@skillstech/thunderlang 0.1.6

package/src/focus.mjs

@@ -0,0 +1,151 @@
+// Intent Lens , Intent Scope + Focus Graph (intent-focus-v1). A Focus Graph is a versioned
+// subgraph of the Intent Atlas around a selected scope (a mission, a set of nodes, a change),
+// with each included node tagged by WHY it is in focus. This is the shared foundation the
+// vision's Intent Lens is built on: Studio renders it, OpenThunder verifies its scope,
+// RepoMastery/SkillsTech Talk teach it, but the deterministic scope + subgraph live here
+// because ThunderLang owns the Intent IR/Atlas. Pure and browser-safe (no Node, no AI).
+//
+// "Intent Atlas shows the complete system. Intent Lens helps you understand one part of it."
+
+export const FOCUS_SCHEMA = 'intent-focus-v1';
+
+export const SCOPE_TYPES = [
+  'branch', 'pull-request', 'commit-range', 'feature', 'capability', 'requirement',
+  'flow', 'service', 'module', 'release', 'incident', 'finding', 'mission', 'custom',
+];
+
+// Why a node is in the focused graph (the vision's inclusion-reason set).
+export const FOCUS_REASONS = [
+  'selected', 'governing', 'dependency', 'dependent', 'implementation',
+  'verification', 'risk', 'contextual',
+];
+
+const RISK_TYPES = new Set(['Risk', 'Finding', 'Conflict', 'Threat']);
+const OPEN_TYPES = new Set(['Unknown', 'Question', 'Assumption']);
+
+// A small deterministic, browser-safe fingerprint (djb2) , for freshness comparison, not security.
+function fingerprint(parts) {
+  let h = 5381;
+  const s = parts.join('
');
+  for (let i = 0; i < s.length; i += 1) h = ((h * 33) ^ s.charCodeAt(i)) >>> 0;
+  return `fp_${h.toString(16)}`;
+}
+
+/** Build a typed Intent Scope. `createdAt` is supplied by the caller (deterministic/testable). */
+export function makeScope({ type = 'custom', title = null, seeds = [], projectId = null, createdBy = null, createdAt = null, ...rest } = {}) {
+  if (!SCOPE_TYPES.includes(type)) throw new Error(`intent focus: unknown scope type "${type}"`);
+  return {
+    schema: FOCUS_SCHEMA,
+    scopeId: `scope.${type}.${fingerprint([type, ...seeds].map(String))}`,
+    projectId, type, title: title || (seeds[0] || type),
+    selectedNodeIds: [...seeds],
+    createdBy, createdAt,
+    provenance: 'compiler-derived',
+    ...rest,
+  };
+}
+
+// Classify why `node`, reached from `viaEdge` (or a seed), is included.
+function reasonFor(node, viaEdge, seedSet) {
+  if (seedSet.has(node.id)) return 'selected';
+  if (RISK_TYPES.has(node.type)) return 'risk';
+  if (node.type === 'VerificationRule' || node.type === 'Verification') return 'verification';
+  if (!viaEdge) return 'contextual';
+  switch (viaEdge.type) {
+    case 'verified_by': return 'verification';
+    case 'requires': case 'constrained_by': case 'governs': case 'supported_by': return 'governing';
+    case 'implemented_by': case 'represented_by': return 'implementation';
+    case 'depends_on': return viaEdge.dir === 'out' ? 'dependency' : 'dependent';
+    default: return 'contextual';
+  }
+}
+
+/**
+ * Build a Focus Graph: the subgraph of `atlas` reachable from `seeds` within `depth` hops,
+ * every node tagged with its focusReason and the hop distance. Deterministic.
+ * @param {{nodes:Array, relationships:Array}} atlas
+ * @param {{seeds:string[], depth?:number, scope?:object}} opts
+ */
+export function buildFocusGraph(atlas, { seeds = [], depth = 2, scope = null } = {}) {
+  const nodesById = new Map((atlas?.nodes || []).map((n) => [n.id, n]));
+  const rels = atlas?.relationships || [];
+  const seedSet = new Set(seeds.filter((s) => nodesById.has(s)));
+  const included = new Map(); // id -> { node, reason, depth }
+  for (const s of seedSet) included.set(s, { node: nodesById.get(s), reason: 'selected', depth: 0 });
+
+  // Adjacency index (built once) so BFS is O(nodes + edges), not O(nodes * edges). Each entry
+  // records the neighbor id + the edge (with direction) that reaches it.
+  const adj = new Map();
+  const link = (from, neighborId, r, dir) => {
+    let list = adj.get(from);
+    if (!list) { list = []; adj.set(from, list); }
+    list.push({ neighborId, via: { type: r.type, from: r.from, to: r.to, dir } });
+  };
+  for (const r of rels) { link(r.from, r.to, r, 'out'); link(r.to, r.from, r, 'in'); }
+
+  let frontier = [...seedSet];
+  for (let d = 1; d <= depth && frontier.length; d += 1) {
+    const next = [];
+    for (const id of frontier) {
+      const edges = adj.get(id);
+      if (!edges) continue;
+      for (const { neighborId, via } of edges) {
+        if (included.has(neighborId)) continue;
+        const node = nodesById.get(neighborId) || { id: neighborId, type: 'Unknown', title: neighborId };
+        included.set(neighborId, { node, reason: reasonFor(node, via, seedSet), depth: d });
+        next.push(neighborId);
+      }
+    }
+    frontier = next;
+  }
+
+  const focusNodes = [...included.values()]
+    .map(({ node, reason, depth: dd }) => ({ id: node.id, type: node.type, title: node.title || node.id, focusReason: reason, depth: dd, confidence: node.confidence || null, provenance: node.provenance || null }))
+    .sort((a, b) => a.depth - b.depth || a.id.localeCompare(b.id));
+  const idSet = new Set(focusNodes.map((n) => n.id));
+  const focusRels = rels.filter((r) => idSet.has(r.from) && idSet.has(r.to));
+
+  const byReason = {};
+  for (const n of focusNodes) byReason[n.focusReason] = (byReason[n.focusReason] || 0) + 1;
+  const byType = {};
+  for (const n of focusNodes) byType[n.type] = (byType[n.type] || 0) + 1;
+
+  return {
+    schema: FOCUS_SCHEMA,
+    scope: scope || makeScope({ type: 'custom', seeds: [...seedSet] }),
+    depth,
+    freshness: fingerprint(focusNodes.map((n) => `${n.id}:${nodesById.get(n.id)?.hash || n.title}`)),
+    overview: { nodes: focusNodes.length, relationships: focusRels.length, byReason, byType },
+    nodes: focusNodes,
+    relationships: focusRels,
+  };
+}
+
+/**
+ * A deterministic Intent Brief for a Focus Graph: what / why / who / involves / risks /
+ * unknowns / confidence. Never invents; every line is derived from focused IR nodes, and the
+ * brief's confidence is the weakest confidence in scope (honesty).
+ */
+export function intentBrief(focus) {
+  const nodes = focus?.nodes || [];
+  const seed = nodes.find((n) => n.focusReason === 'selected' && n.type === 'Mission')
+    || nodes.find((n) => n.type === 'Mission') || nodes[0] || null;
+  const of = (types) => nodes.filter((n) => types.includes(n.type)).map((n) => n.title);
+  const rank = { Confirmed: 5, Observed: 4, Derived: 3, Inferred: 2, Speculative: 1, Conflicted: 0 };
+  const confidences = nodes.map((n) => n.confidence).filter(Boolean);
+  const weakest = confidences.length ? confidences.reduce((a, b) => (rank[b] < rank[a] ? b : a)) : null;
+  return {
+    schema: FOCUS_SCHEMA,
+    scopeId: focus?.scope?.scopeId || null,
+    what: seed ? seed.title : (focus?.scope?.title || null),
+    who: of(['Persona', 'Actor']),
+    involves: focus?.overview?.byType || {},
+    guarantees: of(['Guarantee']),
+    prohibitions: of(['Never', 'ProhibitedBehavior']),
+    risks: nodes.filter((n) => n.focusReason === 'risk').length,
+    verification: nodes.filter((n) => n.focusReason === 'verification').length,
+    unknowns: nodes.filter((n) => OPEN_TYPES.has(n.type)).map((n) => n.title),
+    confidence: weakest,
+    needsReview: nodes.some((n) => ['Inferred', 'Speculative', 'Conflicted'].includes(n.confidence)),
+  };
+}

package/src/format.mjs

@@ -0,0 +1,55 @@
+// A deterministic formatter for .intent source , the gofmt/prettier of ThunderLang. It
+// re-indents each line to its structural depth (two spaces per level), trims trailing
+// whitespace, collapses runs of blank lines to one, and ensures a single trailing newline,
+// while PRESERVING content and comments (only whitespace changes). Idempotent and
+// semantic-preserving: format(format(x)) === format(x), and the re-parsed graph is unchanged.
+
+export const FORMAT_INDENT = '  ';
+
+/**
+ * Format ThunderLang source. Depth is taken from the source's own relative indentation
+ * (the same stack algorithm the parser's indent tree uses), so a file with mixed 2/4-space
+ * or tab indentation is normalized to consistent two-space steps.
+ */
+export function formatSource(source) {
+  const lines = String(source ?? '').replace(/\r\n?/g, '\n').split('\n');
+  const out = [];
+  const stack = [-1]; // indentation widths seen so far; depth = stack.length - 1
+  let blankPending = false;
+  let inString = false; // inside an unterminated multi-line "..." string
+
+  const quoteCount = (s) => (s.match(/(?<!\\)"/g) || []).length;
+
+  for (const line of lines) {
+    // A line CONTINUING a multi-line string is content: preserve it byte-for-byte.
+    if (inString) {
+      if (blankPending) { out.push(''); blankPending = false; }
+      out.push(line.replace(/[\r]+$/, ''));
+      if (quoteCount(line) % 2 === 1) inString = false;
+      continue;
+    }
+
+    const trimmed = line.replace(/\s+$/, '').trimStart();
+    if (trimmed === '') { blankPending = true; continue; }
+
+    const indent = line.length - line.trimStart().length;
+    while (stack.length > 1 && indent <= stack[stack.length - 1]) stack.pop();
+    const depth = stack.length - 1;
+    stack.push(indent);
+
+    if (blankPending && out.length) out.push(''); // collapse any run of blanks to one
+    blankPending = false;
+    out.push(FORMAT_INDENT.repeat(depth) + trimmed);
+    if (quoteCount(trimmed) % 2 === 1) inString = true; // this line opened a string
+  }
+
+  // Exactly one trailing newline; no leading blank line.
+  while (out.length && out[0] === '') out.shift();
+  while (out.length && out[out.length - 1] === '') out.pop();
+  return out.join('\n') + '\n';
+}
+
+/** True if the source is already in canonical form. */
+export function isFormatted(source) {
+  return String(source ?? '').replace(/\r\n?/g, '\n') === formatSource(source);
+}

package/src/governance.mjs

@@ -0,0 +1,100 @@
+// Governance: waivers (founder Gap 5). A waiver is a GOVERNED EXCEPTION to a blocking
+// diagnostic , a named authority signs off, with a reason and (optionally) an expiry and
+// a scope, allowing a normally-blocking condition to ship WITH a full audit trail. This is
+// how intent stays honest under real deadlines: you never silently drop a blocker, you
+// waive it on the record. Deterministic and pure , expiry is evaluated only against a
+// caller-supplied `now` (an ISO date string); with no `now`, expiry is not enforced so the
+// analysis stays reproducible.
+
+export const GOVERNANCE_SCHEMA = 'intent-governance-v1';
+
+// ISO-date compare without Date (keeps the module pure/deterministic). Both are 'YYYY-MM-DD'
+// (or ISO datetime); lexical compare is correct for that format. Returns true if a < b.
+const isoBefore = (a, b) => String(a) < String(b);
+
+/**
+ * Validate a set of waivers and (optionally) evaluate expiry against `now`.
+ * A waiver is well-formed only with a `code`, a `reason`, and an `approvedBy`.
+ * @returns {{level,code,message,why,waiver}[]} governance diagnostics (IL-GOV-*)
+ */
+export function governanceDiagnostics(waivers = [], diagnostics = [], { now = null } = {}) {
+  const out = [];
+  const codesPresent = new Set(diagnostics.map((d) => d.code).filter(Boolean));
+  for (const w of waivers) {
+    if (!w.code) out.push({
+      level: 'error', code: 'IL-GOV-001', role: 'governance',
+      message: `A waiver names no diagnostic code.`,
+      why: 'A waiver must say exactly which diagnostic it excuses; a blanket waiver excuses nothing accountably.',
+      waiver: w.id,
+    });
+    if (!w.reason) out.push({
+      level: 'error', code: 'IL-GOV-002', role: 'governance',
+      message: `Waiver for ${w.code || '(no code)'} has no reason.`,
+      why: 'An exception without a stated reason is not governance, it is silence. Record why shipping is acceptable.',
+      waiver: w.id,
+    });
+    if (!w.approvedBy) out.push({
+      level: 'error', code: 'IL-GOV-003', role: 'governance',
+      message: `Waiver for ${w.code || '(no code)'} names no approver.`,
+      why: 'A waiver is an authority accepting risk; without a named approver there is no accountable owner.',
+      waiver: w.id,
+    });
+    if (w.code && !codesPresent.has(w.code)) out.push({
+      level: 'warning', code: 'IL-GOV-004', role: 'governance',
+      message: `Waiver for ${w.code} does not match any current diagnostic , it may be stale.`,
+      why: 'A dangling waiver hides that the condition it excused is already gone; remove it or it silently pre-approves a future regression.',
+      waiver: w.id,
+    });
+    if (now && w.expires && !isoBefore(now, w.expires)) out.push({
+      level: 'error', code: 'IL-GOV-005', role: 'governance',
+      message: `Waiver for ${w.code} expired on ${w.expires}.`,
+      why: 'An expired waiver no longer excuses anything; the diagnostic it covered is blocking again.',
+      waiver: w.id,
+    });
+  }
+  return out;
+}
+
+/**
+ * Apply waivers to a diagnostic set: each blocking diagnostic that matches a VALID, ACTIVE
+ * waiver is annotated `waived:true` (with the audit record) and no longer counts as blocking.
+ * Non-matching / invalid / expired waivers leave the diagnostic blocking. Deterministic.
+ *
+ * A waiver matches a diagnostic when codes are equal AND (the waiver has no scope, or the
+ * diagnostic's scope/target/mission/waiver field equals the waiver scope).
+ *
+ * @returns {{diagnostics, waived, blockingAfter, report}}
+ */
+export function applyWaivers(diagnostics = [], waivers = [], { now = null } = {}) {
+  const valid = waivers.filter((w) => w.code && w.reason && w.approvedBy
+    && !(now && w.expires && !isoBefore(now, w.expires)));
+
+  const scopeOf = (d) => d.scope || d.target || d.targetPath || d.mission || null;
+  const matches = (w, d) => w.code === d.code && (!w.scope || w.scope === scopeOf(d));
+
+  const waived = [];
+  const applied = diagnostics.map((d) => {
+    const w = valid.find((x) => matches(x, d));
+    if (!w) return d;
+    const record = { ...d, waived: true, waiver: { id: w.id, approvedBy: w.approvedBy, reason: w.reason, expires: w.expires || null } };
+    waived.push(record);
+    return record;
+  });
+
+  const isBlocking = (d) => !d.waived && (d.severity === 'blocker' || (Array.isArray(d.blocks) && d.blocks.length > 0) || d.level === 'error');
+  const blockingAfter = applied.filter(isBlocking);
+
+  return {
+    schema: GOVERNANCE_SCHEMA,
+    diagnostics: applied,
+    waived,
+    blockingAfter,
+    report: {
+      total: diagnostics.length,
+      waived: waived.length,
+      blockingAfter: blockingAfter.length,
+      waivers: waivers.length,
+      activeWaivers: valid.length,
+    },
+  };
+}

package/src/graph-source.mjs

@@ -0,0 +1,292 @@
+// Graph -> source: regenerate editable ThunderLang from an Intent Graph , the inverse of
+// buildIntentGraph. This closes the native round-trip: a tool (SkillsTech Studio, or
+// OpenThunder's discovery) can hold a graph, edit it, and emit `.intent` source that
+// re-parses to an equivalent graph. Deterministic and pure.
+//
+// Round-trip contract: node TYPES + TITLES and the typed RELATIONSHIPS between them are
+// preserved through graph -> source -> graph, and decisions round-trip by EXECUTION. A few
+// compound/derived nodes are best-effort (see docs): Conflict (regenerated from role
+// constraints), Journey steps, and Pattern requirement bodies.
+
+export const GRAPH_SOURCE_SCHEMA = 'intent-graph-source-v1';
+
+// Parse a "key value; key value" description back into an object (inverse of the joins
+// buildIntentGraph uses for scalar fields packed into a node description).
+function parseSegments(desc) {
+  const o = {};
+  for (const seg of String(desc || '').split(';')) {
+    const s = seg.trim();
+    if (!s) continue;
+    const m = s.match(/^(\w+)\s+(.+)$/);
+    if (m) o[m[1]] = m[2].trim();
+    else o[s] = true; // a bare flag like "idempotent"
+  }
+  return o;
+}
+
+export function graphToSource(graph) {
+  const nodes = graph?.nodes || [];
+  const rels = graph?.relationships || [];
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const byType = (t) => nodes.filter((n) => n.type === t);
+  const first = (t) => byType(t)[0] || null;
+  const title = (n) => (n && n.title != null ? String(n.title) : '');
+  // nodes reached FROM id by relType; nodes pointing TO id by relType.
+  const out = (id, type) => rels.filter((r) => r.from === id && r.type === type).map((r) => byId.get(r.to)).filter(Boolean);
+  const inTo = (id, type) => rels.filter((r) => r.to === id && r.type === type).map((r) => byId.get(r.from)).filter(Boolean);
+  const phaseOut = (id) => rels.filter((r) => r.from === id && r.type === 'blocks' && String(r.to).startsWith('phase.')).map((r) => String(r.to).slice('phase.'.length));
+
+  const L = [];
+  const push = (s = '') => L.push(s);
+
+  const mission = first('Mission');
+  const mName = title(mission) || 'Unnamed';
+  push(`mission ${mName}`);
+
+  // Infer the profiles in play from the node types present (advisory, aids readability).
+  const present = new Set(nodes.map((n) => n.type));
+  const uses = [];
+  if (['Outcome', 'Metric', 'Evidence', 'Persona'].some((t) => present.has(t))) uses.push('product');
+  if (['ExperienceContract', 'ExperienceState', 'Pattern'].some((t) => present.has(t))) uses.push('experience');
+  if (['Capability', 'SystemContract'].some((t) => present.has(t))) uses.push('system');
+  if (['Release', 'OutcomeResult', 'LearningArtifact', 'OutcomeContract'].some((t) => present.has(t))) uses.push('delivery');
+  if (['DesignComponent', 'DesignArtifact'].some((t) => present.has(t))) uses.push('design');
+  for (const u of uses) push(`use ${u}`);
+  push();
+
+  if (mission?.description) { push('goal'); push(`  ${mission.description}`); push(); }
+
+  // Persona / customer.
+  for (const p of byType('Persona')) push(`${p.description === 'customer' ? 'customer' : 'persona'} ${title(p)}`);
+
+  for (const e of byType('Evidence')) {
+    push(`evidence ${title(e)}`);
+    if (e.classification) push(`  classification ${e.classification}`);
+    if (e.confidence) push(`  confidence ${e.confidence}`);
+    if (e.source) push(`  source ${e.source}`);
+  }
+
+  for (const o of byType('Outcome')) {
+    push(`outcome ${title(o)}`);
+    if (o.description) push(`  "${o.description}"`);
+  }
+
+  for (const m of byType('Metric')) {
+    push(`metric ${title(m)}`);
+    const kv = parseSegments(m.description);
+    if (kv.baseline) push(`  baseline ${kv.baseline}`);
+    if (kv.target) push(`  target ${kv.target}`);
+    if (kv.window) push(`  window ${kv.window}`);
+  }
+
+  const reqs = byType('Requirement');
+  if (reqs.length) { push('requires'); for (const r of reqs) push(`  ${title(r)}`); }
+
+  // Guarantees (attached form so `verify` round-trips to VerificationRule nodes).
+  for (const g of byType('Guarantee')) {
+    push(`guarantee ${title(g)}`);
+    for (const v of out(g.id, 'verified_by')) push(`  verify ${title(v)}`);
+  }
+
+  // Never-rules: attached form when a `verify` exists (so it round-trips to VerificationRule
+  // nodes), plain `never` block otherwise.
+  const nevers = byType('Never');
+  const neverBare = nevers.filter((n) => out(n.id, 'verified_by').length === 0);
+  if (neverBare.length) { push('never'); for (const n of neverBare) push(`  ${title(n)}`); }
+  for (const n of nevers) {
+    const vs = out(n.id, 'verified_by');
+    if (!vs.length) continue;
+    push(`never ${title(n)}`);
+    for (const v of vs) push(`  verify ${title(v)}`);
+  }
+
+  // Global invariants , regenerate name + statement + verify so they round-trip to Invariant nodes.
+  for (const iv of byType('Invariant')) {
+    const nm = (iv.id || '').replace(/^invariant\./, '')
+      || String(title(iv)).replace(/[^A-Za-z0-9]+/g, '-').replace(/^-+|-+$/g, '').toLowerCase() || 'invariant';
+    push(`invariant ${nm}`);
+    push(`  statement ${title(iv)}`);
+    for (const v of out(iv.id, 'verified_by')) push(`  verify ${title(v)}`);
+  }
+
+  // Skills the mission requires , regenerate a `requires_skill` block so they round-trip to Skill
+  // nodes. (Required-understanding `demonstrates` is prose in the proof/AST, not a structural graph
+  // node, so it is intentionally not regenerated here.)
+  const skillNodes = byType('Skill');
+  if (skillNodes.length) { push('requires_skill'); for (const s of skillNodes) push(`  ${title(s)}`); }
+
+  for (const u of byType('Unknown')) {
+    push(`unknown ${title(u)}`);
+    if (u.owner) push(`  owner ${u.owner}`);
+    // The Unknown -blocks-> phase edge is emitted from `resolve before`, not `blocks`.
+    for (const ph of phaseOut(u.id)) push(`  resolve before ${ph}`);
+  }
+  for (const q of byType('Question')) {
+    push(`question ${title(q)}`);
+    if (q.owner) push(`  asked_of ${q.owner}`);
+    for (const ph of phaseOut(q.id)) push(`  blocks ${ph}`);
+  }
+  for (const a of byType('Assumption')) {
+    push(`assumption ${title(a)}`);
+    if (a.confidence) push(`  confidence ${a.confidence}`);
+  }
+
+  const approvals = byType('Approval');
+  if (approvals.length) { push('approval required from'); for (const a of approvals) push(`  ${title(a)}`); }
+
+  // Role-scoped constraints (`<role> requires`), grouped by role.
+  const constraintsByRole = {};
+  for (const c of byType('Constraint')) (constraintsByRole[c.owner || 'product'] ||= []).push(title(c));
+  for (const [role, stmts] of Object.entries(constraintsByRole)) {
+    push(`${role} requires`);
+    for (const s of stmts) push(`  ${s}`);
+  }
+
+  // Experience contracts + their states.
+  for (const exp of byType('ExperienceContract')) {
+    push(`experience ${title(exp)}`);
+    if (exp.owner) push(`  actor ${exp.owner}`);
+    if (exp.description) push(`  goal "${exp.description}"`);
+    for (const p of out(exp.id, 'derived_from')) if (p.type === 'Pattern') push(`  follows ${title(p)}`);
+    for (const st of out(exp.id, 'requires')) if (st.type === 'ExperienceState') {
+      push(`  state ${title(st)}`);
+      if (st.status === 'recoverable') push('    recover available');
+    }
+  }
+  for (const p of byType('Pattern')) push(`pattern ${title(p)}`);
+
+  // Style intents , re-emit the block (name, the experience it constrains, a11y target).
+  for (const si of byType('StyleIntent')) {
+    push(`style_intent ${title(si)}`);
+    const edge = rels.find((r) => r.to === si.id && r.type === 'constrained_by');
+    const exp = edge ? byId.get(edge.from) : null;
+    if (exp && exp.type === 'ExperienceContract') push(`  applies_to ${title(exp)}`);
+    const am = String(si.description || '').match(/a11y target (\S+)/);
+    if (am) push(`  accessibility_target ${am[1]}`);
+  }
+
+  // Lifecycles.
+  for (const lc of byType('Lifecycle')) {
+    push(`lifecycle ${title(lc)}`);
+    const states = out(lc.id, 'requires').filter((s) => s.type === 'LifecycleState');
+    for (const s of states) push(`  state ${title(s)}`);
+    let ti = 0;
+    for (const s of states) {
+      for (const r of rels.filter((r) => r.from === s.id && r.type === 'transitions_to')) {
+        const to = byId.get(r.to);
+        if (!to) continue;
+        ti += 1;
+        push(`  transition ${r.name || `t${ti}`}`);
+        push(`    from ${title(s)}`);
+        push(`    to ${title(to)}`);
+        if (r.within) push(`    within ${r.within}`);
+      }
+    }
+    const terminals = states.filter((s) => s.status === 'verified').map(title);
+    if (terminals.length) push(`  terminal ${terminals.join(', ')}`);
+  }
+
+  // Decisions + rules (round-trip by execution).
+  for (const d of byType('Decision')) {
+    push(`decision ${title(d)}`);
+    for (const r of out(d.id, 'requires').filter((n) => n.type === 'Rule')) {
+      const m = String(r.description || '').match(/^when (.+?) -> (.*)$/);
+      push(`  rule ${title(r)}`);
+      if (m) { push(`    when ${m[1]}`); push(`    return ${m[2]}`); }
+    }
+    const dm = String(d.description || '').match(/default (.+)$/);
+    if (dm) { push('  default'); push(`    return ${dm[1]}`); }
+    if (d.owner) push(`  owner ${d.owner}`);
+  }
+
+  // Commands + failure handlers.
+  for (const c of byType('Command')) {
+    push(`command ${title(c)}`);
+    const kv = parseSegments(c.description);
+    if (kv.idempotent) push('  idempotency_key id');
+    if (kv.timeout) push(`  timeout ${kv.timeout}`);
+    if (kv.retry) push(`  retry ${kv.retry}`);
+  }
+  for (const h of byType('FailureHandler')) {
+    push(`on ${title(h)}`);
+    const m = String(h.description || '').match(/compensate (.+)$/);
+    if (m) for (const step of m[1].split(',')) push(`  compensate ${step.trim()}`);
+  }
+
+  // System profile.
+  for (const cap of byType('Capability')) {
+    push(`capability ${title(cap)}`);
+    if (cap.description) push(`  description "${cap.description}"`);
+    // Capability -implemented_by-> member (members are OUT edges, unlike design components).
+    for (const m of out(cap.id, 'implemented_by')) push(`  implements ${title(m)}`);
+  }
+  for (const iface of byType('SystemContract')) {
+    push(`interface ${title(iface)}`);
+    const kv = parseSegments(iface.description);
+    if (kv.provides) push(`  provides ${kv.provides}`);
+    if (kv.requires) push(`  requires ${kv.requires}`);
+    if (kv.slo) push(`  slo "${kv.slo}"`);
+  }
+
+  // Delivery profile.
+  for (const r of byType('Release')) {
+    push(`release ${title(r)}`);
+    const kv = parseSegments(r.description);
+    if (kv.v) push(`  version "${kv.v.replace(/^v/, '')}"`);
+    if (r.status) push(`  status ${r.status}`);
+    if (kv.date) push(`  date ${kv.date}`);
+    if (kv.includes) for (const i of kv.includes.split(',')) push(`  includes ${i.trim()}`);
+  }
+  for (const res of byType('OutcomeResult')) {
+    push(`result ${title(res)}`);
+    const measured = inTo(res.id, 'resulted_in').find((n) => n.type === 'Outcome');
+    if (measured) push(`  measures ${title(measured)}`);
+    const kv = parseSegments(res.description);
+    if (kv.metric) push(`  metric ${kv.metric}`);
+    if (kv.value) push(`  value ${kv.value}`);
+    if (kv.baseline) push(`  baseline ${kv.baseline}`);
+  }
+  for (const l of byType('LearningArtifact')) {
+    push(`learning ${title(l)}`);
+    if (l.description) push(`  description "${l.description}"`);
+    const from = out(l.id, 'derived_from').find((n) => n.type === 'Release');
+    if (from) push(`  from ${title(from)}`);
+  }
+
+  // Outcome contracts.
+  for (const c of byType('OutcomeContract')) {
+    push(`outcome_contract ${title(c)}`);
+    const o = out(c.id, 'targets').find((n) => n.type === 'Outcome');
+    if (o) push(`  outcome ${title(o)}`);
+    const met = out(c.id, 'measured_by').find((n) => n.type === 'Metric');
+    if (met) push(`  metric ${title(met)}`);
+    const kv = parseSegments(c.description);
+    if (kv.baseline) push(`  baseline ${kv.baseline}`);
+    if (kv.target) push(`  target ${kv.target}`);
+    if (/lower is better/.test(c.description || '')) push('  direction lower');
+    if (kv.window) push(`  window ${kv.window}`);
+    if (c.owner) push(`  owner ${c.owner}`);
+  }
+
+  // Design profile.
+  for (const comp of byType('DesignComponent')) {
+    push(`component ${title(comp)}`);
+    const desc = String(comp.description || '');
+    const lead = desc.split(';')[0].trim();
+    if (lead && !/^(variants|tokens):/.test(lead)) push(`  description "${lead}"`);
+    const vm = desc.match(/variants:\s*([^;]+)/);
+    if (vm) for (const v of vm[1].split(',')) push(`  variant ${v.trim()}`);
+    const tm = desc.match(/tokens:\s*([^;]+)/);
+    if (tm) for (const t of tm[1].split(',')) push(`  token ${t.trim()}`);
+    for (const impl of inTo(comp.id, 'implemented_by')) push(`  implements ${title(impl)}`);
+  }
+  for (const art of byType('DesignArtifact')) {
+    push(`artifact ${title(art)}`);
+    const kv = parseSegments(art.description);
+    if (kv.kind) push(`  kind ${kv.kind}`);
+    if (art.source) push(`  ref "${art.source}"`);
+    for (const c of inTo(art.id, 'represented_by')) if (c.type === 'DesignComponent') push(`  covers ${title(c)}`);
+  }
+
+  return L.join('\n') + '\n';
+}