@skillstech/thunderlang 0.1.6 → 0.1.7

package/CHANGELOG.md

@@ -16,7 +16,7 @@ changes to 0.1.5.
   errors/handlers, events, a pure runtime). `twelveFactorReport(ast)` returns a per-factor verdict
   (`satisfied` | `partial` | `absent`) with evidence + a fix and a 0–100 score; `twelveFactorSummary`
   is the compact form. `compileSource` and the proof envelope now carry a `twelveFactor` summary, so
-  "12-factor compliant" is a claim the proof asserts. CLI: `intent twelve-factor <file> [--json]`.
+  "12-factor compliant" is a claim the proof asserts. CLI: `thunder twelve-factor <file> [--json]`.
   Findings catalogued as `IL-12F-01..13`. Exported from `/core` and the root. See
   `docs/twelve-factor-agents.md` and `examples/TwelveFactorAgent.intent` (scores 100/100).
 
@@ -109,33 +109,33 @@ The executable + interoperable release. Everything is deterministic and requires
 
 - **Executable intent (the Intent Runtime).** `evaluateDecision` (FIRST-hit, full trace),
   `simulateLifecycle` (walk a state machine, reject illegal transitions), and
-  `checkDecisionCases`, powered by a safe no-`eval` expression engine. CLI: `intent run`,
-  `intent simulate`.
+  `checkDecisionCases`, powered by a safe no-`eval` expression engine. CLI: `thunder run`,
+  `thunder simulate`.
 - **First-class tests.** `test` blocks (`case` / `scenario`) inside a `.intent` file, run
-  with `intent test` and `runTests`. The spec proves itself.
+  with `thunder test` and `runTests`. The spec proves itself.
 - **Outcome contracts.** `outcome_contract` binds an outcome to a target; `evaluateOutcomes`
-  and `intent outcomes` judge it met / missed / pending against a delivery `result`.
+  and `thunder outcomes` judge it met / missed / pending against a delivery `result`.
 - **Full five-profile language.** System (`capability`, `interface`), delivery (`release`,
   `result`, `learning`), and design (`component`, `artifact`) profiles join core, product,
   and experience. Governance (`waiver`) and data privacy (`data`) too.
 - **Interop.** Export to DMN, BPMN, NuSMV, JSON Schema, OpenAPI, W3C Design Tokens, and
-  Mermaid , the whole Intent Graph as a paste-anywhere diagram , (`intent export`, `toMermaid`);
-  import from DMN and BPMN with a fidelity report (`intent import`, `importReport`); native
-  graph <-> source round-trip (`graphToSource`, `intent source`); schema migrations
-  (`migrateGraph`, `validateGraph`, `intent migrate` / `validate`); semantic diff + 3-way
-  merge (`intent diff` / `merge`).
-- **Editor support.** A Language Server (`intent lsp`, `startLspServer`) providing
+  Mermaid , the whole Intent Graph as a paste-anywhere diagram , (`thunder export`, `toMermaid`);
+  import from DMN and BPMN with a fidelity report (`thunder import`, `importReport`); native
+  graph <-> source round-trip (`graphToSource`, `thunder source`); schema migrations
+  (`migrateGraph`, `validateGraph`, `thunder migrate` / `validate`); semantic diff + 3-way
+  merge (`thunder diff` / `merge`).
+- **Editor support.** A Language Server (`thunder lsp`, `startLspServer`) providing
   diagnostics, completion, and hover over LSP; a TextMate grammar
   (`syntaxes/intent.tmLanguage.json`) for syntax highlighting.
-- **Onboarding + CI.** `intent init` scaffolds a runnable starter; `intent check <dir>`
-  recurses and gates a whole repo; `intent check --json` and `intent explain <CODE>` for
+- **Onboarding + CI.** `thunder init` scaffolds a runnable starter; `thunder check <dir>`
+  recurses and gates a whole repo; `thunder check --json` and `thunder explain <CODE>` for
   tooling; a composite GitHub Action.
 - **Style intent.** `style_intent` models brand + visual language as a governed
   Experience-profile extension: design tokens bind to a canonical, lockable address space,
   and `accessibility_target` is always a `proposed` claim (never IL-verified). `analyzeStyle`,
-  `styleDiagnostics`, `intent style`, diagnostics `IL-STYLE-001..005`, canonical `StyleIntent`
+  `styleDiagnostics`, `thunder style`, diagnostics `IL-STYLE-001..005`, canonical `StyleIntent`
   node with graph round-trip. Browser-safe via `/core`. Exports to **W3C Design Tokens
-  (DTCG)** via `intent export --format tokens` / `toDesignTokens` (`intent-design-tokens-v1`)
+  (DTCG)** via `thunder export --format tokens` / `toDesignTokens` (`intent-design-tokens-v1`)
   and to a ready-to-use **CSS** custom-property sheet via `--format css` / `toCss`. Experiences
   export to a **Playwright** E2E test scaffold via `--format playwright` / `toPlaywright`.
 - **Security + type diagnostics.** Deterministic checks for the mistakes prompts ship:
@@ -154,21 +154,21 @@ The executable + interoperable release. Everything is deterministic and requires
   only the target lines so comments, formatting, and untouched blocks stay byte-identical. Closes
   the sync fidelity gap: a PM edits fields and IL keeps the comments. Field removal takes the
   field's indented modifiers with it (no orphans). Unmatched/unsupported edits are reported,
-  never applied blindly. Browser-safe. Also a CLI: `intent edit <file> --edits <json|-> |
+  never applied blindly. Browser-safe. Also a CLI: `thunder edit <file> --edits <json|-> |
   --set-goal | --add-guarantee | ... [--write]`.
-- **Verify a code change against its intent (`intent-verify-diff-v1`).** `intent verify-diff
+- **Verify a code change against its intent (`intent-verify-diff-v1`).** `thunder verify-diff
   <intent> --after <code> [--before <code>]` / `verifyDiff()` proves, deterministically and with
   no AI, which of the intent's guarantees/never-rules a change upholds or breaks, and returns a
   gate verdict (PASS/BLOCK, non-zero exit on BLOCK). Blocks on regressions (a claim that held
   before and broke after) and guardrail hits (an added line pushing a never-rule's protected
   secret into a log/response). The keystone of the AI generate-verify loop; honest (catches
   mechanical violations, does not claim to prove correctness).
-- **Intent Atlas + lift-all.** `liftAll(source)` / `intent lift <file> --all` lifts EVERY public
+- **Intent Atlas + lift-all.** `liftAll(source)` / `thunder lift <file> --all` lifts EVERY public
   function in a file into its own inferred mission (not just the first), filtering internal
   helpers (Go: exported-only; Python/Ruby: top-level, non-underscore) , so a whole module reads
   as intent. Powers the Intent Atlas: `scripts/build-atlas.mjs` lifts well-known OSS projects
   (Requests, Express, Flask, gorilla/mux, chi) into a browsable /atlas of ~99 inferred missions.
-- **Prompt -> intent (`intent-draft-v1`).** `draftIntent(brief)` / `intent draft --brief <json|->`
+- **Prompt -> intent (`intent-draft-v1`).** `draftIntent(brief)` / `thunder draft --brief <json|->`
   turns a structured brief into a rigorous, canonically-formatted intent draft PLUS a review
   checklist of what a human must still fill in (unverified guarantee, decision with no default,
   unguarded secret, missing goal). The deterministic half of prompt->intent , an agent produces
@@ -179,9 +179,9 @@ The executable + interoperable release. Everything is deterministic and requires
   intent declares secret (Secret/Password/Token type, pii/sensitive data, or a secret-looking
   name), deeply , so wrapping a logger enforces "never expose the token"; `assertAllowed(name,
   inputs)` runs a declared decision and THROWS `INTENT_GUARD_DENIED` when the intent denies the
-  action , the intent's rules become a hard production gate. `intent guard <file>` previews it.
+  action , the intent's rules become a hard production gate. `thunder guard <file>` previews it.
   Browser-safe.
-- **MCP server for AI agents.** `intent mcp` / `startMcpServer` speaks the Model Context
+- **MCP server for AI agents.** `thunder mcp` / `startMcpServer` speaks the Model Context
   Protocol over stdio, exposing ThunderLang as native tools for coding agents (Claude Code,
   Cursor, ...): `intent_verify_diff` (the gate), `intent_check`, `intent_lift`, `intent_run`,
   `intent_test`, `intent_graph`, `intent_explain`. The agent checks its own output against the
@@ -233,7 +233,7 @@ The executable + interoperable release. Everything is deterministic and requires
   attribution , a metric moving after release is correlation, not proof this feature caused it).
   This closes the "technical success is mistaken for outcome success" gap: an outcome is only
   trustworthy with a guardrail and honest attribution.
-- **Change Lens , what a branch/PR changed by meaning (`intent changes`).** `intent changes
+- **Change Lens , what a branch/PR changed by meaning (`thunder changes`).** `thunder changes
   <base>..<head>` git-diffs the `.intent` files, semantic-diffs each (reusing `diffGraphs`), and
   reports the behavior-level changes: guarantees / never-rules / invariants / decisions added or
   removed, verification removed, and , crucially , a claim that **lost its verification** is
@@ -250,7 +250,7 @@ The executable + interoperable release. Everything is deterministic and requires
   `invariant-without-verification` warns when a global law has nothing proving it (that is exactly
   where a locally-valid change silently breaks the whole system). Invariants count toward
   comprehension C2 (Structured). Example: `examples/TenantIsolation.intent`.
-- **Code generation , deterministic TypeScript from intent (`intent gen`).** `toTypeScript(ast)`
+- **Code generation , deterministic TypeScript from intent (`thunder gen`).** `toTypeScript(ast)`
   (`intent-codegen-v1`, no AI) generates what the intent fully determines , typed input/output
   interfaces, and the **decision logic**, which is real and behaviorally identical to the runtime
   evaluator (proven by a property test over the input space) , and leaves honest `TODO` markers
@@ -259,33 +259,33 @@ The executable + interoperable release. Everything is deterministic and requires
   token becomes a string literal). **Now also generates C# and Java** (`--target csharp|java`):
   typed records + the same first-hit decision logic, translated per language (C# `==` + `.Contains`;
   Java `Objects.equals`, so string equality is value-correct, not reference `==`) via a
-  dialect-aware `exprToCode`. `intent gen <file> [--target typescript|csharp|java] [--out <dir>]`. Pure
+  dialect-aware `exprToCode`. `thunder gen <file> [--target typescript|csharp|java] [--out <dir>]`. Pure
   / browser-safe and exported from `/core`, so the **playground now has a "Code" tab** , change
-  the intent, watch the code change. Completes the round-trip with `intent lift` (code -> intent).
+  the intent, watch the code change. Completes the round-trip with `thunder lift` (code -> intent).
 - **Fix: non-mission root files no longer render as `# null`.** A standalone `event` / `api` /
   `service` / `capability` file has no `mission`, so the graph titled its root node `null` and the
   docs rendered `# null` (visible in the playground's BillingService / API / event examples). A
   new `subjectName(ast)` derives the title from the primary construct, so these render under their
   real name everywhere (graph, docs, generated code).
-- **Comprehension Contract , the C0..C7 understanding level (`intent comprehension`).** The
+- **Comprehension Contract , the C0..C7 understanding level (`thunder comprehension`).** The
   measurable backbone of the Software Understanding System: `comprehensionLevel(ast)` scores how
   well-understood a mission is, deterministically, from C0 (Unknown) through C4 (Verified) which
   IL determines on its own, up to C5 (Observed), C6 (Teachable), and C7 (Governed) which a sibling
   lifts by attaching evidence (`--observed` = OpenThunder/runtime, `--learning` = Skills Tech Talk,
   `--governed` = Guardian + Workspace/Ledger). The ladder is cumulative (a gap caps the level) and
   honest (a level is never claimed on evidence IL does not have; each missing rung names its owner).
-  `intent comprehension <file|dir>` reports the level + the next rung; `intent-comprehension-v1` is
+  `thunder comprehension <file|dir>` reports the level + the next rung; `intent-comprehension-v1` is
   the shared contract every product reads. Pure / browser-safe, exported from `/core`, typed.
-- **Intent Lens , Intent Scope + Focus Graph (`intent focus`).** A Focus Graph is a
+- **Intent Lens , Intent Scope + Focus Graph (`thunder focus`).** A Focus Graph is a
   deterministic subgraph of the Intent Atlas around a selected scope (a mission, a feature
   query, or `--nodes a,b`), with every node tagged by WHY it is in focus (selected / governing
   / dependency / dependent / implementation / verification / risk / contextual) and bounded by
   `--depth`. `makeScope` builds the typed Intent Scope; `buildFocusGraph` the subgraph;
   `intentBrief` a deterministic what/who/guarantees/prohibitions/risks/unknowns brief whose
-  confidence is the weakest in scope (honesty). `intent focus <mission|query|--nodes>
+  confidence is the weakest in scope (honesty). `thunder focus <mission|query|--nodes>
   [--depth N] [--json]`. Built over the existing Atlas (not a fork); pure and browser-safe so
   Studio / OpenThunder / RepoMastery / Skills Tech Talk consume one focused representation.
-- **Focused scanner queries (`intent risks | gaps | unverified | coverage | unknowns |
+- **Focused scanner queries (`thunder risks | gaps | unverified | coverage | unknowns |
   contradictions`).** Part 3 of the Intent Scanner: one deterministic question each over the
   shared Intent IR + Fable findings (`scan-queries.mjs`, `intent-scan-view-v1`), so a person
   can ask "what is unverified?" or "what is the verification coverage?" without reading the
@@ -296,68 +296,68 @@ The executable + interoperable release. Everything is deterministic and requires
   under-counted never-rule verification (and coverage read wrong). Never-rules with a `verify`
   now emit `verified_by` edges + a `verify-declared` status, and `graphToSource` round-trips
   them. Every downstream consumer (OpenThunder, RepoMastery) sees never-verification faithfully.
-- **Code actions + autocorrect (`intent code-actions` / `apply-fix`).** `getCodeActions`
+- **Code actions + autocorrect (`thunder code-actions` / `apply-fix`).** `getCodeActions`
   surfaces the available quick-fixes, safety-graded (`safe` autocorrects and `reviewable`
   diagnostic fixes); `autocorrectSource` applies only meaning-preserving header fixes
   (`goals` -> `goal`, `nevers` -> `never`, stray trailing colons), never a valid keyword
   in another context (a decision's `inputs` sub-block is deliberately left alone).
-  `intent code-actions <file>` lists them; `intent apply-fix <file> [--write]` applies the
+  `thunder code-actions <file>` lists them; `thunder apply-fix <file> [--write]` applies the
   safe ones and reports the reviewable ones for a human. Both pure and browser-safe.
-- **Per-audience docs (`intent docs --lens`).** `intent docs <file>` renders a mission as
+- **Per-audience docs (`thunder docs --lens`).** `thunder docs <file>` renders a mission as
   Markdown; with `--lens <lens>` it produces an audience-specific doc that weaves that
-  lens's IntentLens notes inline next to the input, output, guarantee, or never they
+  lens's ThunderLens notes inline next to the input, output, guarantee, or never they
   annotate, and states up front that notes are documentation, not verification. `--out`
   writes the file; otherwise it prints. `renderLensDoc` is pure and browser-safe.
-- **Intent AI event sink (`intent-ai-events-v1`).** `intent ai approve` / `reject` now
+- **Intent AI event sink (`intent-ai-events-v1`).** `thunder ai approve` / `reject` now
   persist their integration event to an append-only JSON-Lines log at
   `.intent/ai-events.jsonl`, so a project keeps a durable audit trail of every AI action.
-  `intent ai events [dir] [--subject <id>]` reads it back (who did what, and the status
+  `thunder ai events [dir] [--subject <id>]` reads it back (who did what, and the status
   move). Pure sink module (`recordEvent`, `parseEventLog`, `serializeEventLog`, `timeline`),
   exported from the barrel; rejects unknown event types; append-only (never mutates).
-- **IntentLens notes CLI (`intent-notes-v1`).** `intent notes <file>` lists the compiled
+- **ThunderLens notes CLI (`intent-notes-v1`).** `thunder notes <file>` lists the compiled
   `note <lens>:` blocks grouped by lens, each with its target (mission / input / output /
   guarantee / never) and source line; `--lens <lens>` filters to one audience and `--json`
   emits the report. Notes explain meaning for a reader and are never verification. Reuses
   the parser's `ast.notes` (no new parsing).
-- **Intent Ledger (`intent-ledger-v1`).** `intent ledger <file.json>` / `verifyLedger`, `record*`,
+- **Intent Ledger (`intent-ledger-v1`).** `thunder ledger <file.json>` / `verifyLedger`, `record*`,
   `explain` keep the append-only, hash-chained (tamper-evident) record of a project's MEANING and
   history: why a mission was built, who approved it, what was assumed, which inferred intent a human
   corrected, which risks were accepted, what was verified, which lessons went stale. Each entry hashes
   over the previous, so history cannot be quietly rewritten , `verifyLedger` locates any break to the
-  entry. Deterministic (caller supplies timestamps). `intent ledger <file> --subject <id>` explains
+  entry. Deterministic (caller supplies timestamps). `thunder ledger <file> --subject <id>` explains
   one mission's provenance; exit non-zero on a broken chain. Browser-safe.
-- **Intent Simulator (`intent-simulate-v1`).** `intent impact <base> <proposed>` / `simulateChange`
+- **Intent Simulator (`intent-simulate-v1`).** `thunder impact <base> <proposed>` / `simulateChange`
   estimates a change's impact BEFORE implementation: the deterministic BLAST RADIUS (transitive
   reach over the intent graph, by node type), the risk it would introduce, contradictions, and
   release risk , keeping deterministic dependency impact, rule-derived risk, AI-predicted (null in
   deterministic mode), and unknown impact SEPARATE and honest. Browser-safe.
-- **Intent Guardian (`intent-guardian-v1`).** `intent guardian <before> <after>` / `guardianReport`
+- **Intent Guardian (`intent-guardian-v1`).** `thunder guardian <before> <after>` / `guardianReport`
   detects drift a change introduced: what changed (semantic diff by mission identity, rename-safe),
   what intent it affects, the risk it INTRODUCED (findings new in after), what must be reverified
   (changed contract elements + invalidated approvals), and which missions' learning is now stale.
   `needs-attention` only on newly-introduced blocking risk; exit non-zero gates a PR. Browser-safe.
-- **Intent Scanner + Fable (`intent-scan-v1` / `intent-fable-v1`).** `intent scan [dir]` runs the
+- **Intent Scanner + Fable (`intent-scan-v1` / `intent-fable-v1`).** `thunder scan [dir]` runs the
   deterministic pipeline , parse -> Intent IR -> Fable findings -> risk themes , and prints an
   executive/risk summary + a highest-impact remediation sequence; `--json` for the machine report,
   `--ir <path>` to emit the shared Intent IR. Fable is the rule authority OVER the diagnostics
   catalog (risk category + detection strategy + remediation + suppression policy); every finding is
   fully explained (never "AI detected a possible issue"). `scanProject`, `universalPack`,
   `fableRuleFor`, `toFinding` exported. Browser-safe.
-- **Repo-wide health report.** `intent report [dir]` / `buildReport(files)` aggregates every
+- **Repo-wide health report.** `thunder report [dir]` / `buildReport(files)` aggregates every
   .intent file into an intent-health summary (`intent-report-v1`): diagnostics by severity +
   area, top codes, and coverage (guarantees verified, missions with tests, outcomes contracted).
-- **SARIF code scanning.** `intent check <path> --format sarif` emits a SARIF 2.1.0 log
+- **SARIF code scanning.** `thunder check <path> --format sarif` emits a SARIF 2.1.0 log
   (`toSarif`), so diagnostics appear natively in GitHub/GitLab code scanning and SARIF-aware
   IDEs , with rule metadata, level mapping, and precise line regions where known.
 - **Complete diagnostics reference.** Legacy core check codes (`missing-goal`,
   `guarantee-without-verification`, ...) are now documented and explainable via
-  `CORE_DIAGNOSTICS` / `ALL_DIAGNOSTICS`, so `intent explain <any-code>`, `intent rules`, and
+  `CORE_DIAGNOSTICS` / `ALL_DIAGNOSTICS`, so `thunder explain <any-code>`, `thunder rules`, and
   `docs/diagnostics.md` cover everything the check pass emits (60 codes). A guard test keeps it
   complete. The canonical `DIAGNOSTIC_RULES` stays IL-* only.
 - **Canonical proof envelope (`intent-proof-v1`).** The `.intent-proof.json` shape is now a
   published, versioned contract: `intentProofJsonSchema()` (JSON Schema), `validateProof()`
-  (dependency-free structural check), `intent proof --schema`, and a well-formedness gate in
-  `intent verify`. Browser-safe via `/core` so signers/renderers validate the envelope with
+  (dependency-free structural check), `thunder proof --schema`, and a well-formedness gate in
+  `thunder verify`. Browser-safe via `/core` so signers/renderers validate the envelope with
   no Node build.
 - **Browser-safe `/core` subpath**, the committed `intent-graph.schema.json`, and the
   canonical 49-rule `IL-*` diagnostic catalog (60 codes documented including legacy core codes).

package/LICENSE

@@ -1,21 +1,201 @@
-MIT License
-
-Copyright (c) 2026 SkillsTech
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction,
+and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by
+the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all
+other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition,
+"control" means (i) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity
+exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation
+source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but
+not limited to compiled object code, generated documentation,
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or
+Object form, made available under the License, as indicated by a
+copyright notice that is included in or attached to the work
+(an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object
+form, that is based on (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including
+the original version of the Work and any modifications or additions
+to that Work or Derivative Works thereof, that is intentionally
+submitted to Licensor for inclusion in the Work by the copyright owner
+or by an individual or Legal Entity authorized to submit on behalf of
+the copyright owner. For the purposes of this definition, "submitted"
+means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems,
+and issue tracking systems that are managed by, or on behalf of, the
+Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity
+on behalf of whom a Contribution has been received by Licensor and
+subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the
+Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except as stated in this section) patent license to make, have made,
+use, offer to sell, sell, import, and otherwise transfer the Work,
+where such license applies only to those patent claims licensable
+by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s)
+with the Work to which such Contribution(s) was submitted. If You
+institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work
+or a Contribution incorporated within the Work constitutes direct
+or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate
+as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You
+meet the following conditions:
+
+(a) You must give any other recipients of the Work or
+Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices
+stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works
+that You distribute, all copyright, patent, trademark, and
+attribution notices from the Source form of the Work,
+excluding those notices that do not pertain to any part of
+the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its
+distribution, then any Derivative Works that You distribute must
+include a readable copy of the attribution notices contained
+within such NOTICE file, excluding those notices that do not
+pertain to any part of the Derivative Works, in at least one
+of the following places: within a NOTICE text file distributed
+as part of the Derivative Works; within the Source form or
+documentation, if provided along with the Derivative Works; or,
+within a display generated by the Derivative Works, if and
+wherever such third-party notices normally appear. The contents
+of the NOTICE file are for informational purposes only and
+do not modify the License. You may add Your own attribution
+notices within Derivative Works that You distribute, alongside
+or as an addendum to the NOTICE text from the Work, provided
+that such additional attribution notices cannot be construed
+as modifying the License.
+
+You may add Your own copyright statement to Your modifications and
+may provide additional or different license terms and conditions
+for use, reproduction, or distribution of Your modifications, or
+for any such Derivative Works as a whole, provided Your use,
+reproduction, and distribution of the Work otherwise complies with
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+any Contribution intentionally submitted for inclusion in the Work
+by You to the Licensor shall be under the terms and conditions of
+this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify
+the terms of any separate license agreement you may have executed
+with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor,
+except as required for reasonable and customary use in describing the
+origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+agreed to in writing, Licensor provides the Work (and each
+Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied, including, without limitation, any warranties or conditions
+of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any
+risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+whether in tort (including negligence), contract, or otherwise,
+unless required by applicable law (such as deliberate and grossly
+negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special,
+incidental, or consequential damages of any character arising as a
+result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses), even if such Contributor
+has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+the Work or Derivative Works thereof, You may choose to offer,
+and charge a fee for, acceptance of support, warranty, indemnity,
+or other liability obligations and/or rights consistent with this
+License. However, in accepting such obligations, You may act only
+on Your own behalf and on Your sole responsibility, not on behalf
+of any other Contributor, and only if You agree to indemnify,
+defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason
+of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following
+boilerplate notice, with the fields enclosed by brackets "{}"
+replaced with your own identifying information. (Don't include
+the brackets!)  The text should be enclosed in the appropriate
+comment syntax for the file format. We also recommend that a
+file or class name and description of purpose be included on the
+same "printed page" as the copyright notice for easier
+identification within third-party archives.
+
+Copyright 2026 Skills Tech Talk, LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/NOTICE

@@ -0,0 +1,15 @@
+ThunderLang
+Copyright 2026 Skills Tech Talk, LLC
+
+This product includes software developed by Skills Tech Talk, LLC
+(https://thunderlang.dev).
+
+Licensed under the Apache License, Version 2.0. See the LICENSE file.
+
+ThunderLang, the ThunderLang logo, and related marks are trademarks of
+Skills Tech Talk, LLC. The Apache-2.0 license covers the source code only and
+does not grant any right to use these marks. See TRADEMARKS.md.
+
+ThunderLang was previously introduced as IntentLang. The paradigm it implements,
+Intent-Oriented Programming, and its technical vocabulary (Intent Graph, Intent
+Atlas, Intent Contracts, Intent IR, Intent Diff, Intent Proof) are retained.

package/README.md

@@ -6,10 +6,7 @@ and, for decisions, lifecycles, and outcomes, **executes the intent directly** (
 generated). Every output is pure and deterministic: the same source always yields the same
 result, so intent can be diffed, merged, tested, and trusted.
 
-Part of [ThunderLang](https://thunderlang.dev), the intent-oriented language for AI-era software.
-
-> Previously published as `@skillstech/intentlang`. The package was renamed to
-> `@skillstech/thunderlang`; the old name remains as a deprecated alias.
+Part of [ThunderLang](https://thunderlang.dev), the intent language for AI-era software.
 
 ## Install
 
@@ -54,7 +51,7 @@ intent diff <before> <after>      intent merge <base> <ours> <theirs>
 intent lift <file>   intent approve <file>   intent drift <file>
 ```
 
-Run `intent help` for the full reference.
+Run `thunder help` for the full reference.
 
 ## Executable intent
 
@@ -94,7 +91,7 @@ Export the tokens to **W3C Design Tokens**, a drop-in **CSS** sheet, the whole g
 
 The compiler also catches the mistakes prompts ship: a secret-typed field on an event payload
 (`IL-SEC-001`), a sensitive API output with no auth (`IL-SEC-002`), a mistyped field
-(`IL-TYPE-001`), and more , the full catalog is `intent rules` / [docs](https://thunderlang.dev/docs/diagnostics).
+(`IL-TYPE-001`), and more , the full catalog is `thunder rules` / [docs](https://thunderlang.dev/docs/diagnostics).
 
 ## Use as a library
 
@@ -141,10 +138,10 @@ so it keeps bundling everywhere. The `.` entry is this same surface plus the Nod
 Compilation produces a canonical graph of 40 typed node kinds and 20 directed
 relationship types, across five profiles (product, experience, system, delivery, design).
 The vocabulary is closed and enforced (an anti-fork test guarantees the compiler only
-emits canonical types); `intent schema` emits its draft-07 JSON Schema, also shipped as
+emits canonical types); `thunder schema` emits its draft-07 JSON Schema, also shipped as
 the static `intent-graph.schema.json` in this package (CI-guaranteed in sync with the
 code). Consumers (OpenThunder, Repo Mastery, SkillsTech Studio) build to this graph, and
-`intent validate <graph.json>` self-checks a graph against the canonical vocabulary.
+`thunder validate <graph.json>` self-checks a graph against the canonical vocabulary.
 
 ## Output location
 

package/dist/core.cjs

@@ -471,7 +471,7 @@ var IL_AUTHOR_RULE_ROWS = [
   { ruleId: "IL-SEC-002", area: "security", severity: "blocker", blocks: ["release"], summary: "API returns a secret with no auth requirement." },
   { ruleId: "IL-TYPE-001", area: "type", severity: "info", blocks: [], summary: "Field uses an unrecognized (likely mistyped) type." },
   // 12-Factor Agents conformance (twelve-factor-v1). Advisory: an intent's alignment with the
-  // humanlayer/12-factor-agents principles. `intent twelve-factor` scores these.
+  // humanlayer/12-factor-agents principles. `thunder twelve-factor` scores these.
   { ruleId: "IL-12F-01", area: "twelve-factor", severity: "info", blocks: [], summary: "F1 Natural language to tool calls: model dispatch as a decision/command." },
   { ruleId: "IL-12F-02", area: "twelve-factor", severity: "info", blocks: [], summary: "F2 Own your prompts: behavior is an owned, guaranteed contract, not a black box." },
   { ruleId: "IL-12F-03", area: "twelve-factor", severity: "info", blocks: [], summary: "F3 Own your context window: declare a scope boundary." },
@@ -497,8 +497,8 @@ var IL_CORE_RULE_ROWS = [
   { ruleId: "unknown-block", area: "core", severity: "info", blocks: [], summary: "Unrecognized top-level block." },
   { ruleId: "INTENT-ARCH-001", area: "architecture", severity: "warning", blocks: [], summary: "Architecture rule not understood." },
   { ruleId: "INTENT-AI-010", area: "ai", severity: "warning", blocks: [], summary: "Unsupported implementation scope." },
-  { ruleId: "INTENT_NOTE_UNKNOWN_LENS", area: "note", severity: "info", blocks: [], summary: "IntentLens note uses an unknown lens." },
-  { ruleId: "INTENT_NOTE_EMPTY", area: "note", severity: "info", blocks: [], summary: "IntentLens note is empty." }
+  { ruleId: "INTENT_NOTE_UNKNOWN_LENS", area: "note", severity: "info", blocks: [], summary: "ThunderLens note uses an unknown lens." },
+  { ruleId: "INTENT_NOTE_EMPTY", area: "note", severity: "info", blocks: [], summary: "ThunderLens note is empty." }
 ];
 var RULE_PHASES = ["author", "verify"];
 var RULE_OWNERS = ["IL", "OT"];
@@ -572,7 +572,7 @@ function intentProofJsonSchema() {
       sourceProduct: { type: "string" },
       missionName: { type: ["string", "null"] },
       sourceFile: { type: "string" },
-      // sha256:<hex> , the source fingerprint `intent verify` re-checks for drift/tampering.
+      // sha256:<hex> , the source fingerprint `thunder verify` re-checks for drift/tampering.
       sourceHash: { type: "string", pattern: "^sha256:[0-9a-f]{64}$" },
       compilerVersion: { type: "string" },
       generatedAt: { type: ["string", "null"] },
@@ -3359,14 +3359,14 @@ function buildGuard(ast, { denyResults, mask = "[redacted]" } = {}) {
   }
   function decide(name, inputs) {
     const d = decisions.get(name);
-    if (!d) throw new Error(`intent guard: no decision "${name}"`);
+    if (!d) throw new Error(`thunder guard: no decision "${name}"`);
     const r = evaluateDecision(d, inputs || {});
     return { ...r, allowed: !isDenied(r.result) };
   }
   function assertAllowed(name, inputs) {
     const r = decide(name, inputs);
     if (!r.allowed) {
-      const e = new Error(`intent guard: decision "${name}" denied the action (result: ${r.result})`);
+      const e = new Error(`thunder guard: decision "${name}" denied the action (result: ${r.result})`);
       e.code = "INTENT_GUARD_DENIED";
       e.decision = name;
       e.result = r.result;
@@ -3570,7 +3570,7 @@ var FACTORS = [
       const scoped = len(ast.scope?.include) + len(ast.scope?.exclude);
       if (scoped) return { verdict: "satisfied", evidence: `context boundary declared (scope: ${len(ast.scope.include)} include / ${len(ast.scope.exclude)} exclude)` };
       if (len(ast.requires)) return { verdict: "partial", evidence: "dependencies declared but no explicit scope boundary", fix: "Declare `scope include/exclude` so the context window is curated, not unbounded." };
-      return { verdict: "absent", evidence: "no scope declared", fix: "Add a `scope` block to bound what belongs in context (IntentLens/Focus narrows it further)." };
+      return { verdict: "absent", evidence: "no scope declared", fix: "Add a `scope` block to bound what belongs in context (ThunderLens/Focus narrows it further)." };
     }
   },
   {
@@ -4035,7 +4035,7 @@ function toDesignTokens(ast) {
     });
     for (const t of si.tokens) {
       const leaf = { $value: coerceValue(t.value), $type: tokenType(t.path) };
-      if (!isKnownPath(t.path)) leaf.$extensions = { "dev.thunderlang": { canonical: false } };
+      if (!isKnownPath(t.path)) leaf.$extensions = { "dev.intentlanguage": { canonical: false } };
       setPath(root, t.path, leaf);
     }
   }
@@ -4043,7 +4043,7 @@ function toDesignTokens(ast) {
     $description: `Design tokens for ${ast.title || ast.mission || "intent"} (generated from style_intent by @skillstech/thunderlang)`,
     ...root,
     $extensions: {
-      "dev.thunderlang": {
+      "dev.intentlanguage": {
         schema: DESIGN_TOKENS_SCHEMA,
         format: "W3C Design Tokens (DTCG)",
         source: ast.mission || null,
@@ -5527,7 +5527,7 @@ var LANG_EXT = {
   ruby: "rb",
   perl: "pl"
 };
-function liftSource(source, { language = "typescript", file = "", seeds } = {}) {
+function liftSource(source, { language = "typescript", file = "", seeds = void 0 } = {}) {
   const key = String(language).toLowerCase();
   const adapter = ADAPTERS[key];
   if (!adapter) {
@@ -5597,7 +5597,7 @@ function renderLensDoc(ast, lens) {
   const L = [];
   L.push(`# ${m} , for the ${lens} reader`, "");
   L.push(
-    `> IntentLens \`${lens}\` notes are woven in below. They explain meaning for this`,
+    `> ThunderLens \`${lens}\` notes are woven in below. They explain meaning for this`,
     `> audience; they are documentation, not verification.`,
     ""
   );
@@ -6069,7 +6069,7 @@ function fingerprint(parts) {
   return `fp_${h.toString(16)}`;
 }
 function makeScope({ type = "custom", title = null, seeds = [], projectId = null, createdBy = null, createdAt = null, ...rest2 } = {}) {
-  if (!SCOPE_TYPES.includes(type)) throw new Error(`intent focus: unknown scope type "${type}"`);
+  if (!SCOPE_TYPES.includes(type)) throw new Error(`thunder focus: unknown scope type "${type}"`);
   return {
     schema: FOCUS_SCHEMA,
     scopeId: `scope.${type}.${fingerprint([type, ...seeds].map(String))}`,