@skillstech/thunderlang 0.4.1 → 0.4.2

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to `@skillstech/thunderlang`. Pre-1.0: the language and the
 `intent-graph-v1` schema version independently and may still change.
 
+## 0.4.2
+
+The evidence-graph release. Additive; no breaking changes.
+
+- **Evidence projections.** ThunderLang can now project its verification into `evidence-event-v1`
+  events (`evidenceType: tool_verified`) for the shared SkillsTech proof spine: `thunder evidence
+  <file>` emits `intent.proven`, and `--evidence` on `verify-diff` / `conform` / `drift` emits
+  `change.gated` / `conformance.verified` / `intent.drift`. The projections are pure, offline, and
+  safe-derived (ids, hashes, verdicts, diagnostic codes, and counts only , never source, secret
+  values, finding messages, or expected/actual values). The library exports `toEvidenceEvents`,
+  `verifyDiffToEvidence`, `conformToEvidence`, and `driftToEvidence`. The network push to the spine
+  is intentionally left to the org-layer/CI, so the compiler stays offline and deterministic.
+- **Fix: `thunder lift` emits canonical `.thunder` drafts** instead of the legacy `.intent`
+  extension, on both single-file and repo lifts.
+
 ## 0.4.1
 
 The coherence release. Additive; no breaking changes. Version chosen to align with OpenThunder

package/README.md

@@ -11,7 +11,7 @@ Part of [ThunderLang](https://thunderlang.dev), the intent language for AI-era s
 ## Install
 
 ```bash
-npm install -g @skillstech/thunderlang     # then: intent check path/to/Mission.intent
+npm install -g @skillstech/thunderlang     # then: thunder check path/to/Mission.intent
 npx @skillstech/thunderlang help           # or run without installing
 ```
 
@@ -19,36 +19,36 @@ npx @skillstech/thunderlang help           # or run without installing
 
 ```bash
 # Author & check
-intent init [Name]           # scaffold a runnable starter mission
-intent check <file|dir>      # semantic diagnostics (exit 1 on error); a dir gates the repo
-intent fmt <file|dir> -w     # canonical formatting (whitespace only; comments preserved)
-intent build <file>          # docs, contract graph, test plan, .intent-proof.json
-intent graph <file>          # the canonical Intent Graph (intent-graph-v1)
-intent check . --format sarif   # SARIF 2.1.0 for GitHub/GitLab code scanning
-intent schema                # emit the graph schema + diagnostic catalog
-intent rules  ·  intent explain <CODE>   # the full diagnostic catalog / one code
-intent proof --schema        # the canonical proof envelope schema (intent-proof-v1)
+thunder init [Name]           # scaffold a runnable starter mission
+thunder check <file|dir>      # semantic diagnostics (exit 1 on error); a dir gates the repo
+thunder fmt <file|dir> -w     # canonical formatting (whitespace only; comments preserved)
+thunder build <file>          # docs, contract graph, test plan, .intent-proof.json
+thunder graph <file>          # the canonical Intent Graph (intent-graph-v1)
+thunder check . --format sarif   # SARIF 2.1.0 for GitHub/GitLab code scanning
+thunder schema                # emit the graph schema + diagnostic catalog
+thunder rules  ·  thunder explain <CODE>   # the full diagnostic catalog / one code
+thunder proof --schema        # the canonical proof envelope schema (intent-proof-v1)
 
 # Execute (no AI, no generated code)
-intent run <file> --inputs '{"age":20}'    # evaluate the decision(s) against inputs
-intent simulate <file> --events submit,approve  # walk the lifecycle(s)
-intent test <file>                          # run in-file test blocks (case/scenario)
-intent outcomes <file>                      # evaluate outcome contracts vs results
-intent style <file>                         # resolve style intents vs the canonical token space
+thunder run <file> --inputs '{"age":20}'    # evaluate the decision(s) against inputs
+thunder simulate <file> --events submit,approve  # walk the lifecycle(s)
+thunder test <file>                          # run in-file test blocks (case/scenario)
+thunder outcomes <file>                      # evaluate outcome contracts vs results
+thunder style <file>                         # resolve style intents vs the canonical token space
 
 # Interop  (9 export formats)
-intent export <file> --format dmn|bpmn|smv|jsonschema|openapi|tokens|css|mermaid|playwright
-intent import <file> [--format dmn|bpmn] [--json]   # lift DMN/BPMN into intent
-intent source <file|graph.json>             # regenerate .intent from a graph
-intent migrate <graph.json> [--to <ver>]    # upgrade a persisted graph
-intent verify <proof.json> [src]            # confirm a proof matches its source
+thunder export <file> --format dmn|bpmn|smv|jsonschema|openapi|tokens|css|mermaid|playwright
+thunder import <file> [--format dmn|bpmn] [--json]   # lift DMN/BPMN into intent
+thunder source <file|graph.json>             # regenerate .intent from a graph
+thunder migrate <graph.json> [--to <ver>]    # upgrade a persisted graph
+thunder verify <proof.json> [src]            # confirm a proof matches its source
 
 # Navigate & compare
-intent atlas <dir> [--search q]   intent index <dir>
-intent diff <before> <after>      intent merge <base> <ours> <theirs>
+thunder atlas <dir> [--search q]   thunder index <dir>
+thunder diff <before> <after>      thunder merge <base> <ours> <theirs>
 
 # Code <-> intent
-intent lift <file>   intent approve <file>   intent drift <file>
+thunder lift <file>   thunder approve <file>   thunder drift <file>
 ```
 
 Run `thunder help` for the full reference.
@@ -75,8 +75,8 @@ test Eligibility
 ```
 
 ```bash
-intent run mission.intent --inputs '{"age":20,"score":90}'   # -> Eligible, with a trace
-intent test mission.intent                                    # -> 1/1 passed
+thunder run mission.intent --inputs '{"age":20,"score":90}'   # -> Eligible, with a trace
+thunder test mission.intent                                    # -> 1/1 passed
 ```
 
 No AI, no generated code. The intent itself decides.

package/dist/core.cjs

@@ -4290,7 +4290,7 @@ function notesSummary(ast) {
     byLens
   };
 }
-var COMPILER_VERSION = "0.4.1";
+var COMPILER_VERSION = "0.4.2";
 var PROOF_SCHEMA_VERSION = "0.1.0";
 var SOURCE_PRODUCT = "skillstech-compiler";
 function buildContractGraph(ast, generatedAt) {
@@ -5713,7 +5713,7 @@ function liftRepo(files, { language } = {}) {
     const base = slug(r.lifted.mission);
     const n = (usedNames.get(base) || 0) + 1;
     usedNames.set(base, n);
-    const outName = n === 1 ? `${base}.intent` : `${base}-${n}.intent`;
+    const outName = n === 1 ? `${base}.thunder` : `${base}-${n}.thunder`;
     missions.push({
       mission: r.lifted.mission,
       sourceFile: file,

package/dist/index.cjs

@@ -160,6 +160,7 @@ __export(index_exports, {
   comprehensionLevel: () => comprehensionLevel,
   comprehensionReport: () => comprehensionReport,
   confidenceFromClassification: () => confidenceFromClassification,
+  conformToEvidence: () => conformToEvidence,
   contractHash: () => contractHash,
   contradictionsView: () => contradictionsView,
   correctionsFor: () => correctionsFor,
@@ -168,6 +169,7 @@ __export(index_exports, {
   detectFormat: () => detectFormat,
   diffGraphs: () => diffGraphs,
   draftIntent: () => draftIntent,
+  driftToEvidence: () => driftToEvidence,
   dropNodeField: () => dropNodeField,
   emptyApprovals: () => emptyApprovals,
   emptyEventLog: () => emptyEventLog,
@@ -288,6 +290,7 @@ __export(index_exports, {
   toCss: () => toCss,
   toDMN: () => toDMN,
   toDesignTokens: () => toDesignTokens,
+  toEvidenceEvents: () => toEvidenceEvents,
   toFinding: () => toFinding,
   toJSONSchema: () => toJSONSchema,
   toJava: () => toJava,
@@ -309,6 +312,7 @@ __export(index_exports, {
   validateIR: () => validateIR,
   validateProof: () => validateProof,
   verifyDiff: () => verifyDiff,
+  verifyDiffToEvidence: () => verifyDiffToEvidence,
   verifyLedger: () => verifyLedger,
   violatesArchitecture: () => violatesArchitecture,
   whyBuilt: () => whyBuilt
@@ -328,8 +332,8 @@ function intentRefId(astOrName, { sourceHash } = {}) {
   const name = typeof astOrName === "string" ? astOrName : subjectName(astOrName);
   const base = `intent:${slug(name || "mission")}`;
   if (!sourceHash) return base;
-  const short = String(sourceHash).replace(/^sha256:/, "").slice(0, 8);
-  return short ? `${base}@${short}` : base;
+  const short2 = String(sourceHash).replace(/^sha256:/, "").slice(0, 8);
+  return short2 ? `${base}@${short2}` : base;
 }
 function skillRefId(name) {
   return `skill:${slug(name || "unknown")}`;
@@ -1225,6 +1229,103 @@ function parseIntent(source) {
   return ast;
 }
 
+// src/evidence.mjs
+var COUNTED_STATUSES = ["verified", "failed", "planned", "needs_verification"];
+var stripHash = (h) => String(h || "").replace(/^sha256:/, "");
+var short = (h, n = 16) => stripHash(h).slice(0, n);
+function envelope(eventType, evidenceId, ctx = {}, payload = {}) {
+  return {
+    schema: "evidence-event-v1",
+    sourceProduct: "thunderlang",
+    producer: { name: "thunderlang", version: ctx.compilerVersion || null },
+    eventType,
+    evidenceType: "tool_verified",
+    evidenceId,
+    occurredAt: ctx.occurredAt || null,
+    visibility: ctx.visibility || "private",
+    subject: { missionName: ctx.missionName || null, intentHash: ctx.intentHash || null },
+    payload
+  };
+}
+var safeClaim = (kind, c) => ({ id: c.id, kind, status: c.status, provenBy: c.provenBy || null });
+function countByStatus(claims) {
+  const counts = Object.fromEntries(COUNTED_STATUSES.map((s) => [s, 0]));
+  for (const c of claims) if (c && Object.prototype.hasOwnProperty.call(counts, c.status)) counts[c.status]++;
+  return counts;
+}
+var safeFinding = (f) => ({ code: f.code, level: f.level, ...f.regression !== void 0 ? { regression: !!f.regression } : {}, ...f.line !== void 0 ? { line: f.line } : {} });
+function toEvidenceEvents(proof) {
+  if (!proof || typeof proof !== "object") return [];
+  const guarantees = Array.isArray(proof.guarantees) ? proof.guarantees : [];
+  const neverRules = Array.isArray(proof.neverRules) ? proof.neverRules : [];
+  const claims = [
+    ...guarantees.map((c) => safeClaim("guarantee", c)),
+    ...neverRules.map((c) => safeClaim("prohibition", c))
+  ];
+  const fr = proof.freshness || {};
+  const intentHash2 = proof.freshness?.intentHash || proof.sourceHash || null;
+  return [envelope("intent.proven", `tl-proof-${short(intentHash2)}`, {
+    compilerVersion: proof.compilerVersion,
+    occurredAt: proof.generatedAt,
+    missionName: proof.missionName,
+    intentHash: intentHash2
+  }, {
+    proofStatus: proof.proofStatus || null,
+    total: claims.length,
+    counts: countByStatus(claims),
+    freshness: { implementation: fr.implementation || null, dependencies: fr.dependencies ? fr.dependencies.hash || null : null, environment: fr.environment || null },
+    claims
+  })];
+}
+function verifyDiffToEvidence(verdict2, ctx = {}) {
+  if (!verdict2 || typeof verdict2 !== "object") return [];
+  const findings2 = Array.isArray(verdict2.findings) ? verdict2.findings : [];
+  const id = `tl-verifydiff-${short(ctx.intentHash)}${ctx.changeHash ? `-${short(ctx.changeHash, 8)}` : ""}`;
+  return [envelope("change.gated", id, ctx, {
+    verdict: verdict2.verdict || null,
+    ok: !!verdict2.ok,
+    blocking: verdict2.blocking || 0,
+    regressions: verdict2.summary?.regressions ?? findings2.filter((f) => f.regression).length,
+    findings: findings2.map(safeFinding)
+  })];
+}
+function conformToEvidence(report, ctx = {}) {
+  if (!report || typeof report !== "object") return [];
+  const cases = Array.isArray(report.cases) ? report.cases : [];
+  const columns = Array.isArray(report.columns) ? report.columns : [];
+  const targets = {};
+  for (const col of columns) {
+    const t = { pass: 0, fail: 0, declared: 0 };
+    for (const c of cases) {
+      const s = c.targets?.[col]?.status;
+      if (s === "pass") t.pass++;
+      else if (s === "fail") t.fail++;
+      else t.declared++;
+    }
+    targets[col] = t;
+  }
+  return [envelope("conformance.verified", `tl-conform-${short(ctx.intentHash)}`, ctx, {
+    total: report.total || cases.length,
+    columns,
+    semanticFailures: report.semanticFailures || 0,
+    graded: !!report.graded,
+    targets,
+    // failure locations by name only (case + target), never expected/actual values.
+    failures: (Array.isArray(report.failures) ? report.failures : []).map((f) => ({ target: f.target, case: f.case }))
+  })];
+}
+function driftToEvidence(report, ctx = {}) {
+  if (!report || typeof report !== "object") return [];
+  const findings2 = Array.isArray(report.findings) ? report.findings : [];
+  const id = `tl-drift-${short(ctx.intentHash)}${ctx.codeHash ? `-${short(ctx.codeHash, 8)}` : ""}`;
+  return [envelope("intent.drift", id, ctx, {
+    status: report.status || null,
+    total: findings2.length,
+    blocking: report.summary?.blocking ?? 0,
+    findings: findings2.map(safeFinding)
+  })];
+}
+
 // src/hash.mjs
 var K = new Uint32Array([
   1116352408,
@@ -2288,7 +2389,7 @@ function notesSummary(ast) {
     byLens
   };
 }
-var COMPILER_VERSION = "0.4.1";
+var COMPILER_VERSION = "0.4.2";
 var PROOF_SCHEMA_VERSION = "0.1.0";
 var SOURCE_PRODUCT = "skillstech-compiler";
 function buildContractGraph(ast, generatedAt) {
@@ -4087,7 +4188,7 @@ function liftRepo(files, { language } = {}) {
     const base = slug(r.lifted.mission);
     const n = (usedNames.get(base) || 0) + 1;
     usedNames.set(base, n);
-    const outName = n === 1 ? `${base}.intent` : `${base}-${n}.intent`;
+    const outName = n === 1 ? `${base}.thunder` : `${base}-${n}.thunder`;
     missions.push({
       mission: r.lifted.mission,
       sourceFile: file,
@@ -9648,6 +9749,7 @@ function startLspServer({ readable = process.stdin, writable = process.stdout }
   comprehensionLevel,
   comprehensionReport,
   confidenceFromClassification,
+  conformToEvidence,
   contractHash,
   contradictionsView,
   correctionsFor,
@@ -9656,6 +9758,7 @@ function startLspServer({ readable = process.stdin, writable = process.stdout }
   detectFormat,
   diffGraphs,
   draftIntent,
+  driftToEvidence,
   dropNodeField,
   emptyApprovals,
   emptyEventLog,
@@ -9776,6 +9879,7 @@ function startLspServer({ readable = process.stdin, writable = process.stdout }
   toCss,
   toDMN,
   toDesignTokens,
+  toEvidenceEvents,
   toFinding,
   toJSONSchema,
   toJava,
@@ -9797,6 +9901,7 @@ function startLspServer({ readable = process.stdin, writable = process.stdout }
   validateIR,
   validateProof,
   verifyDiff,
+  verifyDiffToEvidence,
   verifyLedger,
   violatesArchitecture,
   whyBuilt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillstech/thunderlang",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Deterministic ThunderLang compiler, CLI, and Language Server. No AI required. Turns .thunder files into the canonical Intent Graph, docs, and a proof, and EXECUTES the intent: run decisions, simulate lifecycles, and check outcome contracts. Interops with DMN, BPMN, JSON Schema, and OpenAPI.",
   "type": "module",
   "main": "./src/index.mjs",
@@ -70,11 +70,11 @@
   "homepage": "https://thunderlang.dev",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/SkillsTechTalk/intent-language.git",
+    "url": "git+https://github.com/SkillsTechTalk/thunderlang.git",
     "directory": "compiler"
   },
   "bugs": {
-    "url": "https://github.com/SkillsTechTalk/intent-language/issues"
+    "url": "https://github.com/SkillsTechTalk/thunderlang/issues"
   },
   "author": "Skills Tech Talk, LLC",
   "license": "Apache-2.0",

package/src/cli.mjs

@@ -84,6 +84,7 @@ function runLiveTarget(ast, target) {
 }
 import { importIntent, importReport, detectFormat, IMPORT_FORMATS } from './importers.mjs';
 import { runTests } from './testing.mjs';
+import { toEvidenceEvents, verifyDiffToEvidence, conformToEvidence, driftToEvidence } from './evidence.mjs';
 import { evaluateOutcomes } from './outcome.mjs';
 import { analyzeStyle } from './style.mjs';
 import { intentProofJsonSchema, validateProof } from './proof-schema.mjs';
@@ -261,6 +262,7 @@ function parseArgs(argv) {
     else if (a === '--governed') args.governed = true;
     else if (a === '--target') args.target = argv[++i];
     else if (a === '--all-targets') args.allTargets = true;
+    else if (a === '--evidence') args.evidence = true;
     else if (a === '--env') args.env = argv[++i];
     else if (a === '--brief') args.brief = argv[++i];
     else if (a === '--after') args.after = argv[++i];
@@ -370,6 +372,8 @@ Prove & verify intent
   proof <file>               the .thunder-proof.json artifact (see also: prove, which emits verdicts)
   proof --schema             emit the canonical proof envelope JSON Schema (intent-proof-v1)
   verify <proof.json> [src]  re-check a proof; reports STALE when impl/deps/compiler moved
+  evidence <file>            emit evidence-event-v1 JSON (tool_verified) for the shared proof spine
+                             (also: prove/verify-diff/conform/drift accept --evidence to emit their own event)
   conform <file> [--targets a,b] [--run typescript,python,csharp,java | --all-targets] [--results <json>]   conformance matrix across targets
 
 Real code vs intent (drift)
@@ -860,7 +864,7 @@ test Example
     if (!res.ok) { console.error(res.error); process.exit(1); }
     if (args.json) { console.log(JSON.stringify(res.summary, null, 2)); return; }
     if (args.out) {
-      const p = writeText(args.out, `${slug(res.lifted.mission)}.intent`, res.intentText);
+      const p = writeText(args.out, `${slug(res.lifted.mission)}.thunder`, res.intentText);
       console.log(`thunder lift ${basename(file)} -> ${p.replace(process.cwd() + '/', '')}`);
     } else {
       console.log(res.intentText);
@@ -901,6 +905,11 @@ test Example
     const codeText = readFileSync(file, 'utf8');
     const language = args.from && args.from !== 'repo' ? args.from : languageForFile(file);
     const res = checkDrift(intentText, codeText, { language });
+    if (args.evidence) {
+      const ctx = { compilerVersion: COMPILER_VERSION, occurredAt: new Date().toISOString(), missionName: parseIntent(intentText).mission || null, intentHash: sha256(intentText), codeHash: sha256(codeText) };
+      console.log(JSON.stringify(driftToEvidence(res, ctx), null, 2));
+      process.exit(res.status === 'drift' ? 1 : 0); return;
+    }
     if (args.json) { console.log(JSON.stringify(res, null, 2)); }
     else {
       console.log(`thunder drift: ${res.status.toUpperCase()} (${res.summary.blocking} blocking)`);
@@ -1505,6 +1514,34 @@ test Example
     return;
   }
 
+  // `thunder evidence <file>` , project the intent's proof into evidence-event-v1 events for the
+  // shared SkillsTech evidence graph (STW spine). Deterministic, offline, safe-derived; prints JSON.
+  // The network push to the spine belongs to the org-layer/CI, not this CLI.
+  if (cmd === 'evidence') {
+    if (!file || !existsSync(file)) { console.error('usage: thunder evidence <file>  # emit evidence-event-v1 JSON for the shared proof spine'); process.exit(2); return; }
+    const source = readFileSync(file, 'utf8');
+    const ast = parseIntent(source);
+    const diagnostics = semanticDiagnostics(ast);
+    const resolved = resolveObligations(ast);
+    const proof = buildProof(ast, {
+      sourceFile: basename(file),
+      sourceHash: sha256(source),
+      targetsRequested: ast.targets || [],
+      targetsGenerated: [],
+      diagnostics,
+      generatedAt: new Date().toISOString(),
+    });
+    const CLAIM_MAP = { verified: 'verified', failed: 'failed', declared: 'planned', unverified: 'needs_verification' };
+    const byId = new Map(resolved.obligations.map((o) => [o.id, o]));
+    const applyStatus = (claim) => { const o = byId.get(claim.id); return o ? { ...claim, status: CLAIM_MAP[o.status], provenBy: o.provenBy || null } : claim; };
+    proof.guarantees = proof.guarantees.map(applyStatus);
+    proof.neverRules = proof.neverRules.map(applyStatus);
+    proof.freshness = freshnessFor(file, proof, args.env);
+    const events = toEvidenceEvents(proof);
+    console.log(JSON.stringify(events, null, 2));
+    return;
+  }
+
   // CONFORMANCE: the same test cases run against every target. The engine defines the canonical
   // result each case must produce; target outputs fed via --results are graded against it.
   // `thunder conform <file> [--targets ts,py] [--results <json|path>] [--json]`.
@@ -1542,6 +1579,11 @@ test Example
     const rep = buildConformance(ast, { targets, results });
     if (skippedTargets.length) rep.skipped = Array.from(new Set(skippedTargets));
     const bad = rep.semanticFailures > 0 || rep.failures.length > 0;
+    if (args.evidence) {
+      const ctx = { compilerVersion: COMPILER_VERSION, occurredAt: new Date().toISOString(), missionName: ast.mission || null, intentHash: sha256(readFileSync(file, 'utf8')) };
+      console.log(JSON.stringify(conformToEvidence(rep, ctx), null, 2));
+      process.exit(bad ? 1 : 0); return;
+    }
     if (args.json) { console.log(JSON.stringify(rep, null, 2)); process.exit(bad ? 1 : 0); return; }
     if (!rep.total) { console.log(`thunder conform ${basename(file)}: no test cases to conform.`); return; }
 
@@ -1752,6 +1794,11 @@ test Example
     const before = args.before ? readFileSync(args.before, 'utf8') : null;
     const language = args.from || languageForFile(args.after);
     const r = verifyDiff(intentText, { before, after, language });
+    if (args.evidence) {
+      const ctx = { compilerVersion: COMPILER_VERSION, occurredAt: new Date().toISOString(), missionName: parseIntent(intentText).mission || null, intentHash: sha256(intentText), changeHash: sha256(after) };
+      console.log(JSON.stringify(verifyDiffToEvidence(r, ctx), null, 2));
+      process.exit(r.ok ? 0 : 1); return;
+    }
     if (args.json) { console.log(JSON.stringify(r, null, 2)); process.exit(r.ok ? 0 : 1); return; }
     console.log(`thunder verify-diff ${basename(file)} vs ${basename(args.after)}: ${r.verdict} (${r.blocking} blocking, ${r.summary.regressions} regression(s))`);
     for (const f of r.findings) {

package/src/emit.mjs

@@ -30,7 +30,7 @@ export function notesSummary(ast) {
   };
 }
 
-export const COMPILER_VERSION = '0.4.1';
+export const COMPILER_VERSION = '0.4.2';
 export const PROOF_SCHEMA_VERSION = '0.1.0';
 // Identifies which ecosystem product emitted this proof. Consumed by SkillsTech
 // Certified to key cert proofs to the compiler. Stable slug per the coordination bus.

package/src/evidence.mjs

@@ -0,0 +1,116 @@
+// ThunderLang -> shared evidence graph projection.
+//
+// Maps ThunderLang's verification artifacts into evidence-event-v1 events for the SkillsTech proof
+// spine (owned by STW: siblings emit evidence-event-v1, STW composes proof-bundle-v1). ThunderLang is
+// the deterministic, machine-checked layer, so its evidence is evidenceType `tool_verified`.
+//
+// These projections are PURE and OFFLINE. They perform no network I/O: the transport (POST to the
+// spine) belongs to the hosted org-layer / CI, never the end-user CLI, so the compiler stays
+// deterministic and phone-home-free. They are also SAFE-DERIVED: events carry only ids, hashes,
+// verdicts, diagnostic codes, and counts , never source code, never secret values, never claim
+// statement text, never data-element contents (no finding `message`, no expected/actual values).
+//
+// NOTE: the evidence-event-v1 envelope below is ThunderLang's PROPOSED shape, pending STW's canonical
+// schema (see the TL->STW proposal on the comms bus). Field names may adjust once STW confirms.
+
+const COUNTED_STATUSES = ['verified', 'failed', 'planned', 'needs_verification'];
+const stripHash = (h) => String(h || '').replace(/^sha256:/, '');
+const short = (h, n = 16) => stripHash(h).slice(0, n);
+
+// The shared evidence-event-v1 envelope. `ctx` carries the cross-artifact context the individual
+// artifacts do not all include (missionName, intentHash, compilerVersion, occurredAt).
+function envelope(eventType, evidenceId, ctx = {}, payload = {}) {
+  return {
+    schema: 'evidence-event-v1',
+    sourceProduct: 'thunderlang',
+    producer: { name: 'thunderlang', version: ctx.compilerVersion || null },
+    eventType,
+    evidenceType: 'tool_verified',
+    evidenceId,
+    occurredAt: ctx.occurredAt || null,
+    visibility: ctx.visibility || 'private',
+    subject: { missionName: ctx.missionName || null, intentHash: ctx.intentHash || null },
+    payload,
+  };
+}
+
+const safeClaim = (kind, c) => ({ id: c.id, kind, status: c.status, provenBy: c.provenBy || null });
+function countByStatus(claims) {
+  const counts = Object.fromEntries(COUNTED_STATUSES.map((s) => [s, 0]));
+  for (const c of claims) if (c && Object.prototype.hasOwnProperty.call(counts, c.status)) counts[c.status]++;
+  return counts;
+}
+// Safe-derived finding: diagnostic code + level (+ flags), never the human message (which can quote code).
+const safeFinding = (f) => ({ code: f.code, level: f.level, ...(f.regression !== undefined ? { regression: !!f.regression } : {}), ...(f.line !== undefined ? { line: f.line } : {}) });
+
+// intent.proven , from an intent-proof-v1 artifact.
+export function toEvidenceEvents(proof) {
+  if (!proof || typeof proof !== 'object') return [];
+  const guarantees = Array.isArray(proof.guarantees) ? proof.guarantees : [];
+  const neverRules = Array.isArray(proof.neverRules) ? proof.neverRules : [];
+  const claims = [
+    ...guarantees.map((c) => safeClaim('guarantee', c)),
+    ...neverRules.map((c) => safeClaim('prohibition', c)),
+  ];
+  const fr = proof.freshness || {};
+  const intentHash = proof.freshness?.intentHash || proof.sourceHash || null;
+  return [envelope('intent.proven', `tl-proof-${short(intentHash)}`, {
+    compilerVersion: proof.compilerVersion, occurredAt: proof.generatedAt, missionName: proof.missionName, intentHash,
+  }, {
+    proofStatus: proof.proofStatus || null,
+    total: claims.length,
+    counts: countByStatus(claims),
+    freshness: { implementation: fr.implementation || null, dependencies: fr.dependencies ? fr.dependencies.hash || null : null, environment: fr.environment || null },
+    claims,
+  })];
+}
+
+// change.gated , from a verify-diff verdict ({ verdict, ok, findings, blocking, summary }).
+export function verifyDiffToEvidence(verdict, ctx = {}) {
+  if (!verdict || typeof verdict !== 'object') return [];
+  const findings = Array.isArray(verdict.findings) ? verdict.findings : [];
+  const id = `tl-verifydiff-${short(ctx.intentHash)}${ctx.changeHash ? `-${short(ctx.changeHash, 8)}` : ''}`;
+  return [envelope('change.gated', id, ctx, {
+    verdict: verdict.verdict || null,
+    ok: !!verdict.ok,
+    blocking: verdict.blocking || 0,
+    regressions: verdict.summary?.regressions ?? findings.filter((f) => f.regression).length,
+    findings: findings.map(safeFinding),
+  })];
+}
+
+// conformance.verified , from a thunder-conformance-v1 report.
+export function conformToEvidence(report, ctx = {}) {
+  if (!report || typeof report !== 'object') return [];
+  const cases = Array.isArray(report.cases) ? report.cases : [];
+  const columns = Array.isArray(report.columns) ? report.columns : [];
+  // Per-target pass/fail/declared counts, derived without leaking any expected/actual values.
+  const targets = {};
+  for (const col of columns) {
+    const t = { pass: 0, fail: 0, declared: 0 };
+    for (const c of cases) { const s = c.targets?.[col]?.status; if (s === 'pass') t.pass++; else if (s === 'fail') t.fail++; else t.declared++; }
+    targets[col] = t;
+  }
+  return [envelope('conformance.verified', `tl-conform-${short(ctx.intentHash)}`, ctx, {
+    total: report.total || cases.length,
+    columns,
+    semanticFailures: report.semanticFailures || 0,
+    graded: !!report.graded,
+    targets,
+    // failure locations by name only (case + target), never expected/actual values.
+    failures: (Array.isArray(report.failures) ? report.failures : []).map((f) => ({ target: f.target, case: f.case })),
+  })];
+}
+
+// intent.drift , from a checkDrift report ({ status, findings, summary }).
+export function driftToEvidence(report, ctx = {}) {
+  if (!report || typeof report !== 'object') return [];
+  const findings = Array.isArray(report.findings) ? report.findings : [];
+  const id = `tl-drift-${short(ctx.intentHash)}${ctx.codeHash ? `-${short(ctx.codeHash, 8)}` : ''}`;
+  return [envelope('intent.drift', id, ctx, {
+    status: report.status || null,
+    total: findings.length,
+    blocking: report.summary?.blocking ?? 0,
+    findings: findings.map(safeFinding),
+  })];
+}

package/src/index.mjs

@@ -8,6 +8,7 @@
 
 // Parsing
 export { parseIntent, slug, KNOWN_LENSES } from './parse.mjs';
+export { toEvidenceEvents, verifyDiffToEvidence, conformToEvidence, driftToEvidence } from './evidence.mjs';
 
 // Semantic analysis, graphs, and proof
 export {

package/src/lift.mjs

@@ -696,7 +696,7 @@ export function liftRepo(files, { language } = {}) {
     const base = slug(r.lifted.mission);
     const n = (usedNames.get(base) || 0) + 1;
     usedNames.set(base, n);
-    const outName = n === 1 ? `${base}.intent` : `${base}-${n}.intent`;
+    const outName = n === 1 ? `${base}.thunder` : `${base}-${n}.thunder`;
     missions.push({
       mission: r.lifted.mission, sourceFile: file, outName,
       intentText: r.intentText, summary: r.summary, diagnostics: r.diagnostics,