@skillstech/thunderlang 0.3.0 → 0.4.2

package/dist/index.cjs

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

package/package.json

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