@skillstech/thunderlang 0.1.6

package/src/twelve-factor.mjs

@@ -0,0 +1,173 @@
+// 12-Factor Agents conformance lens (twelve-factor-v1). Deterministic, browser-safe.
+//
+// Scores an intent against the 13 principles from humanlayer/12-factor-agents
+// (https://github.com/humanlayer/12-factor-agents). Their thesis , "production agents are
+// mostly deterministic code with LLM steps sprinkled in" , is ThunderLang's thesis, so most
+// factors map to structure IL already models (decisions, lifecycles, typed I/O, approvals,
+// errors/handlers, events, a pure runtime). This turns "12-factor compliant" into a
+// human-owned, verifiable claim instead of a marketing checkbox.
+//
+// Verdicts: 'satisfied' | 'partial' | 'absent'. Score = (satisfied + 0.5*partial) / 13.
+// Each factor cites the IL signal it inspects, the evidence found, and a concrete fix. The
+// finding ids (IL-12F-01..13) are in the canonical rule catalog for `intent explain`.
+
+export const TWELVE_FACTOR_SCHEMA = 'twelve-factor-v1';
+
+const VERDICTS = ['satisfied', 'partial', 'absent'];
+const WEIGHT = { satisfied: 1, partial: 0.5, absent: 0 };
+
+const len = (x) => (Array.isArray(x) ? x.length : 0);
+const typedFields = (fields) => (fields || []).filter((f) => f.type && f.type !== 'Unknown');
+
+// Each factor: id, number, name, and a check(ast) -> { verdict, evidence, fix }.
+const FACTORS = [
+  {
+    id: 'IL-12F-01', num: 1, name: 'Natural language to tool calls',
+    check(ast) {
+      const ops = len(ast.decisions) + len(ast.commands);
+      if (ops) return { verdict: 'satisfied', evidence: `${ops} structured operation(s): ${[...ast.decisions.map((d) => d.name), ...ast.commands.map((c) => c.name)].filter(Boolean).join(', ')}` };
+      return { verdict: 'absent', evidence: 'no decisions or commands', fix: 'Model the tool dispatch as a `decision` (rules -> result) or a `command`, so intent becomes a structured, whitelisted call.' };
+    },
+  },
+  {
+    id: 'IL-12F-02', num: 2, name: 'Own your prompts',
+    check(ast) {
+      const g = len(ast.guarantees);
+      if (g) return { verdict: 'satisfied', evidence: `behavior is an owned, specified contract (${g} guarantee(s))` };
+      if (ast.goal) return { verdict: 'partial', evidence: 'a goal is stated but no guarantees pin the behavior', fix: 'Add `guarantee` statements so the behavior is owned + testable, not a black box.' };
+      return { verdict: 'absent', evidence: 'no goal or guarantees', fix: 'Author the intent explicitly (goal + guarantees) rather than delegating behavior to a framework.' };
+    },
+  },
+  {
+    id: 'IL-12F-03', num: 3, name: 'Own your context window',
+    check(ast) {
+      const scoped = len(ast.scope?.include) + len(ast.scope?.exclude);
+      if (scoped) return { verdict: 'satisfied', evidence: `context boundary declared (scope: ${len(ast.scope.include)} include / ${len(ast.scope.exclude)} exclude)` };
+      if (len(ast.requires)) return { verdict: 'partial', evidence: 'dependencies declared but no explicit scope boundary', fix: 'Declare `scope include/exclude` so the context window is curated, not unbounded.' };
+      return { verdict: 'absent', evidence: 'no scope declared', fix: 'Add a `scope` block to bound what belongs in context (IntentLens/Focus narrows it further).' };
+    },
+  },
+  {
+    id: 'IL-12F-04', num: 4, name: 'Tools are structured outputs',
+    check(ast) {
+      const inT = typedFields(ast.inputs).length, outT = typedFields(ast.outputs).length;
+      const discriminated = (ast.decisions || []).some((d) => (d.rules || []).some((r) => r.result));
+      if ((inT || outT) && (discriminated || len(ast.outputs))) return { verdict: 'satisfied', evidence: `typed I/O (${inT} in / ${outT} out)${discriminated ? ' + discriminated decision results' : ''}` };
+      if (len(ast.inputs) || len(ast.outputs)) return { verdict: 'partial', evidence: 'inputs/outputs present but under-typed or no discriminated result', fix: 'Type the inputs/outputs (semantic types) and give decision rules explicit `result`s so outputs are a structured, parseable contract (export via JSON Schema/OpenAPI).' };
+      return { verdict: 'absent', evidence: 'no typed inputs/outputs', fix: 'Declare typed `input`/`output` fields; tools are structured outputs, not prose.' };
+    },
+  },
+  {
+    id: 'IL-12F-05', num: 5, name: 'Unify execution and business state',
+    check(ast) {
+      if (len(ast.lifecycles)) return { verdict: 'satisfied', evidence: `single state model (${ast.lifecycles.map((l) => l.name).join(', ')})` };
+      if (len(ast.decisions) || len(ast.commands)) return { verdict: 'partial', evidence: 'operations exist but no lifecycle unifies their state', fix: 'Model a `lifecycle` so execution state is inferable from one thread instead of tracked in parallel.' };
+      return { verdict: 'absent', evidence: 'no lifecycle / state model', fix: 'Add a `lifecycle` (states + transitions) so execution and business state live in one serializable model.' };
+    },
+  },
+  {
+    id: 'IL-12F-06', num: 6, name: 'Launch / pause / resume',
+    check(ast) {
+      const lc = (ast.lifecycles || [])[0];
+      if (lc && len(lc.states) && len(lc.terminals) && len(lc.states) > len(lc.terminals)) return { verdict: 'satisfied', evidence: `resumable lifecycle: ${len(lc.states)} states, ${len(lc.terminals)} terminal , non-terminal (pausable) states exist` };
+      if (lc) return { verdict: 'partial', evidence: 'lifecycle present but no clear pausable/terminal structure', fix: 'Give the lifecycle explicit non-terminal (waiting) states + terminals so it can pause and resume.' };
+      return { verdict: 'absent', evidence: 'no lifecycle to pause/resume', fix: 'Model a `lifecycle` with waiting states so the agent can pause on long ops and resume from a saved thread.' };
+    },
+  },
+  {
+    id: 'IL-12F-07', num: 7, name: 'Contact humans with tool calls',
+    check(ast) {
+      if (len(ast.approvals) || ast.approval?.reviewed != null) return { verdict: 'satisfied', evidence: `human gate declared (${len(ast.approvals) ? ast.approvals.join(', ') : 'approval block'})` };
+      if (ast.owner) return { verdict: 'partial', evidence: `an owner is named (${ast.owner}) but no structured approval/human-input step`, fix: 'Declare an `approval required from <role>` gate so contacting a human is a structured, resumable step.' };
+      return { verdict: 'absent', evidence: 'no human-in-the-loop gate', fix: 'Add an `approval required from <role>` (or a human-input decision result) so high-stakes steps pause for a human.' };
+    },
+  },
+  {
+    id: 'IL-12F-08', num: 8, name: 'Own your control flow',
+    check(ast) {
+      const decs = ast.decisions || [];
+      if (decs.length && decs.every((d) => d.default != null)) return { verdict: 'satisfied', evidence: `${decs.length} decision(s), all with an explicit default (total, deterministic control flow)` };
+      if (decs.length) return { verdict: 'partial', evidence: `${decs.length} decision(s) but some have no default (undefined when no rule matches)`, fix: 'Give every `decision` a `default` so control flow is total , no undefined branch between selection and execution.' };
+      return { verdict: 'absent', evidence: 'no decision-based control flow', fix: 'Model branching as a `decision` (FIRST-hit rules + default) so you own the loop, not a framework.' };
+    },
+  },
+  {
+    id: 'IL-12F-09', num: 9, name: 'Compact errors into context',
+    check(ast) {
+      const e = len(ast.errors), h = len(ast.handlers);
+      if (e && h) return { verdict: 'satisfied', evidence: `${e} named error(s) + ${h} handler(s) (compensate/notify)` };
+      if (e || h) return { verdict: 'partial', evidence: e ? 'errors named but no handlers' : 'handlers exist but no named errors', fix: 'Declare named `error`s AND `handler`s (compensate/notify) so failures are structured + recoverable, with bounded retries.' };
+      return { verdict: 'absent', evidence: 'no error model', fix: 'Name the failure modes as `error`s and add `handler`s so errors compact into a recoverable, bounded-retry path.' };
+    },
+  },
+  {
+    id: 'IL-12F-10', num: 10, name: 'Small, focused agents',
+    check(ast) {
+      const steps = len(ast.decisions) + len(ast.commands) + len(ast.handlers) + (ast.lifecycles || []).reduce((n, l) => n + len(l.states), 0);
+      if (steps === 0) return { verdict: 'partial', evidence: 'no executable steps to size', fix: 'Once operations exist, keep them within ~10 steps (20 max) so the agent stays focused.' };
+      if (steps <= 10) return { verdict: 'satisfied', evidence: `${steps} step(s) (target <= 10)` };
+      if (steps <= 20) return { verdict: 'partial', evidence: `${steps} step(s) (over the ~10 target, under the 20 cap)`, fix: 'Split into smaller missions; agents lose focus as step count grows.' };
+      return { verdict: 'absent', evidence: `${steps} step(s) (exceeds the ~20 hard cap)`, fix: 'Decompose this mission , at >20 steps the model loses coherence. One responsibility per mission.' };
+    },
+  },
+  {
+    id: 'IL-12F-11', num: 11, name: 'Trigger from anywhere',
+    check(ast) {
+      if (len(ast.events)) return { verdict: 'satisfied', evidence: `${len(ast.events)} event trigger(s) declared` };
+      if (len(ast.commands) || len(ast.apis)) return { verdict: 'partial', evidence: 'commands/APIs exist but no declared event triggers', fix: 'Declare `event`s so the mission can be triggered by webhooks/crons/other agents, not one entry point.' };
+      return { verdict: 'absent', evidence: 'no trigger surface declared', fix: 'Declare the `event`s/triggers that launch this mission (outer-loop + multi-channel).' };
+    },
+  },
+  {
+    id: 'IL-12F-12', num: 12, name: 'Stateless reducer',
+    check(ast) {
+      if (len(ast.decisions) || len(ast.lifecycles)) return { verdict: 'satisfied', evidence: 'behavior is a pure, replayable function (decisions/lifecycle run on IL’s deterministic runtime)' };
+      if (len(ast.guarantees)) return { verdict: 'partial', evidence: 'specified but nothing executable/pure to replay', fix: 'Express the logic as `decision`/`lifecycle` so it is a pure f(state)->next you can replay + test.' };
+      return { verdict: 'absent', evidence: 'nothing executable', fix: 'Model the step as a deterministic `decision`/`lifecycle` (pure reducer over the event thread).' };
+    },
+  },
+  {
+    id: 'IL-12F-13', num: 13, name: 'Pre-fetch context (appendix)',
+    check(ast) {
+      if (len(ast.inputs)) return { verdict: 'satisfied', evidence: `${len(ast.inputs)} input(s) declared up front` };
+      if (len(ast.decisions)) return { verdict: 'partial', evidence: 'decisions exist but no declared inputs to pre-fetch', fix: 'Declare the `input`s the decision needs so known data is fetched deterministically up front, not via an extra model turn.' };
+      return { verdict: 'absent', evidence: 'no declared inputs', fix: 'Declare `input`s so predictable data is present up front (pre-fetch), saving a round trip.' };
+    },
+  },
+];
+
+/**
+ * Score an intent AST against the 13 factors. Deterministic; returns a stable report.
+ * Pass a parsed AST (from parseIntent). Accepts a mission or any profile intent.
+ */
+export function twelveFactorReport(ast) {
+  const a = ast || {};
+  const factors = FACTORS.map((f) => {
+    const r = f.check(a) || { verdict: 'absent', evidence: '' };
+    const verdict = VERDICTS.includes(r.verdict) ? r.verdict : 'absent';
+    return { id: f.id, factor: f.num, name: f.name, verdict, evidence: r.evidence || '', ...(r.fix ? { fix: r.fix } : {}) };
+  });
+  const raw = factors.reduce((s, f) => s + WEIGHT[f.verdict], 0);
+  const score = Math.round((raw / FACTORS.length) * 100);
+  const counts = { satisfied: 0, partial: 0, absent: 0 };
+  for (const f of factors) counts[f.verdict]++;
+  // Advisory diagnostics for anything not fully satisfied (surface in scan / explain).
+  const diagnostics = factors
+    .filter((f) => f.verdict !== 'satisfied')
+    .map((f) => ({ level: f.verdict === 'absent' ? 'warning' : 'info', code: f.id, message: `Factor ${f.factor} (${f.name}): ${f.evidence}.${f.fix ? ' ' + f.fix : ''}` }));
+  return {
+    schemaVersion: TWELVE_FACTOR_SCHEMA,
+    subject: a.mission || a.title || null,
+    score,                       // 0..100
+    grade: score >= 85 ? 'strong' : score >= 60 ? 'partial' : 'weak',
+    counts,
+    factors,
+    diagnostics,
+  };
+}
+
+// Compact summary for the proof envelope / compileSource (no per-factor prose).
+export function twelveFactorSummary(ast) {
+  const r = twelveFactorReport(ast);
+  return { schemaVersion: r.schemaVersion, score: r.score, grade: r.grade, counts: r.counts };
+}

package/src/verify-diff.mjs

@@ -0,0 +1,105 @@
+// Verify a code change against its intent (intent-verify-diff-v1) , the keystone of the AI loop.
+// A human (or an agent) states intent; an AI proposes a code change; THIS proves, deterministically
+// and with no AI, which of the intent's guarantees and never-rules the change upholds or breaks,
+// and returns a gate verdict (PASS / BLOCK). It is honest: it does not claim to prove correctness
+// (that needs tests + humans), but it catches the mechanical violations AI diffs actually ship ,
+// a secret written to a log, a declared input dropped from a signature, a guarantee whose evidence
+// the change removed.
+//
+//   verifyDiff(intentText, { before?, after, language }) -> { verdict, ok, findings, blocking }
+//
+// The two signals that make this a DIFF check, not just a snapshot:
+//   1. Regressions , a claim that held on `before` but is broken on `after` (the change's fault).
+//   2. Guardrail hits , lines the change ADDED that match a never-rule's sensitive term reaching a
+//      sink (log/print/response/...). This is the active check that catches AI-introduced leaks.
+
+import { parseIntent } from './parse.mjs';
+import { checkDrift } from './drift.mjs';
+
+export const VERIFY_DIFF_SCHEMA = 'intent-verify-diff-v1';
+
+// A value reaching an output sink , where a leak would happen.
+const SINK_RE = /\b(log|logger|logging|console|print|println|printf|echo|write|send|res|response|reply|render|fmt\.Print\w*|System\.out|puts|p\b)\b|\bconsole\.\w+|\bres\.\w+|\bresponse\.\w+/i;
+// Sensitive nouns a never-rule might protect. If the rule names one and an added line sends it to
+// a sink, that is a probable violation.
+const SENSITIVE_TERMS = ['token', 'secret', 'password', 'passwd', 'credential', 'ssn', 'pii', 'card', 'cvv', 'apikey', 'api_key', 'privatekey', 'private_key', 'session', 'jwt', 'email', 'address', 'phone', 'dob', 'birthdate'];
+
+function sensitiveTermsOf(statement) {
+  const s = String(statement).toLowerCase();
+  return SENSITIVE_TERMS.filter((t) => new RegExp(`\\b${t.replace('_', '[_ ]?')}`, 'i').test(s));
+}
+
+// Split a code line into identifier words, breaking camelCase and snake_case, so a term like
+// "token" matches `paymentToken`, `payment_token`, and `paymenttoken` , the common ways an AI
+// diff names a secret variable.
+function identifierWords(text) {
+  return String(text)
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/[^A-Za-z0-9]+/g, ' ')
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(Boolean);
+}
+const lineHitsTerm = (text, terms) => {
+  const words = identifierWords(text);
+  return terms.some((term) => words.some((w) => w === term || w.endsWith(term)));
+};
+
+// Lines present in `after` but not in `before` (exact-text set diff , enough to spot an added
+// sink line). When there is no `before`, every non-trivial line is "added" (verifying fresh code).
+function addedLines(before, after) {
+  const afterLines = String(after ?? '').split(/\r?\n/);
+  if (before == null) return afterLines.map((text, i) => ({ line: i + 1, text })).filter((l) => l.text.trim());
+  const beforeSet = new Set(String(before).split(/\r?\n/).map((l) => l.trim()));
+  return afterLines.map((text, i) => ({ line: i + 1, text })).filter((l) => l.text.trim() && !beforeSet.has(l.text.trim()));
+}
+
+/**
+ * Verify a proposed code change against its intent. Returns a gate verdict + findings.
+ * @param {string} intentText the .intent source (the contract)
+ * @param {{ before?: string|null, after: string, language?: string }} change
+ */
+export function verifyDiff(intentText, { before = null, after, language = 'typescript' } = {}) {
+  const ast = parseIntent(intentText);
+  const findings = [];
+
+  // 1. Contract drift on the AFTER code (guarantee/never/input support vs the intent).
+  const driftAfter = checkDrift(intentText, String(after ?? ''), { language });
+  // 2. What held BEFORE, so we can tell a pre-existing gap from a regression the change introduced.
+  const beforeKeys = before != null
+    ? new Set(checkDrift(intentText, before, { language }).findings.map((f) => `${f.code}|${f.message}`))
+    : null;
+  for (const f of driftAfter.findings) {
+    if (f.code === 'INTENT_DRIFT_NOT_APPROVED' || f.code === 'INTENT_DRIFT_NEW_BEHAVIOR') { findings.push({ ...f, regression: false }); continue; }
+    const regression = beforeKeys ? !beforeKeys.has(`${f.code}|${f.message}`) : false;
+    findings.push({ ...f, regression });
+  }
+
+  // 3. Guardrail scan: added lines that push a never-rule's sensitive term into a sink.
+  const added = addedLines(before, after);
+  for (const n of ast.neverRules || []) {
+    const terms = sensitiveTermsOf(n.statement);
+    if (!terms.length) continue;
+    const wantsSink = /\b(log|logs|logged|logging|expose|exposed|leak|print|return|respond|response|send|output)\b/i.test(n.statement);
+    for (const { line, text } of added) {
+      const hitsTerm = lineHitsTerm(text, terms);
+      if (hitsTerm && (SINK_RE.test(text) || wantsSink && /=|\(|:/.test(text))) {
+        findings.push({
+          level: 'error', code: 'INTENT_VERIFY_NEVER_VIOLATED', regression: true, line,
+          message: `Added code may violate never-rule "${n.statement}": ${text.trim().slice(0, 90)}`,
+        });
+      }
+    }
+  }
+
+  // Verdict: block on any guardrail violation, or any regression of a contract claim.
+  const blocking = findings.filter((f) => f.code === 'INTENT_VERIFY_NEVER_VIOLATED' || (f.regression && f.level === 'warning'));
+  return {
+    schema: VERIFY_DIFF_SCHEMA,
+    ok: blocking.length === 0,
+    verdict: blocking.length ? 'BLOCK' : 'PASS',
+    findings,
+    blocking: blocking.length,
+    summary: { verdict: blocking.length ? 'BLOCK' : 'PASS', findings: findings.length, blocking: blocking.length, regressions: findings.filter((f) => f.regression).length },
+  };
+}

package/src/xml.mjs

@@ -0,0 +1,87 @@
+// A tiny, dependency-free, deterministic XML parser , just enough to read the DMN/BPMN we
+// emit and reasonably well-formed real-world files. Not a validating parser: it handles
+// elements, attributes (single/double quoted), text, self-closing tags, comments, the XML
+// declaration, and entity decoding. Namespaces are kept in the raw name; match by localName.
+
+const ENTITIES = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" };
+export const decodeEntities = (s) =>
+  String(s).replace(/&(amp|lt|gt|quot|apos|#\d+|#x[0-9a-fA-F]+);/g, (_, e) =>
+    e[0] === '#' ? String.fromCodePoint(e[1] === 'x' ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10)) : ENTITIES[e]);
+
+// Strip the namespace prefix: "dmn:decision" -> "decision".
+export const localName = (name) => String(name).split(':').pop();
+
+function parseAttrs(str) {
+  const attrs = {};
+  const re = /([^\s=/]+)\s*=\s*"([^"]*)"|([^\s=/]+)\s*=\s*'([^']*)'/g;
+  let m;
+  while ((m = re.exec(str))) {
+    if (m[1] !== undefined) attrs[m[1]] = decodeEntities(m[2]);
+    else attrs[m[3]] = decodeEntities(m[4]);
+  }
+  return attrs;
+}
+
+/** Parse an XML string into a tree of { name, attrs, children, text }. Root is a synthetic node. */
+export function parseXml(input) {
+  const s = String(input ?? '');
+  const root = { name: '#root', attrs: {}, children: [], text: '' };
+  const stack = [root];
+  let i = 0;
+  while (i < s.length) {
+    if (s[i] === '<') {
+      if (s.startsWith('<!--', i)) { const e = s.indexOf('-->', i); i = e < 0 ? s.length : e + 3; continue; }
+      if (s.startsWith('<?', i)) { const e = s.indexOf('?>', i); i = e < 0 ? s.length : e + 2; continue; }
+      if (s.startsWith('<![CDATA[', i)) {
+        const e = s.indexOf(']]>', i);
+        stack[stack.length - 1].text += s.slice(i + 9, e < 0 ? s.length : e);
+        i = e < 0 ? s.length : e + 3; continue;
+      }
+      if (s.startsWith('<!', i)) { const e = s.indexOf('>', i); i = e < 0 ? s.length : e + 1; continue; }
+      const e = s.indexOf('>', i);
+      if (e < 0) break;
+      if (s[i + 1] === '/') { if (stack.length > 1) stack.pop(); i = e + 1; continue; }
+      let raw = s.slice(i + 1, e).trim();
+      const selfClose = raw.endsWith('/');
+      if (selfClose) raw = raw.slice(0, -1).trim();
+      const sp = raw.search(/\s/);
+      const name = sp < 0 ? raw : raw.slice(0, sp);
+      const node = { name, attrs: parseAttrs(sp < 0 ? '' : raw.slice(sp)), children: [], text: '' };
+      stack[stack.length - 1].children.push(node);
+      if (!selfClose) stack.push(node);
+      i = e + 1;
+    } else {
+      const e = s.indexOf('<', i);
+      const end = e < 0 ? s.length : e;
+      const t = decodeEntities(s.slice(i, end)).trim();
+      if (t) stack[stack.length - 1].text += t;
+      i = end;
+    }
+  }
+  return root;
+}
+
+// ── Tree walk helpers (all match by localName, ignoring namespace prefixes) ──
+
+/** All descendant elements with the given localName (depth-first, document order). */
+export function findAll(node, lname) {
+  const out = [];
+  const walk = (n) => {
+    for (const c of n.children || []) {
+      if (localName(c.name) === lname) out.push(c);
+      walk(c);
+    }
+  };
+  walk(node);
+  return out;
+}
+
+/** First descendant with the given localName, or null. */
+export function find(node, lname) {
+  return findAll(node, lname)[0] || null;
+}
+
+/** Direct children with the given localName. */
+export function childrenNamed(node, lname) {
+  return (node.children || []).filter((c) => localName(c.name) === lname);
+}

package/syntaxes/intent.tmLanguage.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  "name": "ThunderLang",
+  "scopeName": "source.intent",
+  "fileTypes": ["intent"],
+  "patterns": [
+    { "include": "#comment" },
+    { "include": "#string" },
+    { "include": "#block-keyword" },
+    { "include": "#field-type" },
+    { "include": "#operator" },
+    { "include": "#number" },
+    { "include": "#type" }
+  ],
+  "repository": {
+    "comment": {
+      "match": "#.*$",
+      "name": "comment.line.number-sign.intent"
+    },
+    "string": {
+      "name": "string.quoted.double.intent",
+      "begin": "\"",
+      "end": "\"",
+      "patterns": [{ "match": "\\\\.", "name": "constant.character.escape.intent" }]
+    },
+    "block-keyword": {
+      "comment": "A line-leading keyword introduces a block or a field (indentation-structured).",
+      "match": "^\\s*(mission|use|goal|why|because|requires|inputs?|outputs?|guarantees?|never|constraints?|assumptions?|risks|target|style|verify|errors|examples|service|api|event|database|architecture|selection|title|for|persona|customer|problem|evidence|opportunity|outcome_contract|outcome|metric|scope|include|exclude|non_goal|owner|unknown|question|assumption|experience|pattern|decision|rule|default|when|return|command|on|compensate|notify|preserve|lifecycle|state|transition|from|to|terminal|always|eventually|until|conflict|options|between|resolve_by|resolution|choose|approval|capability|interface|provides|slo|release|result|learning|component|artifact|test|case|scenario|given|expect|events|data|waiver|note|implements|covers|variant|token|classification|purpose|retention|basis|baseline|window|direction|includes|measures|value|kind|ref|version|status|date|reason|approved_by|by|at|decision|expires|before|idempotency_key|timeout|retry|backoff|confidence|source|recover|follows|actor|accessible|responsive|asked_of|resolve|validate)\\b",
+      "captures": { "1": { "name": "keyword.control.intent" } }
+    },
+    "field-type": {
+      "comment": "A typed field: name: Type (optionally List<Type>).",
+      "match": "\\b([a-z][A-Za-z0-9_.]*)\\s*(:)\\s*([A-Z][A-Za-z0-9]*(?:<[^>]+>)?)",
+      "captures": {
+        "1": { "name": "variable.other.member.intent" },
+        "2": { "name": "punctuation.separator.intent" },
+        "3": { "name": "entity.name.type.intent" }
+      }
+    },
+    "operator": {
+      "comment": "Expression operators used in decision conditions (when ...).",
+      "match": "(>=|<=|==|!=|>|<|=|\\+|\\-|\\*|/|%)|\\b(and|or|not|in)\\b",
+      "name": "keyword.operator.intent"
+    },
+    "number": {
+      "match": "\\b\\d+(?:\\.\\d+)?%?\\b",
+      "name": "constant.numeric.intent"
+    },
+    "type": {
+      "comment": "PascalCase identifiers are entities/types in ThunderLang.",
+      "match": "\\b([A-Z][A-Za-z0-9]*)(?:<[^>]+>)?\\b",
+      "name": "entity.name.type.intent"
+    }
+  }
+}