Docs menu

Reference

Changelog

Each release of the LexLint plugin bundle since 1.40.0, newest first. Update the plugin in your client to get the newest. In Claude Code that is claude plugin update lexlint@lexlint, then restart your session.

1.83.0

  • A court ruling on a finding now says whether LexLint read its judgment. Each ruling in court_action carries basis: judgment_read, or reported for a ruling LexLint has not read and holds on secondary sources, listed in reported_by as {publisher, url}. A reported ruling's court line ends its "by" with , reported by A and B, and the skill says, wherever it cites one, that its outcome is as those sources report it. A ruling LexLint read prints as before.

1.82.0

  • The bundle now carries a power for Kiro, in its kiro folder. In Kiro, import a power from the repository URL https://github.com/ungovr/lexlint/tree/main/kiro and it brings the same four skills and the same server as every other client. Nothing changes for Claude Code or Codex: no tool, argument, field or schema changes.

1.81.1

  • The skill and AGENTS.md name the jurisdiction of every AI act they mention, as in "the EU AI Act", because several jurisdictions now have an AI act of their own. Wording only: no tool, argument, field or schema changes.

1.81.0

  • Eighteen places now use their UnGovr Atlas name, such as us/ny/city/new-york for New York City. Every old name still works, and your triage carries over.
  • When a jurisdiction you declared by an old name now names another jurisdiction, the lint says so and asks before changing your profile.
  • The run summary keeps one row per law when a jurisdiction is declared under two of its names.

1.80.0

  • The LexLint catalog is now CLD, the Common Legal Duties. From this version on, the IDs in a finding's catalog carry the CLD prefix, as in CLD-0725. They were LXD until this version, and those IDs and their links keep working: the number is the identity, so an ID or a catalog page address written with either prefix names the same entry.
  • The schema accepts both prefixes in catalog, so a lexlint.yml written by an earlier version, with IDs that were LXD until this version, still validates.

1.79.0

  • A public-sector profile that never said which kinds of public body run or buy the software now hears what that silence hides. When public_sector is body or supplier, public_sector_functions was not sent and no education id is declared or left out, each jurisdiction with school law the run does not show has an info line, <slug>:public-education-undeclared, counting the laws that bind schools, or the companies that run or supply their software. Ask the kinds of public body and send public_sector_functions; naming public_education shows them. Answering without it silences the line, as does a public_sector of none. The existing <slug>:public-functions-undeclared line is unchanged: it counts findings already shown, and either line can appear without the other.

1.78.1

  • The role question no longer ties a role to one law. LexLint routes duty lines by role under AI laws and data protection laws well beyond the EU AI Act and the GDPR, so roles is the position the company holds under each jurisdiction's own law, whatever that law calls it. Colorado's developer is a provider. The CCPA's business and India's data fiduciary are each a controller, and the CCPA's service provider is a processor.
  • none means no law the app is under gives the company that role. A company with no users in the European Union can still be Colorado's developer, and answering none for that reason shows its own duties as another party's. If your lexlint.yml answers none only because the app has no EU users, answer again on your next run.
  • The provider sentence now reads: you develop an AI system or model, have one developed, or substantially modify one, and offer it or put it into service. It used to require putting it on the EU market under your own name, which left out Colorado's developer. The schema's two role descriptions say the same as the question.

1.78.0

  • A decision that fits none of the eight kinds can now say so. List a kind the software does not decide in under activities_left_out, and the law written only for that kind no longer reaches a bare high_risk_decisions. Fraud screening is the case that needed it: credit_decisions and the EU AI Act's credit rule both exclude fraud detection, so a fraud model is high_risk_decisions with all eight kinds left out. It keeps the law every automated decision owes, such as GDPR Article 22, and drops hiring, patient-care and other law written for one kind.
  • The skill records that no, and the question form has a "None of these" answer that leaves out every kind not picked. The <slug>:decision-domain-undeclared line counts only the kinds not yet answered, and says how to answer no. A declaration that never sends activities_left_out gets exactly what it got before.

1.77.1

  • ships_encryption now means encrypting data or agreeing keys to keep data confidential, whether in your own code, through the platform's cryptography APIs or with a library you bundle, or bundling a cryptography library that does. Hashing, password hashing and signing on their own are no longer this, and neither is encrypting only the passwords, tokens or session cookies that control access. Encryption through the platform's own APIs (for example WebCrypto, Node's crypto, the Java Cipher class or .NET's AesGcm) now is. HTTPS through the platform's stock client is still not this. Export-control law draws the same line: it controls cryptography that keeps data confidential, not cryptography that only authenticates. If your lexlint.yml declares ships_encryption only because the app hashes passwords, signs tokens or encrypts its session cookies, remove it on your next run.

1.77.0

  • When LexCode is installed, the skill starts the declaration from its evidence. It runs lexcode version, then lexcode scan --json, which reads the repository on your machine and writes nothing into it. Your code never leaves the machine; LexCode's only network call is a one-time download of its pinned scan engine. Each proposed activity then lists where the code appears to perform it or where a dependency enables it, as file:line and the rule that matched, three at most with a count of the rest. A weaker match is shown as worth a look, never as a proposed activity. On a run narrowed by app.scope, only evidence from files inside the scope is used, because the scan reads the whole repository. A match is evidence for the question and never its answer: you still confirm every activity, and one LexCode does not show can still be true.
  • When LexCode is not installed, the skill says so in one line, notes that npx @ungovr/lexcode scan --json runs it without installing, and reads the code itself as before. It never installs anything. LexCode is described at https://lexlint.io/lexcode

1.76.0

  • A second answer for software run by or sold to schools: is it run by a school, district, college or university, public or private (body), supplied to them (supplier), or neither (none)? Send it as regulated_sector, beside any financial answer: {"education": "supplier"}. A duty the school owes, such as a student-records law's disclosure rule, then reaches a vendor as its customer's duty instead of its own, and nothing is added or removed. The skill asks it with the education level, and the manifest schema accepts it. A public_sector of body or supplier answers it for you when public_sector_functions names public_education.
  • A run that declares a level and has no answer carries one info line, <slug>:education-sector-undeclared, counting the findings the answer would move. An education answer leaves the financial question open, and the reverse.

1.75.1

  • A jurisdiction declared by another of its names, such as its Atlas path (us/ca/san-diego/city/san-diego for us/ca/san-diego) or a law slug it was known by before, is linted as the jurisdiction it names. The merge step reported it as not linted, and when both names were declared it counted that jurisdiction's instruments twice. It now reads the declared name from each finding's id and from the jurisdictions the run says it linted, so the report counts that jurisdiction once.
  • The same step now matches a profile that spells a jurisdiction as an ISO code or an Atlas ID (US-CA, urn:ungovr:us/ca) to the slug the run answered with, instead of reporting it as not linted.
  • Declaring a city beside its state can lower distinct_instruments. A few of the city's findings, such as its crawl posture, are the state's own read again but arrive without resolved_from, and earlier versions counted them as distinct. They now count as mirrors, so the number is the law the run actually returned.

1.75.0

  • A finding can carry catalog, the IDs of the LexLint catalog entries it belongs to. Each ID has its own page: LXD-0725 is at https://lexlint.io/catalog/LXD-0725 and the others follow the same pattern. The server has sent them since the catalog went live, but the manifest schema did not list the key, so the merge left it out of lexlint.yml and reported it as a field an update would pick up. The schema now accepts it and lexlint.yml keeps it.

1.74.0

  • get_law now answers with an index: one short row per instrument, with its record_id, name, status, topics and whether it is in force, and none of what it requires. The skill reads the instruments it needs with a second call, passing up to five record_id values as instrument with the same jurisdiction. The largest jurisdictions used to answer with several megabytes, which clients save to a file instead of reading; the index fits in the conversation. detail: "full" still returns the whole file, and earlier versions of the plugin keep getting it by default.
  • The .lexlint/ cache keeps the instruments the skill read in full, keyed by record_id, and stores the index apart from them, never as the law.
  • Setting up Codex or another MCP client by hand now adds an X-LexLint-Bundle header naming this version, so the server answers in the shape this version reads.
  • Three roles for software run by or sold to schools: serves_k12_schools (K-12 schools or districts, charter and private schools included), serves_higher_education (colleges or universities, community colleges included) and their parent serves_education_institutions. The manifest schema accepts them, and the skill asks for the level whenever a project declares serves_minors or names public_education, because school law binds a school's vendor whether or not its users are children. Until it is answered, serves_minors is matched as if the software serves both levels, with an info coverage line, <slug>:education-undeclared, counting the laws shown for that reason.

1.73.0

  • Every option the declaration asks you to pick now has a sentence beside it saying what it means: the EU AI Act and GDPR roles, the public-body and financial questions, and the kinds of decision, content, outreach, chatbot, financial firm and model provider. A role's sentence comes from the LexLint glossary, and the form, the tool schemas and this skill print the same one.
  • When the skill asks for your roles, it gives you each role's sentence as written, so you answer from what the law means by the term.

1.72.1

  • The merge step now says what to do on a client that has python3 but no mktemp to make the working directory: write the block yourself, the same by-hand route it already gave for a client without python3 and PyYAML. Nothing about a run changes.

1.72.0

  • Two roles for the companies that build the largest AI models: provides_general_purpose_ai_model (you put a general-purpose AI model on the market under your own name) and is_frontier_developer (you trained a model with more than 10^26 operations). The EU AI Act's general-purpose model chapter and the frontier model acts (California's SB 53, New York's RAISE Act and others) now bind these roles rather than trains_models, so a team that fine-tunes a classifier is no longer told them.
  • A declaration that names trains_models and neither role does not get those laws. Each place that holds one gets an info coverage line, <slug>:model-role-undeclared, counting them, and set_profile and the form ask. List a role the company does not hold in activities_left_out.

1.71.0

  • A new activity for de-identification, pseudonymization and re-identification law: processes_deidentified_data. Your software strips or replaces the identifiers in personal data to de-identify, pseudonymize or anonymize it, or receives, shares or links data that has been through that with other datasets. It is something your software does, so the code can show it: a tokenizing or masking step, a k-anonymity or differential-privacy library. Encryption alone is not this.
  • Pseudonymized data usually stays personal data, so declare processes_personal_data beside it.
  • It joins the published activity list with the first law that turns on it. Until then, declaring it adds a coverage line and no finding. It implies no other activity and nothing implies it, so every existing declaration is answered as before.

1.70.0

  • Four channels under automated_outreach, so a newsletter sender is not told telemarketing law: places_automated_calls, sends_automated_texts, sends_commercial_email and sends_faxes. Each implies automated_outreach. Declare every channel your software uses.
  • A declaration that names automated_outreach and no channel keeps every law it was shown. Each jurisdiction where a channel would narrow the findings has an info line, <slug>:channel-undeclared, counting them.

1.69.0

  • Two kinds of chatbot under deploys_chatbot, so a customer-support bot is not told companion-chatbot or AI-therapy law. deploys_companion_chatbot is a chatbot that simulates a personal, social, emotional or romantic relationship or companionship with its user. deploys_mental_health_chatbot provides, or is offered as providing, therapy, counseling or mental or behavioral health care. Each implies deploys_chatbot.
  • Most chatbots are neither, so a declaration can say so: activities_left_out: [deploys_companion_chatbot, deploys_mental_health_chatbot].
  • Until it is answered, deploys_chatbot is matched as if it is both, so nothing you were shown goes away on its own. Each jurisdiction where an answer would narrow the findings has an info line, <slug>:chatbot-kind-undeclared, counting them.

1.68.0

  • A new question for government software. When the answer to "is this software run by a public body, sold to public bodies, both, or neither?" is body or supplier, the lint now also asks which kinds of public body: general (a city hall, a state department, a federal agency), law enforcement, corrections, courts and prosecutors, public education, public health, elections, public benefits, or emergency services. Send the answer as public_sector_functions. A duty that binds only another kind of public body is then shown as someone else's, so a vendor to police no longer sees, as its own, a duty that binds only school districts. Duties that bind every public body always reach you.
  • Until it is answered, each jurisdiction with such a duty has an info line, <slug>:public-functions-undeclared, counting the findings an answer would move. With it answered, <slug>:public-functions-narrowed counts the duties it moved, by kind.

1.67.1

  • The bundle's description now calls LexLint a lint for the law that governs software, rather than a compliance lint. LexLint gives legal information: each finding is a research summary of published law, not a judgment about your app. Nothing about a run changes.

1.67.0

  • Two new activities for export-control and sanctions law. ships_encryption: your software implements cryptography, or bundles a library that does, beyond calling the operating system's or platform's own TLS or cryptography APIs. The code can show it: a cryptography library in the dependency tree or in vendored source, a custom cipher. Calling HTTPS through the platform's stock client is not this. serves_sanctioned_destination: your software is offered to people in a country under comprehensive US sanctions.
  • You do not have to declare the second one. When your declaration lists Cuba (cu), Iran (ir) or North Korea (kp), the lint sets it for you and says so in an info line for each of those jurisdictions. Declare it yourself only when your app is offered to people there and you have not listed them.
  • Each joins the published activity list with the first law that turns on it. Until then, declaring one adds a coverage line and no finding. Neither implies another activity and nothing implies them, so every existing declaration is answered as before, except that a declaration listing cu, ir or kp now carries the info line.

1.66.0

  • Two new activities for digital identity and e-signature law. relies_on_digital_identity: your software accepts a digital identity wallet, a verifiable credential or attestation, or an identity-verification service's result to check who a person is, their age or another attribute. collects_e_signatures: your software asks a person to sign an agreement or a record electronically, in its own code or through an e-signature service. Both are things your software does, so the code can show them: a credential verifier, an identity-verification SDK, a signing flow. A password or a social sign-in is not the first, and a checkbox accepting your terms is not the second.
  • Each joins the published activity list with the first law that turns on it. Until then, declaring one adds a coverage line and no finding. Neither implies another activity and nothing implies them, so every existing declaration is answered as before.

1.65.0

  • A new activity, processes_personal_data: your software collects, stores, uses or shares information about a person who can be identified, such as an account, a contact form, analytics that follow visitors, or an order history. It is something your software does, so the code can show it: a users table, an auth provider, an analytics SDK, a form that stores an email address.
  • It is what privacy law turns on now. Before, privacy law reached apps through the AI activities, so a crawler or a chatbot was told every general privacy law while an app that only held customer accounts was told none. A privacy law now reaches a crawler, a model trainer, a chatbot, a caller or a biometric system only where its own text names that conduct.
  • Until your declaration answers the question, a run that declares any activity your code settles is answered as if it processes personal data, and says so in a coverage line. Declare processes_personal_data if it does; if it holds nothing about anyone, add activities_left_out: [processes_personal_data] to the profile.

1.64.3

  • The bundle's descriptions now name export-control law among the topics the lint reads: what software must clear before it is exported or offered abroad, namely the classification and authorization an encryption item needs, the end users and end uses an export may not reach, and the comprehensively sanctioned destinations it may not go to. The law library holds no laws in it yet, so every run reports it as not yet researched for each jurisdiction until its first laws load. Nothing you declare or call changes.

1.64.2

  • The bundle's descriptions now name cloud-service law among the topics the lint reads: what a provider of a hosted cloud service owes its customers, namely switching and exit, limits on switching and egress charges, interoperability, and safeguards against foreign governmental access to the data it holds, starting with the EU Data Act. Only a run that declares provides_cloud_services is told a jurisdiction's cloud-service law has not been researched; every other run is unchanged. Nothing you declare or call changes.

1.64.1

  • The topics LexLint reads now include digital identity and e-signature law: the duties a service takes on when it relies on a digital identity wallet, a credential or an attestation, and when an electronic signature or record counts. The law library holds no laws in it yet, so every run reports it as not yet researched for each jurisdiction until its first laws load.

1.64.0

  • A new activity, ships_consumer_interface: your product has a website, app or other screen that members of the public use to buy, book, read or reach a service. It is something your software does, so the code can show it: public pages, app screens, a storefront, a booking or sign-up flow. A tool only your own staff use does not count. Declare it beside ships_mobile_app when the app is both.
  • It is the trigger for digital-accessibility law. No law in the library is tagged with it yet, so declaring it today adds a coverage line and no finding; findings arrive once the first documents load. No other activity implies it and it implies nothing, so every existing declaration is answered as before.

1.63.1

  • The bundle's descriptions now name digital-accessibility law among the topics the lint reads: what a product you sell, or a service you offer to the public, must do so that people with disabilities can use it, starting with the European Accessibility Act, which has applied since 28 June 2025. Until a jurisdiction's accessibility law is researched, a run there says so as a coverage warning. Nothing you declare or call changes.

1.63.0

  • A sixth role, provides_cloud_services: the company behind your app offers it to customers, under a contract, as a hosted service that stores or runs their own data or workloads (infrastructure, platform or software as a service). Running your own app on somebody else's cloud is not this role. Like the other roles it is your answer, never something read from the code.
  • Declaring it today reaches the cybersecurity laws that bind any organization, as every role does. The cloud-provider duties in the EU Data Act, such as the end of switching charges on 12 January 2027, reach it once they are in the law library.

1.62.0

  • A law's name now arrives whole, as its own name field on every instrument finding. Some names hold a colon themselves, such as "High-Risk AI: Public-Authority Deployer Obligations", and the run's first look used to cut the name at its first colon, so half of it opened the sentence beneath. The first look now prints name whole and the rest of summary under it.
  • summary is unchanged, and so is every finding id. The next merge writes each instrument finding's name into lexlint.yml, one line beside its summary, and moves nothing else.

1.61.0

  • generates_content has four media kinds under it: generates_text, generates_images, generates_video and generates_audio (speech, singing, music and other sound). Declare each kind of output your software makes, and generates_content comes with it. A rule written for one medium, such as a voice-cloning law, then reaches only software that makes that medium.
  • A declaration that names generates_content and no kind is answered exactly as before, with every kind's rules, and each jurisdiction where a kind would narrow them has an info line, <slug>:medium-undeclared, counting those findings. set_profile asks which kinds.
  • A kind is something your software does, not who you are, so a library or framework may declare one in its ACTIVITIES.md.

1.60.1

  • Step 4's merge script now writes its temporary file under a new name it creates for itself, so a link committed in a repository under the old fixed name can no longer send the write to a different file. Update if you run LexLint in repositories you did not write.
  • A finding whose text carries a control character, such as the residue of a statute extracted from a PDF, is written so that the next merge can read lexlint.yml back. Before, one such character could leave the file unreadable until it was edited by hand.
  • A key inside a finding's nested fields is quoted whenever YAML would read it as something else, so no key can add a line of its own to lexlint.yml.
  • Where the merge script has to be fetched rather than run from the skill, step 4 puts it in a new private directory from mktemp -d instead of a fixed name in /tmp, and runs it only when it names this bundle's own version. Nothing you declare or call changes.

1.60.0

  • Three starter prompts in the Codex manifest (interface.defaultPrompt), the ones a client shows before the first message. The first asks for a lint and names no app, so your agent asks which app to lint; the other two look up the law and need no account.
  • The skill and AGENTS.md alike say to lint only an app whose code your agent can open: the folder you have open, a public repository, one you connected, or code you paste into the chat. When you ask for a lint without saying which app, your agent asks, offering the open folder first when there is one. When no repository is open, as in a chat on a phone or on the web, it also asks where the code is, and it does not build a declaration from a description. Where it can open the code but not write to it, it shows the confirmed lexlint.yml for you to commit.

1.59.0

  • A new finding kind, derived, off by default. Add derived: true to the profile in your lexlint.yml and a run adds one finding per record an app holds to meet the deadlines the matched laws set: a recorded moment for each start an incident-notification deadline counts from (derived:event_time), and a recorded jurisdiction of residence or location for each affected person (derived:jurisdiction_signal). Each is always info, is about the run rather than one jurisdiction, and lists every law it rests on, with whether that law states the record or LexLint infers it. It stays off unless you ask for it while its wording is under legal review.
  • derived is a new optional profile key, true or false, accepted by set_profile, run_lint and upload_lint_run and by the schema's profile. With no key the server default applies, which is off.
  • Six fields on a derived finding, all additive. Five are new: capability (the record, as key and words), stated_by and inferred_from (how many of the listed laws name the record themselves, and how many LexLint infers it from), derived_from (each law it rests on, with its bases) and moments (on derived:event_time only, each start a deadline counts from). The sixth is basis, which posture and customer-duty findings already carry; here it says what the listed laws state and what LexLint infers. A derived finding's id begins derived:, and the schema's kind enum gains derived.
  • The skill and AGENTS.md alike describe the kind in the severity model. The skill tells your agent never to ask about derived, to send the key through set_profile, run_lint and the upload exactly as your manifest holds it, to triage each derived finding as one code work item titled by its capability.words, with no jurisdictions key when it is the item's only finding, and to report its counts rather than its list of laws.
  • The merge script carries the new fields into lexlint.yml, in the order the schema declares them.
  • On a split run, where your agent divides one declaration across several run_lint calls, a derived finding in lexlint.yml covers only the jurisdictions of the first call carrying the id. The run stored on the portal is rebuilt whole and covers them all; run the lint unsplit to have the whole-run finding locally.

1.58.0

  • A new declaration question, flows: where your software stores or sends personal data across a border. Write it into lexlint.yml under profile.flows, one entry per route, for example [{"from": "eu", "to": "us", "data": "personal", "basis": "contract_clauses"}], or [] when no personal data leaves the jurisdiction it was collected in. data is personal or sensitive, and basis is the transfer mechanism the route relies on: adequacy, contract_clauses, binding_rules, certification, authority_approval, consent, derogation, or unknown. Each cross-border transfer finding then names, in flows, the declared routes that leave its jurisdiction. No finding is dropped or downgraded on a flow yet, so a run shows the same findings with or without it.
  • A jurisdiction with cross-border transfer findings carries one coverage line, <slug>:transfer-flows, counting them and saying what was declared: it asks for flows when they were not sent, and for the basis of any route declared as unknown.

1.57.0

  • The lexlint skill is now a directory: a short SKILL.md that your agent loads when the skill starts, and a references/ folder of files it reads only when a step needs one, each named in SKILL.md with the moment to read it. That is the shape the Agent Skills standard asks for, which keeps SKILL.md under its size budget. A client that reads a long file in slices could miss a step of the old single file; now an agent loads the loop and its rules up front and the detail of each step as it reaches it. No rule has changed, only which file states it, except as listed here: the key, update, sign-in and one-run scope steps are now worded for any client, with each client's own command in references/clients.md, and SKILL.md gains a short list of the rules to know before a run starts. One step's wording changed as well: route 2 of the large-response step, in the skill and in AGENTS.md alike, now says that no recipe for that call ships and to take route 3 otherwise, instead of pointing at a recipe that does not ship.
  • The split-run paragraph of the large-response step, in the skill and in AGENTS.md alike, now lists every activity that can raise an activity: coverage warning on a split run; it named 9 of the 25 by name.
  • The commands each client declares (install, key, update, restart, sign-in and one-run scope) appear in the skill only in references/clients.md, its per-client setup steps, so the same skill reads correctly in every client that loads a skill folder. AGENTS.md stays one file.
  • Each client's entry under Client setup, in references/clients.md and in AGENTS.md alike, now gives that client's restart step, which the key and update steps both end on.
  • SKILL.md declares its license, what it needs to run (network access to the LexLint server, and python3 with PyYAML for the merge step) and this bundle's version in its frontmatter.
  • The merge step's script ships as a file, skills/lexlint/scripts/merge.py, so your agent runs it where the skill is installed instead of writing a few hundred lines to a temporary file on every run. It is the same program AGENTS.md carries inline, byte for byte, has no execute bit, and makes no network call. The skill runs it with python3 by its installed path, from your repository root, or with uv run the same way where python3 has no PyYAML: its header declares the dependency. If your client loads the skill's text without its files, the skill takes the same script from AGENTS.md instead.
  • The merge script has a --help with worked examples, a --dry-run that prints the counts and writes nothing, and a distinct exit code for each way it stops (3 for a missing run file or an empty run, 4 for a manifest it cannot read or write, 5 for a run file of the wrong shape), with only its JSON summary on stdout and every message on stderr. An unreadable --previous manifest or a manifest that is not YAML now stops with a message instead of a Python traceback.
  • lint.tool in your manifest is the --tool value the procedure passes, this bundle's own version, and the README's sample manifest shows that value instead of a long-stale one.
  • The skill's description, the text your agent reads to decide whether to load the skill, is rewritten and measured. It now tells the agent to load the skill first, before touching code, when a change adds or alters what the app does with people, their data or other sites (collecting personal data, automated email or messages, a chatbot or other generative AI feature, training on user data, crawling, voice or face capture, decisions about people), even when the request never mentions law, and says what it is not for. On 22 labeled requests the old text loaded the skill on none, and the new one loaded it on every request it should and on none it should not. That was measured on the bundle without its commands, which is the shape this release ships (the next entry): until now, in Claude Code the /lexlint command shared the skill's name and its description was the one the agent read.
  • If you decline a key, the sign-in or the lint itself, the skill now says in one line that the lint was offered and declined, and goes back to the request that brought it in. The lint is advisory and never blocks the work. AGENTS.md says the same.
  • The plugin's four commands are skills now, and their names changed. In Claude Code lists them as /lexlint:lexlint (the lint), /lexlint:lexlint-key, /lexlint:lexlint-upload and /lexlint:lexlint-feedback, and asking in your own words loads the same skills. After claude plugin update lexlint@lexlint and a restart, /lexlint, /lexlint-key, /lexlint-upload and /lexlint-feedback are no longer commands. A typed short name can still reach its skill, as /lexlint-key did in a measured run, but the listed names are the ones to use. The reason is reach: a command was a Claude Code convention, while every client that reads a skill folder, Codex among them, now gets all four, and in Claude Code the old /lexlint command loaded in place of the skill it shared a name with.
  • The key, upload and feedback skills are written from the same source as the lint, so their rules cannot drift from it. The key skill looks for a saved key before it offers a route, checks a key against the server before saving it, and sends your agent to your client's own entry in references/clients.md for where the key goes and how to restart.
  • Passing a path with the request is now step 1 of the lint, for every client: a path ending in .yml or .yaml is the manifest, any other path is the scope for that run, both at once is the manifest first, a path that does not exist stops the run, and a scope from the request is never written to the manifest. In Claude Code that is /lexlint:lexlint <path>.
  • The upload's consent preview, in the skill and in AGENTS.md alike, now lists the declared activities and, when the run carries them, the public-sector and regulated-sector answers, since the call sends them. The feedback step shows its payload in a block before it sends. AGENTS.md no longer names a Claude Code command in its upload section.

1.56.0

  • A sixth license class under provides_financial_services: is_crypto_asset_provider, for a crypto-asset or virtual-asset service provider (an exchange, custodian, broker, transfer service or token issuer), or software supplied to one. Declare it and the role comes with it, so every rule that binds any financial firm still reaches you; a rule written for crypto businesses alone now reaches only this class.
  • is_payment_provider no longer covers crypto-asset service providers: it is a payment or e-money institution or a money transmitter. A crypto business that declared only is_payment_provider should add is_crypto_asset_provider: MiCA's rule on recording client communications now reaches the new class alone, so that finding stops appearing until you do. Rules that name both kinds of firm, such as Cyprus's DORA designation and Palestine's payments decree, reach either declaration. A business that also transmits money declares both classes.

1.55.0

  • The procedure now covers an install that signs in instead of using a key. When check_access reports credential: "none", your agent skips the key steps and never mints a trial, reads the law straight away up to the free lookups free_lookups reports, and, when a tool asks for sign-in, tells you how for your client: /mcp in Claude Code, or the Connect prompt in the Claude apps. Signing in from Codex is not open yet, so Codex keeps using a key. An install that uses a key changes nothing.

1.54.1

  • A LexLint report now ends with the link to the stored run, on a line of its own, so it is the last thing you read instead of sitting above the findings.
  • /lexlint-key's check of a key now sets its own time limit, so it runs as written on a Mac. Nothing you declare or call changes.

1.54.0

  • A new declaration question, roles: which role the maker of your software holds under the EU AI Act (provider, deployer, importer, distributor, product manufacturer or authorised representative) and under the GDPR (controller or processor). Write it into lexlint.yml under profile.roles, for example {"ai_system": ["provider"], "personal_data": ["processor"]}. A duty line that binds a role you do not hold now sits in requires_elsewhere instead of requires, and the finding names the roles it was judged under in role. A run without it says how many findings an answer would move, in a coverage line per regime. Only the European Union's own rows are tagged by role so far.
  • Each instrument finding carries reading: whose reading its lines are (LexLint's), the day research read the source, and the guidance and court rulings that also read the law, each with the day it was issued or the day LexLint recorded it.

1.53.2

  • /lexlint and /lexlint-key now say that the Claude desktop app never reads a shell profile, not even after a full quit and reopen. A key saved only in ~/.zshrc or another profile is diagnosed as such, and the fix offered is /lexlint-key, which saves the key where every start of Claude Code reads it. The README's "Get a key" says the same. Nothing you declare or call changes.

1.53.1

  • LexLint's server now keeps a record of each request: what it was, which coding tool sent it, what kind of credential it carried, whether it succeeded, and the country and region of the connection. It holds no IP address, key or account, and nothing from what you linted. The README sets it out in full, under Feedback. Nothing you declare or call changes.

1.53.0

  • high_risk_decisions has eight decision domains under it: employment_decisions, credit_decisions, insurance_decisions, housing_decisions, education_decisions, health_care_decisions, public_services_decisions and justice_decisions. Declare each kind of decision your software makes or scores about people, and high_risk_decisions comes with it. A rule written for one kind of decision, such as a hiring law, then reaches only software that makes that kind.
  • A declaration that names high_risk_decisions and no domain is answered exactly as before, with every domain's rules, and each jurisdiction where a domain would narrow them has an info line, <slug>:decision-domain-undeclared, counting those findings. set_profile asks for the domains.
  • A domain is something your software does, not who you are, so a library or framework may declare one in its ACTIVITIES.md.

1.52.0

  • provides_financial_services has five license classes under it: is_bank, is_lender, is_insurer, is_securities_firm and is_payment_provider. Declare the class or classes your software's financial law comes from (a bank that lends declares two), and the role comes with it. A rule that binds one class of firm then reaches only that class, so a lender is not told a broker-dealer's rules.
  • A declaration that names the role and no class is answered exactly as before, with every class's rules, and each jurisdiction where a class would narrow them has an info line, <slug>:financial-class-undeclared, counting those findings. The skill now asks for the class together with regulated_sector.
  • The role's definition says what it always meant: a license held, or software supplied to a firm that holds one. Moving money alone is not it.

1.51.0

  • The bundle ships schema/activities.schema.json, the schema for ACTIVITIES.md: a file at a repository's root that declares which legal activities each package it ships performs or enables, which it rules out, and which counterparties it necessarily talks to. The activities are the 24 the lint already accepts, each with a page in the registry at https://lexlint.io/activities
  • The bundle carries its own ACTIVITIES.md: a library that performs none of the activities and talks to mcp.lexlint.io for every run.
  • Four activity definitions the lint shows are spelled in US English. Their meaning is unchanged. Nothing you declare or call changes.

1.50.2

  • The bundle's descriptions now name product-liability law among the topics the lint reads: who answers in damages for harm a product, software or an AI system causes, starting with the EU Product Liability Directive, which makes software a product from 9 December 2026. Until a jurisdiction's liability law is researched, a run there says so as a coverage warning. Nothing you declare or call changes.

1.50.1

  • The README links UnGovr's privacy policy, which applies to LexLint, under "More". Nothing about how a run behaves changes.

1.50.0

  • Recording a call and recording a text chat are now two activities, because the law treats them differently. records_conversations is replaced by records_calls (people talking to each other: a phone or video call, or a meeting held in person or online, including a notetaker that joins one; a voice assistant a caller talks to is processes_voice) and records_text_chat (keeping what users type in a chat, or having a vendor receive it as it is typed, with a person or an assistant answering: live chat, a chat widget, stored transcripts, session replay of typing). Declare the one that matches, or both. A statute that covers only the telephone, such as a telephone-only recording law, now reaches a call recorder and not a chat widget. The old name is retired, not deleted: runs and declarations that already name it still read, marked "(retired)", but a new run that names it is refused, with the two replacements and their definitions. Ask the developer which one applies, because a call and a typed chat differ in law, then update the manifest or saved declaration. Nothing else you declare or call changes.

1.49.3

  • The procedure now names the legal unit a jurisdiction everywhere, never a place: the lead block for each declared jurisdiction, the jurisdiction at the head of each block, and the ISO 3166 code read as the jurisdiction it names. Nothing you declare or call changes, and no field is added, renamed or removed.

1.49.2

  • The README shows the LexLint wordmark at the top instead of the LL icon. The icon is now used for the favicon alone. Nothing about how a run behaves changes.

1.49.1

  • When you have not said whether a public body runs or buys the software, or whether a bank or its supplier does, the run's note about it now counts every finding your answer would change, not only the ones it would move off you whole. A finding that is partly a public body's and partly yours stays at warn whatever you answer, so it was never counted, yet your answer still moves its other duties, and a supplier's answer adds a customer_duty finding for it. Those findings are now counted in <slug>:public-sector-undeclared and <slug>:regulated-sector-undeclared, and the lines say the findings "carry duties that bind only" those parties, which is true of a finding that is only partly theirs. Nothing you declare or call changes. A run that did not send the answer can now carry one of those notes in a jurisdiction that did not carry it before, when the only law there that touches it is partly a public body's or a bank's; no other finding is added or removed. A run that sent the answer reads as it did before.

1.49.0

  • A profile can now say whose duty the financial-services law is, profile.regulated_sector, keyed by sector: {"financial": "supplier"}. The values are body (a bank, insurer or payment institution runs the software), supplier (it is supplied to such entities) and none. A vendor whose customers are banks no longer reads its customers' duties as its own: the incident notices and reporting duties a bank owes arrive as customer_duty findings, a provider's contract terms stay yours, and a law that binds anyone is unchanged. It moves duties and never adds a match, so a vendor still declares provides_financial_services. A finding the answer cannot move, a law that binds only public bodies among them, carries no owed and is read as it is without the answer.
  • set_profile asks the question in its next step when provides_financial_services is declared and the answer was not sent. A run without it says so: each jurisdiction where financial-law duties would move carries one info line counting them, <slug>:regulated-sector-undeclared. Nothing changes for a profile that does not declare the role.
  • run_lint, set_profile and upload_lint_run take regulated_sector, and the run echoes it. Send it to upload_lint_run whenever the run had it.

1.48.1

  • The command in the procedure that prints the run after run_lint could not be pasted into a shell: a single apostrophe in its text ended the quoted program early, and the shell stopped with a syntax error. It now runs as written, and prints the same words as before. Nothing you declare or call changes.

1.48.0

  • A run that does not say whether a public body runs or buys the software now says so itself. Each jurisdiction where a law binding only public bodies matched carries one info line counting them, and set_profile asks the question in its next step when the answer was not sent. The same law no longer appears at two severities in two sessions without a reason given.
  • A strategy, a charter or a regulator's guidance that matched your declaration is no longer reported as a duty. These records bind nobody on their own, so one info line per jurisdiction names them as context instead.
  • generates_content now means output that reaches the app's users or the public. A tool whose AI output only its own team reads does not declare it.
  • run_lint takes brief: true, for a client with no LexLint procedure that shows findings to a person. Each finding comes back as one line: its summary and first duty clipped to 160 characters, with the citation, link, when the law binds and whose duty it is. On a customer's 61-finding run that is about 3,700 words where the full run is about 25,000. The plugin never sends it: the procedure needs the full findings to write lexlint.yml.
  • Every run_lint result carries replay, a short reference to quote when you tell us about a run. It names the bundle, the law library build, the moment the run was judged and a digest of the declaration, so we can rebuild exactly that run. Nothing about the run is stored to make this work; the feedback step now puts it in the summary for you.

1.47.0

  • When a court has blocked a law, struck it or part of it down, or upheld it after a block, the finding now says which ruling did it. A new field, court_action, carries each ruling's name, its court, the day it was decided, what it did, the parts of the law it reached when it reached only some, where it stands now (an appeal filed, affirmed, reversed) and its case page on LexLint, plus a flag when a suit against the law is pending. It is absent when no court has acted, which is most laws.
  • The run printed after run_lint adds a line under any law a court acted on, for example "blocked 2025-08-29 by Kohls v. Bonta (United States District Court for the Eastern District of California)", and "under challenge in court" when a suit is pending. The brief for counsel names the ruling the same way, linked to its page.
  • lexlint.yml keeps court_action on each finding, and the bundle's schema declares it. Nothing you declare or call changes.

1.46.2

  • LexLint's body of law is now called the law library wherever you and your agent read it: the tool and schema descriptions, the text the server returns, the written procedure, the plugin's commands and README. It used to be called the corpus. Only the word changes. No key, field name, value or step is different, and corpus_built_at keeps its name, so a client that reads it is not affected. The run block the procedure prints labels its third line law library, where it read corpus.

1.46.1

  • The bundle's descriptions now name content-moderation law among the topics the lint reads: the liability of a service for what its users post, notice-and-takedown, and moderation transparency. A profile that declares operates_social_platform meets it. Nothing you declare or call changes.

1.46.0

  • A run now opens in the shape https://lexlint.io and https://developer.lexlint.io show a run in, printed straight after run_lint and before anything is merged: what was declared, where the app operates, by flag and name, and the date of the corpus; then a block for the lead finding in each declared place and for every finding for counsel, each with its place, the law, when it binds, the duty in full, the date it was read against its source and the address of its law page; then a count of what the block shows and of the rest.

1.45.1

  • The bundle now carries this changelog, CHANGELOG.md, with one entry per release, newest first. Read it in the bundle or at https://developer.lexlint.io/changelog on the developer site.
  • The procedure's pointer to LexLint's law pages, which had been a bare domain name, is now the full address https://lexlint.io/law

1.45.0

  • A profile can now declare a public-sector role, profile.public_sector: body for software a public body runs, supplier for software sold to or run for public bodies, both, or none. set_profile, run_lint and upload_lint_run all accept it.
  • With the role declared, each requirement is routed by who owes it. Every instrument finding carries owed. A duty that binds you stays in the finding's requires. A duty that binds only bodies you are not is reported as information, with its lines kept in requires_elsewhere.
  • A duty that your public-sector customer owes and meets through your software arrives as its own customer_duty finding, placed right after the instrument finding it was split from.
  • A caller that does not declare a role gets exactly the output it got before.

1.44.0

  • A state or other sub-national place now reads with its country code first, as "US-California", where it used to read "California (US)". The code, a hyphen and the name take about as much room as a flag emoji and its space, so a Place column lines up in both command-line clients. No field is added or renamed.
  • The procedure's flag rule and its examples use the new form, and the plugin schema's description names both.

1.43.1

  • The copyright line in the bundle's LICENSE file now names the holder as UnGovr, with no company-type suffix. No tool, schema or procedure behaviour changes.

1.43.0

  • Every run_lint finding and every set_profile coverage row for a country, the European Union or the United Nations now also carries jurisdiction_flag, the flag emoji for that place. A state or a city carries none and never borrows its country's. The field is declared in the plugin's schema, and a merged manifest keeps it.
  • The procedure prints the flag, then a space, before the place name in every table and list, and the keyless first-run preview table prints it too.

1.42.0

  • Every run_lint instrument finding, and every instrument get_law returns, now carries in_force, which says when the law binds. It is declared in the plugin's schema, a merged manifest keeps it, and lifecycle stays for existing clients.
  • The procedure prints each finding's in-force words, in_force.words, wherever it says when a law binds.

1.41.1

  • The aggregation topic is labelled "Reuse law", not "News aggregation law".

1.41.0

  • The procedure names the communications topic and the three facts it adds.
  • The automated_outreach activity no longer borrows deploys_chatbot's categories. It now reaches the communications topic's rows, so a profile that declares it gets those rows in place of chatbot-disclosure rows, and its findings change.

1.40.3

  • /lexlint-key checks a key with check_access.
  • LexLint no longer says your key is forwarded to a separate data service. The LexLint server checks it itself. Where get_law holds no data for a jurisdiction, its note now points at https://lexlint.io/law for coverage.

1.40.2

  • Step 1 no longer leaves a row marked ask when the evidence in hand settles it, and it asks an open ask row again before it sets the profile, so a one-word yes can no longer silently drop that row.
  • Step 1 resolves the app's domains before it shows the declaration table.

1.40.1

  • Step 1 proposes the declaration from the code, and you confirm it, on every client.

1.40.0

  • A compact upload's app_scope reaches the portal as the scope object its schema requires.