@skillstech/thunderlang 0.2.0 → 0.4.1

package/src/cli.mjs

@@ -98,7 +98,13 @@ import {
 import { parseEventLog, serializeEventLog, recordEvent, timeline } from './ai-events.mjs';
 
 // Recursively collect supported source files, skipping vendored / build dirs.
-const LIFT_EXTS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.rs', '.pl', '.pm'];
+// Kept in sync with lift.mjs languageForFile(): every language the lift adapters support,
+// so repo-mode discovery matches the advertised multi-language lift surface.
+const LIFT_EXTS = [
+  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.rs', '.pl', '.pm', '.t',
+  '.py', '.pyi', '.java', '.cs', '.go', '.cpp', '.cc', '.cxx', '.hpp', '.hh', '.c', '.h',
+  '.php', '.rb', '.kt', '.kts', '.scala', '.sc', '.ex', '.exs',
+];
 const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', '.next', 'build', '.intent', 'coverage', '.vercel']);
 // ThunderLang source files. `.thunder` is the canonical public extension; `.tl` is an
 // accepted shorthand; `.intent` stays supported so legacy IntentLang sources keep working.
@@ -321,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`;
 
@@ -642,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') {
@@ -653,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;
@@ -846,9 +854,9 @@ test Example
       return;
     }
 
-    // Single-file mode.
+    // Single-file mode. Auto-detect language by extension (consistent with --all / repo modes).
     const src = readFileSync(file, 'utf8');
-    const res = liftSource(src, { language: args.from || 'typescript', file: basename(file) });
+    const res = liftSource(src, { language: args.from || languageForFile(file), file: basename(file) });
     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) {

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.2.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/lift.mjs

@@ -393,6 +393,74 @@ export function extractFactsRuby(source, file = 'input.rb') {
   return { schemaVersion: IR_SCHEMA_VERSION, sourceLanguage: 'ruby', sourceRoot: file, functions, tests, errors };
 }
 
+// Params written "name: Type" (Kotlin, Scala). Top-level comma split so generics/tuples
+// like Map<String, Int> or (A, B) don't split mid-type. Strips val/var/vararg/implicit and defaults.
+function parseNameColonTypeParams(raw) {
+  return splitTopLevel(raw, ',').map((p) => p.trim()).filter(Boolean).map((p) => {
+    const cleaned = p.replace(/@\w+(\([^)]*\))?/g, '').replace(/^(?:val|var|vararg|implicit|final|lazy)\s+/, '').replace(/=.*$/, '').trim();
+    const mm = cleaned.match(/^([A-Za-z_]\w*)\s*:\s*(.+)$/);
+    if (mm) return { name: mm[1], type: mm[2].trim() };
+    return { name: cleaned.replace(/[^\w].*$/, '') || cleaned, type: null };
+  });
+}
+
+// ── Kotlin adapter (JVM: fun name(p: Type): Ret, @Test, *Exception) ──────────
+export function extractFactsKotlin(source, file = 'input.kt') {
+  let m; const functions = []; const tests = []; const seen = new Set();
+  const testMethods = new Set(); const ta = /@Test\b[\s\S]{0,120}?\bfun\s+(?:`([^`]+)`|(\w+))\s*\(/g;
+  while ((m = ta.exec(source))) testMethods.add(m[1] || m[2]);
+  const fnRe = /\bfun\s+(?:<[^>]*>\s*)?(?:[A-Za-z_][\w.]*\.)?(?:`([^`]+)`|([A-Za-z_]\w*))\s*\(([^)]*)\)\s*(?::\s*([^{=\n]+))?/g;
+  while ((m = fnRe.exec(source))) {
+    const name = m[1] || m[2];
+    if (testMethods.has(name)) { if (!tests.some((t) => t.name === name)) tests.push({ name, file, line: lineOf(source, m.index) }); continue; }
+    if (seen.has(name)) continue; seen.add(name);
+    functions.push({ name, file, line: lineOf(source, m.index), parameters: parseNameColonTypeParams(m[3] || ''), returnType: m[4] ? m[4].trim() : null, evidence: [{ kind: 'fun', file, line: lineOf(source, m.index) }] });
+  }
+  const errors = []; const addErr = addErrOf(errors, new Set(), { _src: source, _file: file });
+  let mm; const ce = /class\s+(\w*(?:Exception|Error))\b/g; while ((mm = ce.exec(source))) addErr(mm[1], mm.index);
+  const th = /throw\s+(\w+)\s*\(/g; while ((mm = th.exec(source))) addErr(mm[1], mm.index); // Kotlin: no `new`
+  return { schemaVersion: IR_SCHEMA_VERSION, sourceLanguage: 'kotlin', sourceRoot: file, functions, tests, errors };
+}
+
+// ── Scala adapter (def name(p: Type): Ret, ScalaTest, *Exception) ─────────────
+export function extractFactsScala(source, file = 'input.scala') {
+  let m; const functions = []; const tests = []; const seen = new Set();
+  const fnRe = /\bdef\s+([A-Za-z_]\w*)\s*(?:\[[^\]]*\])?\s*\(([^)]*)\)\s*(?::\s*([^={\n]+))?/g;
+  while ((m = fnRe.exec(source))) {
+    const name = m[1];
+    if (seen.has(name)) continue; seen.add(name);
+    functions.push({ name, file, line: lineOf(source, m.index), parameters: parseNameColonTypeParams(m[2] || ''), returnType: m[3] ? m[3].trim() : null, evidence: [{ kind: 'def', file, line: lineOf(source, m.index) }] });
+  }
+  // ScalaTest: `test("desc")` (FunSuite) and `"desc" in { }` / `"desc" should`/`must` (WordSpec/FlatSpec).
+  const seenT = new Set(); const addTest = (n, idx) => { const k = String(n).toLowerCase(); if (n && !seenT.has(k)) { seenT.add(k); tests.push({ name: n, file, line: lineOf(source, idx) }); } };
+  const tr = /\btest\s*\(\s*"([^"]+)"/g; while ((m = tr.exec(source))) addTest(m[1], m.index);
+  const inRe = /"([^"]+)"\s+(?:in|should|must)\b/g; while ((m = inRe.exec(source))) addTest(m[1], m.index);
+  const errors = []; const addErr = addErrOf(errors, new Set(), { _src: source, _file: file });
+  let mm; const ce = /class\s+(\w*(?:Exception|Error))\b/g; while ((mm = ce.exec(source))) addErr(mm[1], mm.index);
+  const th = /throw\s+new\s+(\w+)\s*\(/g; while ((mm = th.exec(source))) addErr(mm[1], mm.index);
+  return { schemaVersion: IR_SCHEMA_VERSION, sourceLanguage: 'scala', sourceRoot: file, functions, tests, errors };
+}
+
+// ── Elixir adapter (dynamic: def/defp name(args), ExUnit test, raise/defexception)
+export function extractFactsElixir(source, file = 'input.ex') {
+  let m; const functions = []; const tests = []; const seen = new Set();
+  const seenT = new Set(); const addTest = (n, idx) => { const k = String(n).toLowerCase(); if (n && !seenT.has(k)) { seenT.add(k); tests.push({ name: n, file, line: lineOf(source, idx) }); } };
+  const tr = /\btest\s+"([^"]+)"/g; while ((m = tr.exec(source))) addTest(m[1], m.index); // ExUnit: test "desc" do
+  const fnRe = /^[ \t]*defp?\s+([a-z_]\w*[!?]?)\s*(?:\(([^)]*)\))?/gm;
+  while ((m = fnRe.exec(source))) {
+    const name = m[1];
+    if (seen.has(name)) continue; seen.add(name);
+    // Elixir params are pattern matches (conn, %{id: id}, x \\ default); take the leading binding name.
+    const parameters = splitTopLevel(m[2] || '', ',').map((p) => p.trim()).filter(Boolean)
+      .map((p) => ({ name: p.split(/\\\\/)[0].trim().replace(/^%\{?/, '').replace(/[^\w].*$/, '') || p, type: null }));
+    functions.push({ name, file, line: lineOf(source, m.index), indent: (m[0].match(/^[ \t]*/) || [''])[0].length, parameters, returnType: null, evidence: [{ kind: 'def', file, line: lineOf(source, m.index) }] });
+  }
+  const errors = []; const seenErr = new Set(); const addErr = (n, idx) => { if (n && !seenErr.has(n)) { seenErr.add(n); errors.push({ name: n, file, line: lineOf(source, idx) }); } };
+  const modErr = /defmodule\s+([\w.]*(?:Error|Exception))\b/g; while ((m = modErr.exec(source))) addErr(m[1].split('.').pop(), m.index);
+  const raiseRe = /raise\s+([A-Z][\w.]*)/g; while ((m = raiseRe.exec(source))) addErr(m[1].split('.').pop(), m.index);
+  return { schemaVersion: IR_SCHEMA_VERSION, sourceLanguage: 'elixir', sourceRoot: file, functions, tests, errors };
+}
+
 const ADAPTERS = {
   typescript: extractFactsTypeScript, ts: extractFactsTypeScript,
   javascript: extractFactsTypeScript, js: extractFactsTypeScript,
@@ -405,13 +473,17 @@ const ADAPTERS = {
   cpp: extractFactsCpp, 'c++': extractFactsCpp, c: extractFactsCpp, cc: extractFactsCpp,
   php: extractFactsPhp,
   ruby: extractFactsRuby, rb: extractFactsRuby,
+  kotlin: extractFactsKotlin, kt: extractFactsKotlin, kts: extractFactsKotlin,
+  scala: extractFactsScala, sc: extractFactsScala,
+  elixir: extractFactsElixir, ex: extractFactsElixir, exs: extractFactsElixir,
 };
-export const SUPPORTED_LANGUAGES = ['typescript', 'javascript', 'python', 'java', 'csharp', 'go', 'rust', 'cpp', 'php', 'ruby', 'perl'];
-const DYNAMIC_LANGUAGES = new Set(['perl', 'javascript', 'python', 'ruby', 'php']);
+export const SUPPORTED_LANGUAGES = ['typescript', 'javascript', 'python', 'java', 'csharp', 'go', 'rust', 'cpp', 'php', 'ruby', 'perl', 'kotlin', 'scala', 'elixir'];
+const DYNAMIC_LANGUAGES = new Set(['perl', 'javascript', 'python', 'ruby', 'php', 'elixir']);
 
 const LANG_DISPLAY = {
   typescript: 'TypeScript', javascript: 'JavaScript', python: 'Python', java: 'Java',
   csharp: 'C#', go: 'Go', rust: 'Rust', cpp: 'C++', php: 'PHP', ruby: 'Ruby', perl: 'Perl',
+  kotlin: 'Kotlin', scala: 'Scala', elixir: 'Elixir',
 };
 
 // Unwrap Result<T, E> / Promise<T> / T -> { output, error }
@@ -558,6 +630,9 @@ export function languageForFile(file) {
   if (/\.(cpp|cc|cxx|hpp|hh|c|h)$/i.test(file)) return 'cpp';
   if (/\.php$/i.test(file)) return 'php';
   if (/\.rb$/i.test(file)) return 'ruby';
+  if (/\.kts?$/i.test(file)) return 'kotlin';
+  if (/\.(scala|sc)$/i.test(file)) return 'scala';
+  if (/\.exs?$/i.test(file)) return 'elixir';
   if (/\.(mjs|cjs|jsx?)$/i.test(file)) return 'javascript';
   return 'typescript';
 }
@@ -577,7 +652,7 @@ function isPublicFn(fn, language) {
   // Common private-helper naming conventions, across languages.
   if (/(?:Internal|Impl|_impl|_helper|_test|Helper)$/.test(name)) return false;
   if (language === 'go' || language === 'golang') return /^[A-Z]/.test(name) && name !== 'Test';
-  if (language === 'python' || language === 'ruby') return !name.startsWith('_') && (fn.indent == null || fn.indent <= 4);
+  if (language === 'python' || language === 'ruby' || language === 'elixir') return !name.startsWith('_') && (fn.indent == null || fn.indent <= 4);
   return !name.startsWith('_') && name !== 'init' && name !== 'constructor';
 }
 
@@ -643,6 +718,7 @@ export function liftRepo(files, { language } = {}) {
 const LANG_EXT = {
   typescript: 'ts', javascript: 'js', python: 'py', java: 'java', csharp: 'cs',
   go: 'go', rust: 'rs', cpp: 'cpp', php: 'php', ruby: 'rb', perl: 'pl',
+  kotlin: 'kt', scala: 'scala', elixir: 'ex',
 };
 
 /**