@skillstech/thunderlang 0.3.0 → 0.4.1

package/CHANGELOG.md

@@ -3,6 +3,32 @@
 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.1
+
+The coherence release. Additive; no breaking changes. Version chosen to align with OpenThunder
+(TL and OT version in lockstep; OT is moving from 0.4.0 to match).
+
+- **Python code generation.** `thunder gen <file> --target python` now emits a typed Python 3
+  scaffold, aligning the codegen axis with live execution. Also fixes a real gap: C# and Java `gen`
+  silently dropped `requires` preconditions that TypeScript emitted; they are now emitted as guided
+  TODOs.
+- **Language support matrix.** New `docs/language-support-matrix.md` documents the three axes , lift
+  (14 languages), gen, and live target execution (4) , and makes them discoverable.
+- **VS Code extension.** `editors/vscode/` ships a real extension: syntax highlighting and a Language
+  Server client that launches `thunder lsp`. Packageable with `vsce package`.
+- **Grouped, scannable CLI help.** `thunder --help` is reorganized into nine labeled groups with a
+  one-line mental model. Command behavior is unchanged (help text only); a test guards that no
+  command was dropped.
+- **Verify-real-code loop, productized.** New MCP tools `intent_prove`, `intent_conform`, and
+  `intent_drift` let AI agents drive the full loop. `docs/verifying-ai-changes.md` is rewritten as
+  the headline workflow (author intent, write code, prove conformance, gate the merge) with a CI
+  recipe.
+- **Honest Playwright scaffolds.** The exported Playwright tests now open with `test.fixme` so an
+  unfilled scaffold cannot pass vacuously.
+- **intent-graph-v1 stability policy.** New `docs/schema-stability.md` commits to additive-only type
+  sets within v1, an IR version that moves independently of the package, a deprecation policy, and a
+  road to 1.0, so consumers like OpenThunder can depend on the IR safely.
+
 ## 0.3.0
 
 The 14-language lift release. Additive; no breaking changes. Restores the OpenThunder -> ThunderLang

package/dist/core.cjs

@@ -161,6 +161,7 @@ __export(core_exports, {
   toDesignTokens: () => toDesignTokens,
   toFinding: () => toFinding,
   toJava: () => toJava,
+  toPython: () => toPython,
   toTypeScript: () => toTypeScript,
   twelveFactorReport: () => twelveFactorReport,
   twelveFactorSummary: () => twelveFactorSummary,
@@ -3336,6 +3337,7 @@ function exprToCode(src, { inputs = [], dialect = "js" } = {}) {
 var exprToJs = (src, opts = {}) => exprToCode(src, { ...opts, dialect: "js" });
 var exprToCSharp = (src, opts = {}) => exprToCode(src, { ...opts, dialect: "csharp" });
 var exprToJava = (src, opts = {}) => exprToCode(src, { ...opts, dialect: "java" });
+var exprToPython = (src, opts = {}) => exprToCode(src, { ...opts, dialect: "python" });
 
 // src/runtime.mjs
 var RUNTIME_SCHEMA = "intent-runtime-v1";
@@ -4288,7 +4290,7 @@ function notesSummary(ast) {
     byLens
   };
 }
-var COMPILER_VERSION = "0.3.0";
+var COMPILER_VERSION = "0.4.1";
 var PROOF_SCHEMA_VERSION = "0.1.0";
 var SOURCE_PRODUCT = "skillstech-compiler";
 function buildContractGraph(ast, generatedAt) {
@@ -6671,7 +6673,7 @@ function toCSharp(ast) {
       try {
         cond = exprToCSharp(r.when, { inputs });
       } catch {
-        cond = `false /* TODO: "${r.when}" */`;
+        cond = `false /* TODO: could not translate "${r.when}" */`;
       }
       L.push(`    if (${cond}) return ${JSON.stringify(r.result)}; // rule ${r.name}`);
     }
@@ -6680,6 +6682,7 @@ function toCSharp(ast) {
   const inName = (ast.inputs || []).length ? `${subject}Input` : null;
   const outName = (ast.outputs || []).length ? `${subject}Output` : "void";
   L.push(`  public static ${outName} Run(${inName ? `${inName} input` : ""})`, "  {");
+  for (const r of ast.requires || []) L.push(`    // precondition: ${r}  , TODO: validate`);
   for (const n of ast.neverRules || []) L.push(`    // NEVER: ${n.statement}`);
   for (const g of ast.guarantees || []) L.push(`    // GUARANTEE: ${g.statement}`);
   L.push('    throw new NotImplementedException("TODO: implement , the intent above defines what this must do.");', "  }");
@@ -6740,7 +6743,7 @@ function toJava(ast) {
       try {
         cond = exprToJava(r.when, { inputs });
       } catch {
-        cond = `false /* TODO: "${r.when}" */`;
+        cond = `false /* TODO: could not translate "${r.when}" */`;
       }
       L.push(`    if (${cond}) return ${JSON.stringify(r.result)}; // rule ${r.name}`);
     }
@@ -6749,18 +6752,98 @@ function toJava(ast) {
   const inName = (ast.inputs || []).length ? `${subject}Input` : null;
   const outName = (ast.outputs || []).length ? `${subject}Output` : "void";
   L.push(`  public static ${outName} run(${inName ? `${inName} input` : ""}) {`);
+  for (const r of ast.requires || []) L.push(`    // precondition: ${r}  , TODO: validate`);
   for (const n of ast.neverRules || []) L.push(`    // NEVER: ${n.statement}`);
   for (const g of ast.guarantees || []) L.push(`    // GUARANTEE: ${g.statement}`);
   L.push('    throw new UnsupportedOperationException("TODO: implement , the intent above defines what this must do.");', "  }");
   L.push("}", "");
   return L.join("\n");
 }
+var PY_TYPES = {
+  Email: "str",
+  Url: "str",
+  UserId: "str",
+  AccountId: "str",
+  OrderId: "str",
+  InvoiceId: "str",
+  CustomerId: "str",
+  Secret: "str",
+  Token: "str",
+  Jwt: "str",
+  IdempotencyKey: "str",
+  Currency: "str",
+  Date: "str",
+  DateTime: "str",
+  Money: "float",
+  Percentage: "float",
+  Count: "int",
+  Duration: "int",
+  Flag: "bool"
+};
+function pyType(type, domain) {
+  if (!type) return "object";
+  const list = /^List<(.+)>$/.exec(type);
+  if (list) return `list[${pyType(list[1], domain)}]`;
+  const base = type.replace(/\(.*\)/, "");
+  if (PY_TYPES[base]) return PY_TYPES[base];
+  domain.add(base);
+  return base;
+}
+var snake = (s) => pascal2(s).replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+function toPython(ast) {
+  const subject = pascal2(subjectName(ast) || "Intent");
+  const domain = /* @__PURE__ */ new Set();
+  const L = [
+    `# ${subject} , generated from ThunderLang (intent-codegen-v1). Deterministic, no AI.`,
+    "# The dataclass contract and the decision logic are fully determined by the intent;",
+    "# business logic marked TODO is yours, bound by the guarantees and never-rules below.",
+    ""
+  ];
+  const hasData = (ast.inputs || []).length || (ast.outputs || []).length;
+  if (hasData) L.push("from __future__ import annotations", "from dataclasses import dataclass", "");
+  const cls = (name, fields) => fields.length ? ["@dataclass", `class ${name}:`, ...fields.map((f) => `    ${f.name}: ${pyType(f.type, domain)}`), ""] : [];
+  if ((ast.inputs || []).length) L.push(...cls(`${subject}Input`, ast.inputs));
+  if ((ast.outputs || []).length) L.push(...cls(`${subject}Output`, ast.outputs));
+  for (const d of ast.decisions || []) {
+    const inputs = d.inputs || [];
+    L.push(`# decision ${d.name} , first matching rule wins.`);
+    L.push(`def ${snake(d.name)}(${inputs.join(", ")}) -> str:`);
+    for (const r of d.rules || []) {
+      let cond, note = "";
+      try {
+        cond = exprToPython(r.when, { inputs });
+      } catch {
+        cond = "False";
+        note = `  # TODO: could not translate "${r.when}"`;
+      }
+      L.push(`    if ${cond}:${note}`);
+      L.push(`        return ${JSON.stringify(r.result)}  # rule ${r.name}`);
+    }
+    L.push(`    return ${JSON.stringify(d.default ?? "Undecided")}  # default`, "");
+  }
+  const inName = (ast.inputs || []).length ? `${subject}Input` : null;
+  const outName = (ast.outputs || []).length ? `${subject}Output` : "None";
+  L.push(`def run(${inName ? `input: ${inName}` : ""}) -> ${outName}:`);
+  for (const r of ast.requires || []) L.push(`    # precondition: ${r}  , TODO: validate`);
+  for (const n of ast.neverRules || []) L.push(`    # NEVER: ${n.statement}`);
+  for (const g of ast.guarantees || []) L.push(`    # GUARANTEE: ${g.statement}`);
+  L.push('    raise NotImplementedError("TODO: implement , the intent above defines what this must do.")', "");
+  const stubs = [...domain].filter((t) => !PY_TYPES[t] && /^[A-Z]/.test(t)).sort();
+  if (stubs.length) {
+    L.push("# Domain types referenced by the intent , complete these.");
+    for (const t of stubs) L.push(`class ${t}: pass  # TODO: fields`);
+    L.push("");
+  }
+  return L.join("\n");
+}
 var GENERATORS = {
   typescript: toTypeScript,
   ts: toTypeScript,
   csharp: toCSharp,
   cs: toCSharp,
-  java: toJava
+  java: toJava,
+  python: toPython,
+  py: toPython
 };
 
 // src/changes.mjs
@@ -6977,6 +7060,7 @@ function changeReport(pairs) {
   toDesignTokens,
   toFinding,
   toJava,
+  toPython,
   toTypeScript,
   twelveFactorReport,
   twelveFactorSummary,

package/dist/index.cjs

@@ -294,6 +294,7 @@ __export(index_exports, {
   toMermaid: () => toMermaid,
   toOpenAPI: () => toOpenAPI,
   toPlaywright: () => toPlaywright,
+  toPython: () => toPython,
   toSMV: () => toSMV,
   toSarif: () => toSarif,
   toTypeScript: () => toTypeScript,
@@ -2287,7 +2288,7 @@ function notesSummary(ast) {
     byLens
   };
 }
-var COMPILER_VERSION = "0.3.0";
+var COMPILER_VERSION = "0.4.1";
 var PROOF_SCHEMA_VERSION = "0.1.0";
 var SOURCE_PRODUCT = "skillstech-compiler";
 function buildContractGraph(ast, generatedAt) {
@@ -5147,7 +5148,9 @@ function toPlaywright(ast) {
   const exps = ast.experiences || [];
   const L = [];
   L.push("// Playwright test scaffold generated from experience intent by @skillstech/thunderlang.");
-  L.push("// SKELETON: fill in selectors and assertions. It is not a passing test until you do.");
+  L.push("// SKELETON: fill in selectors and assertions. Every test starts with a test.fixme");
+  L.push('// guard so an unimplemented scaffold reports "fixme" instead of passing vacuously;');
+  L.push("// remove the guard from each test once its body is real.");
   L.push("import { test, expect } from '@playwright/test';");
   L.push("");
   if (!exps.length) {
@@ -5162,6 +5165,7 @@ function toPlaywright(ast) {
     }
     for (const j of exp.journeys || []) {
       L.push(`  test(${jsStr(j.name || "journey")}, async ({ page }) => {`);
+      L.push(`    test.fixme(true, ${jsStr("scaffold: implement the steps, then remove this guard")});`);
       if (!(j.steps || []).length) L.push("    // TODO: no steps declared for this journey");
       for (const step of j.steps || []) {
         L.push(`    await test.step(${jsStr(step)}, async () => {`);
@@ -5173,10 +5177,12 @@ function toPlaywright(ast) {
     for (const st of exp.states || []) {
       if (st.hasRecovery) {
         L.push(`  test(${jsStr(`failure state "${st.name}" offers a recovery path`)}, async ({ page }) => {`);
+        L.push(`    test.fixme(true, ${jsStr("scaffold: implement this state check, then remove this guard")});`);
         L.push(`    // TODO: drive the UI into "${st.name}", assert a recovery action is available`);
         L.push("  });");
       } else {
         L.push(`  test(${jsStr(`reaches state: ${st.name}`)}, async ({ page }) => {`);
+        L.push(`    test.fixme(true, ${jsStr("scaffold: implement this state check, then remove this guard")});`);
         L.push(`    // TODO: drive the UI to "${st.name}" and assert it is shown`);
         L.push("  });");
       }
@@ -6351,6 +6357,7 @@ function exprToCode(src, { inputs = [], dialect = "js" } = {}) {
 var exprToJs = (src, opts = {}) => exprToCode(src, { ...opts, dialect: "js" });
 var exprToCSharp = (src, opts = {}) => exprToCode(src, { ...opts, dialect: "csharp" });
 var exprToJava = (src, opts = {}) => exprToCode(src, { ...opts, dialect: "java" });
+var exprToPython = (src, opts = {}) => exprToCode(src, { ...opts, dialect: "python" });
 
 // src/runtime.mjs
 var RUNTIME_SCHEMA = "intent-runtime-v1";
@@ -7848,7 +7855,7 @@ function toCSharp(ast) {
       try {
         cond = exprToCSharp(r.when, { inputs });
       } catch {
-        cond = `false /* TODO: "${r.when}" */`;
+        cond = `false /* TODO: could not translate "${r.when}" */`;
       }
       L.push(`    if (${cond}) return ${JSON.stringify(r.result)}; // rule ${r.name}`);
     }
@@ -7857,6 +7864,7 @@ function toCSharp(ast) {
   const inName = (ast.inputs || []).length ? `${subject}Input` : null;
   const outName = (ast.outputs || []).length ? `${subject}Output` : "void";
   L.push(`  public static ${outName} Run(${inName ? `${inName} input` : ""})`, "  {");
+  for (const r of ast.requires || []) L.push(`    // precondition: ${r}  , TODO: validate`);
   for (const n of ast.neverRules || []) L.push(`    // NEVER: ${n.statement}`);
   for (const g of ast.guarantees || []) L.push(`    // GUARANTEE: ${g.statement}`);
   L.push('    throw new NotImplementedException("TODO: implement , the intent above defines what this must do.");', "  }");
@@ -7917,7 +7925,7 @@ function toJava(ast) {
       try {
         cond = exprToJava(r.when, { inputs });
       } catch {
-        cond = `false /* TODO: "${r.when}" */`;
+        cond = `false /* TODO: could not translate "${r.when}" */`;
       }
       L.push(`    if (${cond}) return ${JSON.stringify(r.result)}; // rule ${r.name}`);
     }
@@ -7926,18 +7934,98 @@ function toJava(ast) {
   const inName = (ast.inputs || []).length ? `${subject}Input` : null;
   const outName = (ast.outputs || []).length ? `${subject}Output` : "void";
   L.push(`  public static ${outName} run(${inName ? `${inName} input` : ""}) {`);
+  for (const r of ast.requires || []) L.push(`    // precondition: ${r}  , TODO: validate`);
   for (const n of ast.neverRules || []) L.push(`    // NEVER: ${n.statement}`);
   for (const g of ast.guarantees || []) L.push(`    // GUARANTEE: ${g.statement}`);
   L.push('    throw new UnsupportedOperationException("TODO: implement , the intent above defines what this must do.");', "  }");
   L.push("}", "");
   return L.join("\n");
 }
+var PY_TYPES = {
+  Email: "str",
+  Url: "str",
+  UserId: "str",
+  AccountId: "str",
+  OrderId: "str",
+  InvoiceId: "str",
+  CustomerId: "str",
+  Secret: "str",
+  Token: "str",
+  Jwt: "str",
+  IdempotencyKey: "str",
+  Currency: "str",
+  Date: "str",
+  DateTime: "str",
+  Money: "float",
+  Percentage: "float",
+  Count: "int",
+  Duration: "int",
+  Flag: "bool"
+};
+function pyType(type, domain) {
+  if (!type) return "object";
+  const list = /^List<(.+)>$/.exec(type);
+  if (list) return `list[${pyType(list[1], domain)}]`;
+  const base = type.replace(/\(.*\)/, "");
+  if (PY_TYPES[base]) return PY_TYPES[base];
+  domain.add(base);
+  return base;
+}
+var snake = (s) => pascal2(s).replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+function toPython(ast) {
+  const subject = pascal2(subjectName(ast) || "Intent");
+  const domain = /* @__PURE__ */ new Set();
+  const L = [
+    `# ${subject} , generated from ThunderLang (intent-codegen-v1). Deterministic, no AI.`,
+    "# The dataclass contract and the decision logic are fully determined by the intent;",
+    "# business logic marked TODO is yours, bound by the guarantees and never-rules below.",
+    ""
+  ];
+  const hasData = (ast.inputs || []).length || (ast.outputs || []).length;
+  if (hasData) L.push("from __future__ import annotations", "from dataclasses import dataclass", "");
+  const cls = (name, fields) => fields.length ? ["@dataclass", `class ${name}:`, ...fields.map((f) => `    ${f.name}: ${pyType(f.type, domain)}`), ""] : [];
+  if ((ast.inputs || []).length) L.push(...cls(`${subject}Input`, ast.inputs));
+  if ((ast.outputs || []).length) L.push(...cls(`${subject}Output`, ast.outputs));
+  for (const d of ast.decisions || []) {
+    const inputs = d.inputs || [];
+    L.push(`# decision ${d.name} , first matching rule wins.`);
+    L.push(`def ${snake(d.name)}(${inputs.join(", ")}) -> str:`);
+    for (const r of d.rules || []) {
+      let cond, note = "";
+      try {
+        cond = exprToPython(r.when, { inputs });
+      } catch {
+        cond = "False";
+        note = `  # TODO: could not translate "${r.when}"`;
+      }
+      L.push(`    if ${cond}:${note}`);
+      L.push(`        return ${JSON.stringify(r.result)}  # rule ${r.name}`);
+    }
+    L.push(`    return ${JSON.stringify(d.default ?? "Undecided")}  # default`, "");
+  }
+  const inName = (ast.inputs || []).length ? `${subject}Input` : null;
+  const outName = (ast.outputs || []).length ? `${subject}Output` : "None";
+  L.push(`def run(${inName ? `input: ${inName}` : ""}) -> ${outName}:`);
+  for (const r of ast.requires || []) L.push(`    # precondition: ${r}  , TODO: validate`);
+  for (const n of ast.neverRules || []) L.push(`    # NEVER: ${n.statement}`);
+  for (const g of ast.guarantees || []) L.push(`    # GUARANTEE: ${g.statement}`);
+  L.push('    raise NotImplementedError("TODO: implement , the intent above defines what this must do.")', "");
+  const stubs = [...domain].filter((t) => !PY_TYPES[t] && /^[A-Z]/.test(t)).sort();
+  if (stubs.length) {
+    L.push("# Domain types referenced by the intent , complete these.");
+    for (const t of stubs) L.push(`class ${t}: pass  # TODO: fields`);
+    L.push("");
+  }
+  return L.join("\n");
+}
 var GENERATORS = {
   typescript: toTypeScript,
   ts: toTypeScript,
   csharp: toCSharp,
   cs: toCSharp,
-  java: toJava
+  java: toJava,
+  python: toPython,
+  py: toPython
 };
 
 // src/changes.mjs
@@ -8527,6 +8615,54 @@ function verifyDiff(intentText, { before = null, after, language = "typescript"
   };
 }
 
+// src/mcp.mjs
+var import_node_child_process = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+
+// src/conformance.mjs
+function buildConformance(ast, { targets = [], results = null } = {}) {
+  const sem = runTests(ast);
+  const cases = (sem.results || []).map((r) => ({
+    key: `${r.target} / ${r.case}`,
+    test: r.target,
+    case: r.case,
+    inputs: r.inputs || {},
+    expected: r.expected,
+    semantic: r.actual,
+    semanticPass: !!r.pass
+  }));
+  const columns = (targets.length ? targets : ast.targets || []).map((t) => String(t).toLowerCase());
+  const rows = cases.map((c) => {
+    const t = {};
+    for (const col of columns) {
+      const tr = results && results[col];
+      if (!tr || !(c.key in tr)) {
+        t[col] = { status: "declared" };
+        continue;
+      }
+      const actual = tr[c.key];
+      t[col] = { status: String(actual) === String(c.expected) ? "pass" : "fail", actual };
+    }
+    return { ...c, targets: t };
+  });
+  const failures = [];
+  for (const row of rows) for (const col of columns) {
+    const tr = row.targets[col];
+    if (tr.status === "fail") failures.push({ target: col, case: row.key, expected: row.expected, actual: tr.actual });
+  }
+  return {
+    schema: "thunder-conformance-v1",
+    mission: ast.mission,
+    total: cases.length,
+    columns,
+    semanticFailures: cases.filter((c) => !c.semanticPass).length,
+    graded: !!results,
+    failures,
+    cases: rows
+  };
+}
+
 // src/draft.mjs
 var DRAFT_SCHEMA = "intent-draft-v1";
 var SECRET_TYPES2 = /* @__PURE__ */ new Set(["secret", "password", "passwd", "jwt", "token", "apikey", "api_key", "privatekey", "private_key", "credential", "cvv"]);
@@ -8618,6 +8754,75 @@ function draftIntent(brief = {}) {
 // src/mcp.mjs
 var PROTOCOL_VERSION = "2024-11-05";
 var str = { type: "string" };
+function resolveObligations(ast) {
+  const t = runTests(ast);
+  const testPass = /* @__PURE__ */ new Map();
+  for (const res of t.results || []) {
+    const cur = testPass.get(res.target);
+    testPass.set(res.target, cur === void 0 ? !!res.pass : cur && !!res.pass);
+  }
+  const norm4 = (s) => String(s).toLowerCase().replace(/[^a-z0-9]/g, "");
+  const matchTest = (verifyText) => {
+    const v = norm4(verifyText);
+    if (!v) return null;
+    for (const [name, pass] of testPass) {
+      const n = norm4(name);
+      if (n && (n === v || n.includes(v) || v.includes(n))) return { name, pass };
+    }
+    return null;
+  };
+  const build = (kind, o) => {
+    const verify = o.verify || [];
+    let status = "unverified", provenBy = null;
+    if (verify.length) {
+      let m = null;
+      for (const vt of verify) {
+        const x = matchTest(vt);
+        if (x) {
+          m = x;
+          if (!x.pass) break;
+        }
+      }
+      if (m) {
+        status = m.pass ? "verified" : "failed";
+        provenBy = m.name;
+      } else status = "declared";
+    }
+    return { kind, id: o.id, status, provenBy };
+  };
+  const obligations = [...ast.guarantees.map((g) => build("guarantee", g)), ...ast.neverRules.map((n) => build("prohibition", n))];
+  return { obligations, tests: t, failed: obligations.filter((o) => o.status === "failed").length };
+}
+var LOCKFILES = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "poetry.lock", "Pipfile.lock", "Cargo.lock", "go.sum", "Gemfile.lock", "composer.lock"];
+function proofFreshness(proof, environment) {
+  let head = null;
+  try {
+    head = (0, import_node_child_process.execSync)("git rev-parse HEAD", { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }).trim() || null;
+  } catch {
+    head = null;
+  }
+  let lock = null, dir = process.cwd();
+  for (let i = 0; i < 6 && !lock; i++) {
+    for (const lf of LOCKFILES) {
+      const p = (0, import_node_path.join)(dir, lf);
+      if ((0, import_node_fs.existsSync)(p)) {
+        lock = p;
+        break;
+      }
+    }
+    const parent = (0, import_node_path.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return {
+    intentHash: proof.sourceHash,
+    compilerVersion: proof.compilerVersion,
+    implementation: head,
+    dependencies: lock ? { file: (0, import_node_path.basename)(lock), hash: sha256((0, import_node_fs.readFileSync)(lock, "utf8")) } : null,
+    environment: environment || null,
+    generatedAt: proof.generatedAt
+  };
+}
 var TOOLS = [
   {
     name: "intent_check",
@@ -8643,6 +8848,75 @@ var TOOLS = [
     },
     run: ({ intent, after, before = null, language = "typescript" }) => verifyDiff(String(intent), { before: before == null ? null : String(before), after: String(after), language })
   },
+  {
+    name: "intent_prove",
+    description: "Emit the durable intent-proof-v1 artifact for .intent source: per-claim verdicts (verified / failed / planned / needs_verification, each bound to the named test that proves it) plus the freshness tuple (intent hash, compiler version, commit, dependency lockfile) that lets `thunder verify` mark the proof STALE later. Mirrors `thunder prove`; an unverified claim never reads as passed. Call it after the gate passes to record WHAT was proven.",
+    inputSchema: {
+      type: "object",
+      required: ["source"],
+      properties: {
+        source: { ...str, description: "the .intent source" },
+        sourceFile: { ...str, description: "file name to record in the proof (default intent.thunder)" },
+        environment: { ...str, description: "environment name to bind into the freshness tuple (optional)" }
+      }
+    },
+    run: ({ source, sourceFile = "intent.thunder", environment }) => {
+      const text = String(source);
+      const ast = parseIntent(text);
+      const diagnostics = semanticDiagnostics(ast);
+      const resolved = resolveObligations(ast);
+      const proof = buildProof(ast, {
+        sourceFile: String(sourceFile),
+        sourceHash: sha256(text),
+        targetsRequested: ast.targets || [],
+        targetsGenerated: [],
+        diagnostics,
+        generatedAt: (/* @__PURE__ */ 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 = proofFreshness(proof, environment);
+      const ok = proof.verification.semanticPassed && resolved.tests.ok !== false && resolved.failed === 0;
+      return { ok, proofId: `proof-${proof.sourceHash.replace("sha256:", "").slice(0, 6)}`, ...proof, tests: resolved.tests };
+    }
+  },
+  {
+    name: "intent_conform",
+    description: 'Grade cross-target conformance (thunder-conformance-v1): the deterministic engine defines the canonical result every in-file test case must produce, and each target\'s outputs (passed via `results`) are graded against it. Same tests, every implementation , a diverging target case is a CONFORMANCE FAILURE. Mirrors `thunder conform`. Without `results`, targets honestly stay "declared", never "pass".',
+    inputSchema: {
+      type: "object",
+      required: ["source"],
+      properties: {
+        source: { ...str, description: "the .intent source (with test blocks)" },
+        targets: { type: "array", items: str, description: "target languages to grade (default: the targets the intent declares)" },
+        results: { type: "object", description: 'per-target actual outputs to grade: {target: {"Test / case": result}}' }
+      }
+    },
+    run: ({ source, targets = [], results = null }) => {
+      const rep = buildConformance(parseIntent(String(source)), { targets: Array.isArray(targets) ? targets.map(String) : [], results });
+      return { ok: rep.semanticFailures === 0 && rep.failures.length === 0, ...rep };
+    }
+  },
+  {
+    name: "intent_drift",
+    description: "Check whether real code, as it exists TODAY, still satisfies its intent , the standing-guard complement to intent_verify_diff (no diff needed). Re-lifts the code and reports drift findings: guarantees with no matching evidence, never-rules with no guard, declared inputs missing from the signature, and new behavior the intent never declared. Mirrors `thunder drift`.",
+    inputSchema: {
+      type: "object",
+      required: ["intent", "code"],
+      properties: {
+        intent: { ...str, description: "the approved .intent source (the contract)" },
+        code: { ...str, description: "the implementation source as it exists now" },
+        language: { ...str, description: `source language (default typescript). One of: ${SUPPORTED_LANGUAGES.join(", ")}` }
+      }
+    },
+    run: ({ intent, code, language = "typescript" }) => checkDrift(String(intent), String(code), { language })
+  },
   {
     name: "intent_draft",
     description: "Turn a STRUCTURED brief into a rigorous, canonically-formatted ThunderLang draft plus a review checklist of what a human must still fill in (unverified guarantees, unguarded secrets, missing goal). Use this after distilling a user request into structured fields; the draft is a proposal for human approval, never verified.",
@@ -9508,6 +9782,7 @@ function startLspServer({ readable = process.stdin, writable = process.stdout }
   toMermaid,
   toOpenAPI,
   toPlaywright,
+  toPython,
   toSMV,
   toSarif,
   toTypeScript,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillstech/thunderlang",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "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",

package/src/cli.mjs

@@ -327,81 +327,83 @@ function printDiagnostics(diags) {
 
 const HELP = `thunder , the ThunderLang compiler + engine (deterministic, no AI required)
 
+The flow: author intent, inspect it, run and prove it, then keep real code aligned with it.
+
 usage: thunder <command> <file> [options]
        thunder mission <Name> <command>     run any command on a mission by name
 
-Everyday
-  new [Name]               scaffold a runnable starter mission (Name.thunder)   [alias: init]
-  mission <Name> [cmd]     resolve a mission by name and run a command on it (list | <Name> | <Name> <cmd>)
-  check <file|dir>         parse + lint + explainable diagnostics
-  run <file> --inputs '<json>'         execute the decision(s) deterministically
+Author
+  new [Name]                 scaffold a runnable starter mission (Name.thunder)   [alias: init]
+  mission <Name> [cmd]       resolve a mission by name and run a command on it (list | <Name> | <Name> <cmd>)
+  draft --brief <json|->     scaffold a rigorous intent draft + gap checklist from a brief
+  edit <file> [--edits <json|->] [--set-goal ..] [--add-guarantee ..] [--write]   structural edits, comments kept
+  fmt <file|dir> [--write|--check]   canonical formatting (whitespace only; comments kept)
+  source <file|graph.json>   regenerate .thunder from a persisted graph
+
+Inspect
+  check <file|dir> [--json|--format sarif]   parse + lint + explainable diagnostics; gate a whole dir
+  report [dir] [--json]      repo-wide intent health: severity + area counts, coverage
+  risks | gaps | unverified | coverage | unknowns | contradictions [dir] [--json]   focused scan queries
+  focus <mission|query|--nodes a,b> [--depth N] [--dir <d>] [--json]   Intent Lens: focused graph + brief
+  comprehension <file|dir> [--observed] [--learning] [--governed] [--json]   the C0..C7 understanding level
+  twelve-factor <file> [--json]   score against the 13 humanlayer/12-factor-agents principles   [alias: 12factor]
+  explain <IL-CODE>          explain a diagnostic code (area, severity, what it blocks)
+  rules [--json]             list the whole canonical diagnostic catalog
+  notes <file> [--lens <lens>] [--json]   ThunderLens: the compiled note blocks by lens (not verification)
+  docs <file> [--lens <lens>] [--out <dir>]   render a mission as Markdown docs (per-audience with --lens)
+  index <dir>                the Mission Atlas inventory
+  atlas <dir> [--search q | --expand id]   the whole-system Atlas
+
+Run & test
+  run <file> --inputs '<json>'   execute the decision(s) deterministically
   test <file> [--contracts | --properties | --scenarios | --mutate | --evals | --changed | --coverage] [--strict]
   test <file> --target typescript|python|csharp|java   run the tests against the EXECUTED generated code
-  test <file> --all-targets            run the tests against every AVAILABLE target in one pass
-  prove <file>             emit an intent-proof-v1 artifact (honest verdicts + freshness)
+  test <file> --all-targets  run the tests against every AVAILABLE target in one pass
+  simulate <file> --events a,b,c   walk the lifecycle(s) over events
+  outcomes <file>            evaluate outcome contracts vs delivery results
+  style <file>               resolve style intents vs the canonical token space
+  gen <file> [--target typescript|csharp|java|python] [--out <dir>]   deterministic code scaffold (types + decision logic + TODOs)
+  build <file>               generate docs, contract graph, test plan, and .thunder-proof.json
+
+Prove & verify intent
+  prove <file>               emit an intent-proof-v1 artifact (honest verdicts + freshness)
+  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
-  build <file>             generate docs, contract graph, test plan, targets
-
-Author & check
-  init [Name]              scaffold a runnable starter mission (Name.thunder)
-  draft --brief <json|->   scaffold a rigorous intent draft + gap checklist from a brief
-  check <file|dir> [--json|--format sarif]  diagnostics for one file, or gate a whole dir
-  report [dir] [--json]     repo-wide intent health: severity + area counts, coverage
-  scan [dir] [--json] [--ir <path>]  Scanner: intent -> Intent IR -> Fable findings -> risk themes
-  risks | gaps | unverified | coverage | unknowns | contradictions [dir] [--json]  focused scan queries
-  focus <mission|query|--nodes a,b> [--depth N] [--dir <d>] [--json]  Intent Lens: focused graph + brief
-  comprehension <file|dir> [--observed] [--learning] [--governed] [--json]  the C0..C7 understanding level
-  twelve-factor <file> [--json]  score an intent against the 13 humanlayer/12-factor-agents principles
-  gen <file> [--target typescript|csharp|java] [--out <dir>]  deterministic code scaffold (types + decision logic + TODOs)
-  changes [<base>..<head> | <base>] [--json]  Change Lens: what a branch/PR changed by meaning
-  guardian <before> <after>  drift: what changed, what risk, what to reverify, what learning is stale
-  impact <base> <proposed>  Simulator: estimate a change's blast radius + risk BEFORE building it
-  ledger <file.json> [--subject <id>]  verify the tamper-evident history + explain why/who/what changed
-  guard <file> [--json]     preview the runtime guard (redacted fields, enforced decisions)
-  fmt <file|dir> [--write|--check]  canonical formatting (whitespace only; comments kept)
-  edit <file> [--edits <json|->] [--set-goal ..] [--add-guarantee ..] [--write]  structural edits, comments kept
-  lsp                      start the Language Server (LSP over stdio, for editors)
-  mcp                      start the MCP server (for AI coding agents; stdio)
-  build <file>              docs, contract graph, test plan, and .thunder-proof.json
-  graph <file> [--safe]     the canonical Intent Graph (intent-graph-v1); --safe = display-safe on stdout
-  proof <file>              the .thunder-proof.json artifact
-  proof --schema            emit the canonical proof envelope JSON Schema (intent-proof-v1)
-  verify <proof.json> [src]  confirm a proof is well-formed and still matches its source
-  conform <file> [--targets a,b] [--run typescript,python,csharp,java | --all-targets] [--results <json>]  run the same cases against every target (conformance matrix)
-  schema                    emit the canonical graph schema + diagnostic catalog
-  explain <IL-CODE>         explain a diagnostic code (area, severity, what it blocks)
-  rules [--json]            list the whole canonical diagnostic catalog
-  notes <file> [--lens <lens>] [--json]  ThunderLens: the compiled note blocks by lens (not verification)
-  docs <file> [--lens <lens>] [--out <dir>]  render a mission as Markdown docs (per-audience with --lens)
-  code-actions <file> [--json]  available quick-fixes, safety-graded (safe | reviewable)
-  apply-fix <file> [--write]    apply the SAFE autocorrects (header aliases, stray colons)
-
-Execute (no AI, no generated code)
-  run <file> --inputs '<json>'      evaluate the decision(s) against inputs
-  simulate <file> --events a,b,c    walk the lifecycle(s) over events
-  test <file>                       run the in-file test blocks (case/scenario)
-  outcomes <file>                   evaluate outcome contracts vs delivery results
-  style <file>                      resolve style intents vs the canonical token space
+  conform <file> [--targets a,b] [--run typescript,python,csharp,java | --all-targets] [--results <json>]   conformance matrix across targets
+
+Real code vs intent (drift)
+  lift <file> [--from <lang>]    lift source code into inferred intent
+  drift <codeFile> --intent <file.intent> [--from <lang>]   check intent vs code drift
+  approve <file> --by <name>     approve intent (drift baseline)
+  verify-diff <intent> --after <code> [--before <code>]   gate a code change against its intent
+  changes [<base>..<head> | <base>] [--json]   Change Lens: what a branch/PR changed by meaning
+  guardian <before> <after>      drift: what changed, what risk, what to reverify, what learning is stale
+  impact <base> <proposed>       Simulator: estimate a change's blast radius + risk BEFORE building it
+  diff <before> <after>          semantic diff (by meaning)
+  merge <base> <ours> <theirs>   deterministic 3-way semantic merge
+  handoff <file>                 the OpenThunder drift handoff
+  ledger <file.json> [--subject <id>]   verify the tamper-evident history + explain why/who/what changed
+  guard <file> [--json]          preview the runtime guard (redacted fields, enforced decisions)
+
+Graph & IR
+  graph <file> [--safe]      the canonical Intent Graph (intent-graph-v1); --safe = display-safe on stdout
+  migrate <graph.json> [--to <version>]   upgrade a persisted graph
+  validate <graph.json> [--json]   check a graph is canonical (anti-fork)
+  schema                     emit the canonical graph schema + diagnostic catalog
 
 Interop
   export <file> --format <dmn|bpmn|smv|jsonschema|openapi|tokens|mermaid|css|playwright>   render to a standard format
-  import <file> [--format dmn|bpmn] [--json]                 lift DMN/BPMN into intent
-  source <file|graph.json>                                   regenerate .thunder from a graph
-  migrate <graph.json> [--to <version>]                      upgrade a persisted graph
-  validate <graph.json> [--json]                             check a graph is canonical (anti-fork)
+  import <file> [--format dmn|bpmn] [--json]   lift DMN/BPMN into intent
 
-Navigate & compare (over many missions)
-  atlas <dir> [--search q | --expand id]   the whole-system Atlas
-  index <dir>                              the Mission Atlas inventory
-  diff <before> <after>                    semantic diff (by meaning)
-  merge <base> <ours> <theirs>             deterministic 3-way semantic merge
+Fix
+  scan [dir] [--json] [--ir <path>]   Scanner: intent -> Intent IR -> Fable findings -> risk themes
+  code-actions <file> [--json]   available quick-fixes, safety-graded (safe | reviewable)
+  apply-fix <file> [--write]     apply the SAFE autocorrects (header aliases, stray colons)
 
-Code <-> intent
-  lift <file> [--from <lang>]   lift source code into inferred intent
-  approve <file> --by <name>    approve intent (drift baseline)
-  drift <file> --from <code>    check intent vs code drift
-  verify-diff <intent> --after <code> [--before <code>]  gate a code change against its intent
-  handoff <file>                the OpenThunder drift handoff
+Servers
+  lsp                        start the Language Server (LSP over stdio, for editors)
+  mcp                        start the MCP server (for AI coding agents; stdio)
 
 Common options: --out <dir>, --json, --no-ai. See https://thunderlang.dev/docs`;
 
@@ -648,7 +650,7 @@ function main() {
     return;
   }
 
-  // `thunder gen <file> [--target typescript|csharp|java] [--out <dir>]` , deterministic code scaffold from
+  // `thunder gen <file> [--target typescript|csharp|java|python] [--out <dir>]` , deterministic code scaffold from
   // intent. Generates the typed contract + the decision logic (already executable) and leaves
   // honest TODO markers for business logic. No AI. Prints, or writes with --out.
   if (cmd === 'gen') {
@@ -659,7 +661,7 @@ function main() {
     const ast = parseIntent(readFileSync(file, 'utf8'));
     const code = generate(ast);
     if (args.outExplicit) {
-      const ext = target.startsWith('ts') || target === 'typescript' ? 'ts' : target;
+      const ext = target.startsWith('ts') || target === 'typescript' ? 'ts' : target === 'python' ? 'py' : target === 'csharp' ? 'cs' : target;
       const p = writeText(args.out, `${slug(subjectName(ast) || 'intent')}.${ext}`, code.endsWith('\n') ? code : code + '\n');
       console.log(`wrote ${p.replace(process.cwd() + '/', '')}`);
       return;

package/src/codegen.mjs

@@ -5,9 +5,9 @@
 // the "see how it works, then change it" surface for the playground and `thunder gen`.
 //
 // Pure and browser-safe so the playground can render it. TypeScript first; the same adapter
-// shape (a type map + a body walk) extends to C# / Java.
+// shape (a type map + a body walk) extends to C# / Java / Python.
 
-import { exprToJs, exprToCSharp, exprToJava } from './expr.mjs';
+import { exprToJs, exprToCSharp, exprToJava, exprToPython } from './expr.mjs';
 import { subjectName } from './parse.mjs';
 
 export const CODEGEN_SCHEMA = 'intent-codegen-v1';
@@ -138,7 +138,7 @@ export function toCSharp(ast) {
     L.push(`  public static string ${pascal(d.name)}(${inputs.map((i) => `dynamic ${i}`).join(', ')})`);
     L.push('  {');
     for (const r of d.rules || []) {
-      let cond; try { cond = exprToCSharp(r.when, { inputs }); } catch { cond = `false /* TODO: "${r.when}" */`; }
+      let cond; try { cond = exprToCSharp(r.when, { inputs }); } catch { cond = `false /* TODO: could not translate "${r.when}" */`; }
       L.push(`    if (${cond}) return ${JSON.stringify(r.result)}; // rule ${r.name}`);
     }
     L.push(`    return ${JSON.stringify(d.default ?? 'Undecided')}; // default`, '  }');
@@ -146,6 +146,7 @@ export function toCSharp(ast) {
   const inName = (ast.inputs || []).length ? `${subject}Input` : null;
   const outName = (ast.outputs || []).length ? `${subject}Output` : 'void';
   L.push(`  public static ${outName} Run(${inName ? `${inName} input` : ''})`, '  {');
+  for (const r of ast.requires || []) L.push(`    // precondition: ${r}  , TODO: validate`);
   for (const n of ast.neverRules || []) L.push(`    // NEVER: ${n.statement}`);
   for (const g of ast.guarantees || []) L.push(`    // GUARANTEE: ${g.statement}`);
   L.push('    throw new NotImplementedException("TODO: implement , the intent above defines what this must do.");', '  }');
@@ -192,7 +193,7 @@ export function toJava(ast) {
     L.push(`  // decision ${d.name} , first matching rule wins.`);
     L.push(`  public static String ${lower(pascal(d.name))}(${inputs.map((i) => `Object ${i}`).join(', ')}) {`);
     for (const r of d.rules || []) {
-      let cond; try { cond = exprToJava(r.when, { inputs }); } catch { cond = `false /* TODO: "${r.when}" */`; }
+      let cond; try { cond = exprToJava(r.when, { inputs }); } catch { cond = `false /* TODO: could not translate "${r.when}" */`; }
       L.push(`    if (${cond}) return ${JSON.stringify(r.result)}; // rule ${r.name}`);
     }
     L.push(`    return ${JSON.stringify(d.default ?? 'Undecided')}; // default`, '  }');
@@ -200,6 +201,7 @@ export function toJava(ast) {
   const inName = (ast.inputs || []).length ? `${subject}Input` : null;
   const outName = (ast.outputs || []).length ? `${subject}Output` : 'void';
   L.push(`  public static ${outName} run(${inName ? `${inName} input` : ''}) {`);
+  for (const r of ast.requires || []) L.push(`    // precondition: ${r}  , TODO: validate`);
   for (const n of ast.neverRules || []) L.push(`    // NEVER: ${n.statement}`);
   for (const g of ast.guarantees || []) L.push(`    // GUARANTEE: ${g.statement}`);
   L.push('    throw new UnsupportedOperationException("TODO: implement , the intent above defines what this must do.");', '  }');
@@ -207,8 +209,75 @@ export function toJava(ast) {
   return L.join('\n');
 }
 
+// ── Python ───────────────────────────────────────────────────────────────────
+const PY_TYPES = {
+  Email: 'str', Url: 'str', UserId: 'str', AccountId: 'str', OrderId: 'str',
+  InvoiceId: 'str', CustomerId: 'str', Secret: 'str', Token: 'str', Jwt: 'str',
+  IdempotencyKey: 'str', Currency: 'str', Date: 'str', DateTime: 'str',
+  Money: 'float', Percentage: 'float', Count: 'int', Duration: 'int', Flag: 'bool',
+};
+function pyType(type, domain) {
+  if (!type) return 'object';
+  const list = /^List<(.+)>$/.exec(type);
+  if (list) return `list[${pyType(list[1], domain)}]`;
+  const base = type.replace(/\(.*\)/, '');
+  if (PY_TYPES[base]) return PY_TYPES[base];
+  domain.add(base); return base;
+}
+// PascalCase/camelCase -> snake_case, for idiomatic Python function names. Field and decision
+// input names stay verbatim: the translated conditions reference them by their intent names.
+const snake = (s) => pascal(s).replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+
+/** Generate a deterministic Python scaffold from an intent AST. */
+export function toPython(ast) {
+  const subject = pascal(subjectName(ast) || 'Intent');
+  const domain = new Set();
+  const L = [
+    `# ${subject} , generated from ThunderLang (intent-codegen-v1). Deterministic, no AI.`,
+    '# The dataclass contract and the decision logic are fully determined by the intent;',
+    '# business logic marked TODO is yours, bound by the guarantees and never-rules below.',
+    '',
+  ];
+  const hasData = (ast.inputs || []).length || (ast.outputs || []).length;
+  // Postponed annotations so a dataclass may reference a domain stub declared below it.
+  if (hasData) L.push('from __future__ import annotations', 'from dataclasses import dataclass', '');
+  const cls = (name, fields) => fields.length
+    ? ['@dataclass', `class ${name}:`, ...fields.map((f) => `    ${f.name}: ${pyType(f.type, domain)}`), '']
+    : [];
+  if ((ast.inputs || []).length) L.push(...cls(`${subject}Input`, ast.inputs));
+  if ((ast.outputs || []).length) L.push(...cls(`${subject}Output`, ast.outputs));
+  for (const d of ast.decisions || []) {
+    const inputs = d.inputs || [];
+    L.push(`# decision ${d.name} , first matching rule wins.`);
+    L.push(`def ${snake(d.name)}(${inputs.join(', ')}) -> str:`);
+    for (const r of d.rules || []) {
+      let cond, note = '';
+      try { cond = exprToPython(r.when, { inputs }); }
+      catch { cond = 'False'; note = `  # TODO: could not translate "${r.when}"`; }
+      L.push(`    if ${cond}:${note}`);
+      L.push(`        return ${JSON.stringify(r.result)}  # rule ${r.name}`);
+    }
+    L.push(`    return ${JSON.stringify(d.default ?? 'Undecided')}  # default`, '');
+  }
+  const inName = (ast.inputs || []).length ? `${subject}Input` : null;
+  const outName = (ast.outputs || []).length ? `${subject}Output` : 'None';
+  L.push(`def run(${inName ? `input: ${inName}` : ''}) -> ${outName}:`);
+  for (const r of ast.requires || []) L.push(`    # precondition: ${r}  , TODO: validate`);
+  for (const n of ast.neverRules || []) L.push(`    # NEVER: ${n.statement}`);
+  for (const g of ast.guarantees || []) L.push(`    # GUARANTEE: ${g.statement}`);
+  L.push('    raise NotImplementedError("TODO: implement , the intent above defines what this must do.")', '');
+  const stubs = [...domain].filter((t) => !PY_TYPES[t] && /^[A-Z]/.test(t)).sort();
+  if (stubs.length) {
+    L.push('# Domain types referenced by the intent , complete these.');
+    for (const t of stubs) L.push(`class ${t}: pass  # TODO: fields`);
+    L.push('');
+  }
+  return L.join('\n');
+}
+
 export const GENERATORS = {
   typescript: toTypeScript, ts: toTypeScript,
   csharp: toCSharp, cs: toCSharp,
   java: toJava,
+  python: toPython, py: toPython,
 };

package/src/core.d.ts

@@ -50,7 +50,7 @@ export {
 } from './index';
 
 // Code generation , deterministic scaffolds from intent.
-export { CODEGEN_SCHEMA, GENERATORS, toTypeScript, toCSharp, toJava, subjectName, intentRefId, skillRefId } from './index';
+export { CODEGEN_SCHEMA, GENERATORS, toTypeScript, toCSharp, toJava, toPython, subjectName, intentRefId, skillRefId } from './index';
 
 // 12-Factor Agents conformance lens (twelve-factor-v1).
 export { TWELVE_FACTOR_SCHEMA, TwelveFactorResult, twelveFactorReport, twelveFactorSummary } from './index';

package/src/core.mjs

@@ -80,7 +80,7 @@ export { FOCUS_SCHEMA, SCOPE_TYPES, FOCUS_REASONS, makeScope, buildFocusGraph, i
 // Comprehension Contract: the C0..C7 understanding level (browser-safe; every product reads it).
 export { COMPREHENSION_SCHEMA, LEVELS as COMPREHENSION_LEVELS, comprehensionLevel, comprehensionReport } from './comprehension.mjs';
 // Code generation: deterministic scaffolds from intent (browser-safe, so the playground renders it).
-export { CODEGEN_SCHEMA, GENERATORS, toTypeScript, toCSharp, toJava } from './codegen.mjs';
+export { CODEGEN_SCHEMA, GENERATORS, toTypeScript, toCSharp, toJava, toPython } from './codegen.mjs';
 // Change Lens: what a branch/PR changed by meaning (pure; the CLI supplies the git-diffed graphs).
 export { CHANGES_SCHEMA, changeReport } from './changes.mjs';
 export { subjectName, intentRefId, skillRefId } from './parse.mjs';

package/src/emit.mjs

@@ -30,7 +30,7 @@ export function notesSummary(ast) {
   };
 }
 
-export const COMPILER_VERSION = '0.3.0';
+export const COMPILER_VERSION = '0.4.1';
 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/exporters.mjs

@@ -180,17 +180,23 @@ export function toMermaid(ast) {
 
 // ── Playwright (experience -> E2E test scaffold) ─────────────────────────────
 // A SKELETON, not a passing test: declared experiences/journeys/states become structured
-// Playwright stubs (describe/test/test.step) with TODOs for selectors + assertions. This is
-// the test-plan target for the experience profile , it turns "what the UI must do" into the
-// shape of the test that proves it, deterministically. Consistent with the compiler's scope
-// (test scaffolds, not production code).
+// Playwright stubs (describe/test/test.step) with TODOs for selectors + assertions. The
+// TODOs are intentional and stay: a deterministic compiler cannot know the app's selectors,
+// so it must not fabricate them. To keep the scaffold honest, every generated test opens
+// with a test.fixme(true, ...) guard: Playwright reports it as "fixme" (not a vacuous pass)
+// until a human fills in the body and removes the guard. This is the test-plan target for
+// the experience profile , it turns "what the UI must do" into the shape of the test that
+// proves it, deterministically. Consistent with the compiler's scope (test scaffolds, not
+// production code).
 const jsStr = (s) => `'${String(s ?? '').replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\r?\n/g, ' ')}'`;
 
 export function toPlaywright(ast) {
   const exps = ast.experiences || [];
   const L = [];
   L.push('// Playwright test scaffold generated from experience intent by @skillstech/thunderlang.');
-  L.push('// SKELETON: fill in selectors and assertions. It is not a passing test until you do.');
+  L.push('// SKELETON: fill in selectors and assertions. Every test starts with a test.fixme');
+  L.push('// guard so an unimplemented scaffold reports "fixme" instead of passing vacuously;');
+  L.push('// remove the guard from each test once its body is real.');
   L.push("import { test, expect } from '@playwright/test';");
   L.push('');
   if (!exps.length) {
@@ -204,6 +210,7 @@ export function toPlaywright(ast) {
     }
     for (const j of exp.journeys || []) {
       L.push(`  test(${jsStr(j.name || 'journey')}, async ({ page }) => {`);
+      L.push(`    test.fixme(true, ${jsStr('scaffold: implement the steps, then remove this guard')});`);
       if (!(j.steps || []).length) L.push('    // TODO: no steps declared for this journey');
       for (const step of j.steps || []) {
         L.push(`    await test.step(${jsStr(step)}, async () => {`);
@@ -215,10 +222,12 @@ export function toPlaywright(ast) {
     for (const st of exp.states || []) {
       if (st.hasRecovery) {
         L.push(`  test(${jsStr(`failure state "${st.name}" offers a recovery path`)}, async ({ page }) => {`);
+        L.push(`    test.fixme(true, ${jsStr('scaffold: implement this state check, then remove this guard')});`);
         L.push(`    // TODO: drive the UI into "${st.name}", assert a recovery action is available`);
         L.push('  });');
       } else {
         L.push(`  test(${jsStr(`reaches state: ${st.name}`)}, async ({ page }) => {`);
+        L.push(`    test.fixme(true, ${jsStr('scaffold: implement this state check, then remove this guard')});`);
         L.push(`    // TODO: drive the UI to "${st.name}" and assert it is shown`);
         L.push('  });');
       }

package/src/index.d.ts

@@ -691,6 +691,7 @@ export const CODEGEN_SCHEMA: string;
 export function toTypeScript(ast: IntentAst): string;
 export function toCSharp(ast: IntentAst): string;
 export function toJava(ast: IntentAst): string;
+export function toPython(ast: IntentAst): string;
 export const GENERATORS: Record<string, (ast: IntentAst) => string>;
 export function exprToJs(src: string, opts?: { inputs?: string[] }): string;
 export function subjectName(ast: IntentAst): string | null;

package/src/index.mjs

@@ -113,7 +113,7 @@ export { FOCUS_SCHEMA, SCOPE_TYPES, FOCUS_REASONS, makeScope, buildFocusGraph, i
 // Comprehension Contract , the C0..C7 understanding level (intent-comprehension-v1)
 export { COMPREHENSION_SCHEMA, LEVELS as COMPREHENSION_LEVELS, comprehensionLevel, comprehensionReport } from './comprehension.mjs';
 // Code generation , deterministic scaffolds from intent (intent-codegen-v1)
-export { CODEGEN_SCHEMA, GENERATORS, toTypeScript, toCSharp, toJava } from './codegen.mjs';
+export { CODEGEN_SCHEMA, GENERATORS, toTypeScript, toCSharp, toJava, toPython } from './codegen.mjs';
 // Change Lens , what a branch/PR changed by meaning (intent-changes-v1)
 export { CHANGES_SCHEMA, changeReport } from './changes.mjs';
 export { exprToJs, exprToCSharp, exprToJava, exprToCode } from './expr.mjs';

package/src/mcp.mjs

@@ -6,19 +6,79 @@
 //
 // Start it with `thunder mcp`. Point an MCP client at that command.
 
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
 import { parseIntent } from './parse.mjs';
-import { semanticDiagnostics, COMPILER_VERSION } from './emit.mjs';
+import { semanticDiagnostics, buildProof, COMPILER_VERSION } from './emit.mjs';
+import { sha256 } from './hash.mjs';
 import { verifyDiff } from './verify-diff.mjs';
 import { liftSource, SUPPORTED_LANGUAGES } from './lift.mjs';
 import { runTests } from './testing.mjs';
 import { evaluateDecision } from './runtime.mjs';
 import { buildIntentGraph } from './intent-graph.mjs';
+import { buildConformance } from './conformance.mjs';
+import { checkDrift } from './drift.mjs';
 import { draftIntent } from './draft.mjs';
 import { ALL_DIAGNOSTICS } from './intent-schema.mjs';
 
 const PROTOCOL_VERSION = '2024-11-05';
 const str = { type: 'string' };
 
+// ── prove helpers ────────────────────────────────────────────────────────────
+// Per-claim resolution , mirrors resolveObligations in cli.mjs (shared there by `thunder test
+// --contracts` and `thunder prove`) so the MCP proof and the CLI proof agree claim for claim.
+// States: verified (proven by a passing named test), failed (its test fails), declared (a
+// verification is named but not runnable in-file), unverified (nothing).
+function resolveObligations(ast) {
+  const t = runTests(ast);
+  const testPass = new Map();
+  for (const res of (t.results || [])) {
+    const cur = testPass.get(res.target);
+    testPass.set(res.target, cur === undefined ? !!res.pass : cur && !!res.pass);
+  }
+  const norm = (s) => String(s).toLowerCase().replace(/[^a-z0-9]/g, '');
+  const matchTest = (verifyText) => {
+    const v = norm(verifyText); if (!v) return null;
+    for (const [name, pass] of testPass) { const n = norm(name); if (n && (n === v || n.includes(v) || v.includes(n))) return { name, pass }; }
+    return null;
+  };
+  const build = (kind, o) => {
+    const verify = o.verify || [];
+    let status = 'unverified', provenBy = null;
+    if (verify.length) {
+      let m = null;
+      for (const vt of verify) { const x = matchTest(vt); if (x) { m = x; if (!x.pass) break; } }
+      if (m) { status = m.pass ? 'verified' : 'failed'; provenBy = m.name; } else status = 'declared';
+    }
+    return { kind, id: o.id, status, provenBy };
+  };
+  const obligations = [...ast.guarantees.map((g) => build('guarantee', g)), ...ast.neverRules.map((n) => build('prohibition', n))];
+  return { obligations, tests: t, failed: obligations.filter((o) => o.status === 'failed').length };
+}
+
+// Freshness tuple , the (intent, implementation, dependencies, compiler, environment) binding
+// `thunder verify` recomputes later to mark a proof STALE. Mirrors freshnessFor in cli.mjs;
+// implementation/dependencies are read from the server's working directory when available.
+const LOCKFILES = ['pnpm-lock.yaml', 'package-lock.json', 'yarn.lock', 'poetry.lock', 'Pipfile.lock', 'Cargo.lock', 'go.sum', 'Gemfile.lock', 'composer.lock'];
+function proofFreshness(proof, environment) {
+  let head = null;
+  try { head = execSync('git rev-parse HEAD', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim() || null; } catch { head = null; }
+  let lock = null, dir = process.cwd();
+  for (let i = 0; i < 6 && !lock; i++) {
+    for (const lf of LOCKFILES) { const p = join(dir, lf); if (existsSync(p)) { lock = p; break; } }
+    const parent = dirname(dir); if (parent === dir) break; dir = parent;
+  }
+  return {
+    intentHash: proof.sourceHash,
+    compilerVersion: proof.compilerVersion,
+    implementation: head,
+    dependencies: lock ? { file: basename(lock), hash: sha256(readFileSync(lock, 'utf8')) } : null,
+    environment: environment || null,
+    generatedAt: proof.generatedAt,
+  };
+}
+
 // Each tool is a pure function of its arguments. `run` returns a JSON-able value or a string.
 const TOOLS = [
   {
@@ -44,6 +104,70 @@ const TOOLS = [
     },
     run: ({ intent, after, before = null, language = 'typescript' }) => verifyDiff(String(intent), { before: before == null ? null : String(before), after: String(after), language }),
   },
+  {
+    name: 'intent_prove',
+    description: 'Emit the durable intent-proof-v1 artifact for .intent source: per-claim verdicts (verified / failed / planned / needs_verification, each bound to the named test that proves it) plus the freshness tuple (intent hash, compiler version, commit, dependency lockfile) that lets `thunder verify` mark the proof STALE later. Mirrors `thunder prove`; an unverified claim never reads as passed. Call it after the gate passes to record WHAT was proven.',
+    inputSchema: {
+      type: 'object', required: ['source'],
+      properties: {
+        source: { ...str, description: 'the .intent source' },
+        sourceFile: { ...str, description: 'file name to record in the proof (default intent.thunder)' },
+        environment: { ...str, description: 'environment name to bind into the freshness tuple (optional)' },
+      },
+    },
+    run: ({ source, sourceFile = 'intent.thunder', environment }) => {
+      const text = String(source);
+      const ast = parseIntent(text);
+      const diagnostics = semanticDiagnostics(ast);
+      const resolved = resolveObligations(ast);
+      const proof = buildProof(ast, {
+        sourceFile: String(sourceFile),
+        sourceHash: sha256(text),
+        targetsRequested: ast.targets || [],
+        targetsGenerated: [],
+        diagnostics,
+        generatedAt: new Date().toISOString(),
+      });
+      // Fold per-claim verdicts into the proof so it records real status, not just planned/needs_verification.
+      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 = proofFreshness(proof, environment);
+      const ok = proof.verification.semanticPassed && resolved.tests.ok !== false && resolved.failed === 0;
+      return { ok, proofId: `proof-${proof.sourceHash.replace('sha256:', '').slice(0, 6)}`, ...proof, tests: resolved.tests };
+    },
+  },
+  {
+    name: 'intent_conform',
+    description: 'Grade cross-target conformance (thunder-conformance-v1): the deterministic engine defines the canonical result every in-file test case must produce, and each target\'s outputs (passed via `results`) are graded against it. Same tests, every implementation , a diverging target case is a CONFORMANCE FAILURE. Mirrors `thunder conform`. Without `results`, targets honestly stay "declared", never "pass".',
+    inputSchema: {
+      type: 'object', required: ['source'],
+      properties: {
+        source: { ...str, description: 'the .intent source (with test blocks)' },
+        targets: { type: 'array', items: str, description: 'target languages to grade (default: the targets the intent declares)' },
+        results: { type: 'object', description: 'per-target actual outputs to grade: {target: {"Test / case": result}}' },
+      },
+    },
+    run: ({ source, targets = [], results = null }) => {
+      const rep = buildConformance(parseIntent(String(source)), { targets: Array.isArray(targets) ? targets.map(String) : [], results });
+      return { ok: rep.semanticFailures === 0 && rep.failures.length === 0, ...rep };
+    },
+  },
+  {
+    name: 'intent_drift',
+    description: 'Check whether real code, as it exists TODAY, still satisfies its intent , the standing-guard complement to intent_verify_diff (no diff needed). Re-lifts the code and reports drift findings: guarantees with no matching evidence, never-rules with no guard, declared inputs missing from the signature, and new behavior the intent never declared. Mirrors `thunder drift`.',
+    inputSchema: {
+      type: 'object', required: ['intent', 'code'],
+      properties: {
+        intent: { ...str, description: 'the approved .intent source (the contract)' },
+        code: { ...str, description: 'the implementation source as it exists now' },
+        language: { ...str, description: `source language (default typescript). One of: ${SUPPORTED_LANGUAGES.join(', ')}` },
+      },
+    },
+    run: ({ intent, code, language = 'typescript' }) => checkDrift(String(intent), String(code), { language }),
+  },
   {
     name: 'intent_draft',
     description: 'Turn a STRUCTURED brief into a rigorous, canonically-formatted ThunderLang draft plus a review checklist of what a human must still fill in (unverified guarantees, unguarded secrets, missing goal). Use this after distilling a user request into structured fields; the draft is a proposal for human approval, never verified.',