sibyl-system 1.2.2 → 1.3.1

package/dist/index.js

@@ -4904,9 +4904,9 @@ function cloneIssues(issues) {
 }
 var recursive = /* @__PURE__ */ new WeakMap();
 function isRecursive(inst, stack) {
-  const cached3 = recursive.get(inst);
-  if (cached3 !== void 0)
-    return cached3;
+  const cached4 = recursive.get(inst);
+  if (cached4 !== void 0)
+    return cached4;
   if (stack.has(inst))
     return true;
   stack.add(inst);
@@ -18662,15 +18662,15 @@ function visit(schema, fnOrHandlers) {
   };
   const cache = /* @__PURE__ */ new Map();
   function run2(s) {
-    const cached3 = cache.get(s);
-    if (cached3 === RESOLVING) {
+    const cached4 = cache.get(s);
+    if (cached4 === RESOLVING) {
       return new $ZodLazy({
         type: "lazy",
         getter: () => cache.get(s)
       });
     }
-    if (cached3 !== void 0)
-      return cached3;
+    if (cached4 !== void 0)
+      return cached4;
     cache.set(s, RESOLVING);
     const inner = mapInner(s);
     const mapped = fn(inner, inner !== s);
@@ -18919,7 +18919,10 @@ var pluginOptionsSchema = external_exports.object({
     runRoot: external_exports.string().min(1).default("/tmp"),
     opencodeBin: external_exports.string().min(1).prefault(discoverOpencodeBin),
     configSource: external_exports.string().prefault(() => join(homedir(), ".config", "opencode", "opencode.jsonc")),
-    roleTimeoutMs: external_exports.number().int().min(5e3).default(6e5)
+    roleTimeoutMs: external_exports.number().int().min(5e3).default(6e5),
+    /** Exam venue: absolute dirs tmpfs-masked from the candidate (grader files,
+     * other runs). Empty = venue runs unsandboxed and SAYS SO on the voice face. */
+    examMaskDirs: external_exports.array(external_exports.string().min(2)).default([])
   }).prefault({}),
   /** v1.1 E4/F1: seats only from allowed model-id prefixes; deny at launch. */
   modelPolicy: external_exports.object({
@@ -18986,7 +18989,36 @@ import { dirname, join as join2 } from "node:path";
 var SIBYL_STATE_FILE_ENV = "SIBYL_STATE_FILE";
 var RUN_KINDS = ["consult", "swarm"];
 var RUN_STATUSES = ["running", "done", "failed", "suspended"];
+var INDEPENDENCE_STATUSES = ["INDEPENDENT", "NOT-INDEPENDENT", "UNVERIFIABLE"];
+function isIndependenceShape(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+  const o = v;
+  if (!INDEPENDENCE_STATUSES.includes(o["status"])) return false;
+  if (!Array.isArray(o["convenerChain"]) || !o["convenerChain"].every((s) => typeof s === "string" && s.length > 0)) return false;
+  return typeof o["evidence"] === "string";
+}
+function rebuildIndependence(v) {
+  return { status: v.status, convenerChain: [...v.convenerChain], evidence: v.evidence };
+}
 var VERDICT_TAGS = ["APPROVE", "REJECT", "CANNOT_ANSWER"];
+var INSTRUMENT_NAME = /^[a-z0-9-]{1,40}$/;
+var HEX64 = /^[0-9a-f]{64}$/;
+function isInstrumentShape(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+  const o = v;
+  if (typeof o["rulesHash"] !== "string" || !HEX64.test(o["rulesHash"])) return false;
+  const comps = o["components"];
+  if (typeof comps !== "object" || comps === null || Array.isArray(comps)) return false;
+  return Object.entries(comps).every(
+    ([name, hash3]) => INSTRUMENT_NAME.test(name) && typeof hash3 === "string" && HEX64.test(hash3)
+  );
+}
+function rebuildInstrument(v) {
+  return {
+    rulesHash: v.rulesHash,
+    components: Object.fromEntries(Object.entries(v.components).map(([name, hash3]) => [name, hash3]))
+  };
+}
 function oneOf(v, opts) {
   return opts.some((o) => o === v);
 }
@@ -19062,6 +19094,20 @@ function validateEntry(raw) {
     if (typeof notes !== "string") return { ok: false, reason: "notes must be a string when present" };
     record3.notes = notes;
   }
+  const instrument = field(raw, "instrument");
+  if (instrument !== void 0) {
+    if (!isInstrumentShape(instrument)) {
+      return { ok: false, reason: "instrument must be {rulesHash: 64-hex, components: name->64-hex} when present" };
+    }
+    record3.instrument = rebuildInstrument(instrument);
+  }
+  const independence = field(raw, "independence");
+  if (independence !== void 0) {
+    if (!isIndependenceShape(independence)) {
+      return { ok: false, reason: "independence must be {status: INDEPENDENT|NOT-INDEPENDENT|UNVERIFIABLE, convenerChain: string[], evidence: string} when present" };
+    }
+    record3.independence = rebuildIndependence(independence);
+  }
   return { ok: true, record: record3 };
 }
 function byCreatedAt(a, b) {
@@ -19190,8 +19236,8 @@ var RunStore = class {
 };
 
 // src/tools/consult.ts
-import { join as join3 } from "node:path";
-import { writeFile as writeFile2 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+import { appendFile, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
 
 // node_modules/@opencode-ai/plugin/node_modules/zod/v4/classic/external.js
 var external_exports2 = {};
@@ -31895,6 +31941,123 @@ async function runPersona(opts) {
   }
 }
 
+// src/independence.ts
+var MAX_CHAIN_DEPTH = 16;
+var MIN_INLINE_MATCH = 64;
+var DRAFTING_TOOLS = ["write", "edit", "multiedit", "patch", "apply_patch"];
+var PATH_KEYS = ["filePath", "path"];
+var CONTENT_KEYS = ["content", "text", "oldString", "newString"];
+function isDraftingTool(name) {
+  return name !== void 0 && DRAFTING_TOOLS.includes(name);
+}
+function pathTargets(input2, artifactPath) {
+  if (input2 === void 0) return false;
+  for (const key of PATH_KEYS) {
+    const v = input2[key];
+    if (typeof v === "string" && v.trim() === artifactPath) return true;
+  }
+  return false;
+}
+function contentMatches(input2, needle) {
+  if (input2 === void 0) return false;
+  for (const key of CONTENT_KEYS) {
+    const v = input2[key];
+    if (typeof v !== "string") continue;
+    if (v.trim() === needle) return true;
+    if (needle.length >= MIN_INLINE_MATCH && v.includes(needle)) return true;
+    if (needle.length >= MIN_INLINE_MATCH && v.length >= MIN_INLINE_MATCH && needle.includes(v.trim()) && v.trim().length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function scanMessages(rows, convenerIndex, sid, artifact) {
+  for (const [mi, m] of rows.entries()) {
+    for (const p of m.parts ?? []) {
+      if (p.type === "tool" && isDraftingTool(p.tool)) {
+        if (artifact.kind === "path" && pathTargets(p.input, artifact.source)) {
+          return `drafting evidence: ${p.tool} on ${artifact.source} in convener-chain session ${sid} (chain position ${String(convenerIndex)}, message ${String(mi)})`;
+        }
+        if (artifact.kind === "inline" && contentMatches(p.input, artifact.text.trim())) {
+          return `drafting evidence: ${p.tool} content matches the inline artifact in convener-chain session ${sid} (chain position ${String(convenerIndex)}, message ${String(mi)})`;
+        }
+      }
+      if (artifact.kind === "inline" && m.info?.role === "assistant" && p.type === "text" && typeof p.text === "string" && artifact.text.trim().length >= MIN_INLINE_MATCH && p.text.includes(artifact.text.trim())) {
+        return `drafting evidence: assistant text in convener-chain session ${sid} (chain position ${String(convenerIndex)}, message ${String(mi)}) contains the inline artifact`;
+      }
+    }
+  }
+  return null;
+}
+async function assessIndependence(client, directory, convenerSessionID, artifact) {
+  const noChain = { status: "UNVERIFIABLE", convenerChain: [], evidence: "" };
+  if (convenerSessionID.length === 0) {
+    return { ...noChain, evidence: "headless invocation: no calling session to resolve the convener chain against" };
+  }
+  if (!artifact.ok) {
+    return { ...noChain, evidence: "artifact unreadable at assessment time" };
+  }
+  if (client.session.get === void 0) {
+    return { ...noChain, evidence: "engine client exposes no session.get seam (chain cannot be walked; not a verdict of independence)" };
+  }
+  if (client.session.messages === void 0) {
+    return { ...noChain, convenerChain: [convenerSessionID], evidence: "engine client exposes no session.messages seam (drafting scan impossible)" };
+  }
+  const chain = [convenerSessionID];
+  const seen = new Set(chain);
+  let walkIncomplete = false;
+  let walkReason = "";
+  let current = convenerSessionID;
+  for (let depth = 0; depth < MAX_CHAIN_DEPTH; depth += 1) {
+    const res = await client.session.get({ path: { id: current } });
+    if (res.error !== void 0 || res.data === void 0) {
+      walkIncomplete = true;
+      walkReason = `session.get(${current}) refused (${res.error === void 0 ? "no data" : JSON.stringify(res.error).slice(0, 120)})`;
+      break;
+    }
+    const parent = res.data.parentID ?? "";
+    if (parent.length === 0) break;
+    if (seen.has(parent)) {
+      walkReason = `cycle at ${parent} (store anomaly); walk stopped`;
+      break;
+    }
+    chain.push(parent);
+    seen.add(parent);
+    current = parent;
+  }
+  let scanFailed = "";
+  for (const [i, sid] of chain.entries()) {
+    const res = await client.session.messages({ path: { id: sid }, query: { directory } });
+    if (res.error !== void 0 || res.data === void 0) {
+      scanFailed = scanFailed.length > 0 ? scanFailed : `messages(${sid}) refused`;
+      continue;
+    }
+    const hit = scanMessages(res.data, i, sid, artifact);
+    if (hit !== null) {
+      return { status: "NOT-INDEPENDENT", convenerChain: chain, evidence: hit };
+    }
+  }
+  if (scanFailed.length > 0 || walkIncomplete) {
+    const why = [walkIncomplete ? walkReason : "", scanFailed].filter((s) => s.length > 0).join("; ");
+    return { status: "UNVERIFIABLE", convenerChain: chain, evidence: `partial read: ${why} \u2014 independence was NOT established` };
+  }
+  const note = walkReason.length > 0 ? `; walk note: ${walkReason}` : "";
+  return {
+    status: "INDEPENDENT",
+    convenerChain: chain,
+    evidence: `scanned ${String(chain.length)} session(s) of the convener chain to root; no drafting evidence within read scope${note}`
+  };
+}
+function independenceLabel(v) {
+  return v.status === "INDEPENDENT" ? "independence=INDEPENDENT" : `independence=${v.status} \u2014 ${v.evidence}`;
+}
+
+// src/instrument.ts
+import { createHash } from "node:crypto";
+
+// src/chamber/protocol.ts
+import { join as join4 } from "node:path";
+
 // src/verdict/index.ts
 var OPEN_BRACE = 123;
 var CLOSE_BRACE = 125;
@@ -32046,6 +32209,135 @@ async function parseVerdict(text, repair) {
   return rejectVerdict(`${first.why} + repair-invalid: ${second.why}`);
 }
 
+// src/state/chamber.ts
+import { mkdir as mkdir2, readFile as readFile2, readdir, rename as rename2, unlink as unlink2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname2, isAbsolute, join as join3, resolve } from "node:path";
+var DEFAULT_CHAMBER_LEDGER = join3(homedir3(), ".sibyl", "chamber-ledger.jsonl");
+var TERMINAL_STATES = ["CONVERGED", "NEEDS_ROUND", "MEMBER_LOST", "TIMEOUT"];
+var RUN_PROFILES = ["review", "exam"];
+var RECORD_SCHEMA = 1;
+function asStringArray(v) {
+  return Array.isArray(v) && v.every((x) => typeof x === "string") ? [...v] : null;
+}
+function isRosterRef(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const o = v;
+  const modelOk = o["policyCheck"] === "deny" ? typeof o["modelId"] === "string" : isNonEmptyString(o["modelId"]);
+  return isNonEmptyString(o["role"]) && isNonEmptyString(o["slot"]) && modelOk && (o["policyCheck"] === "allow" || o["policyCheck"] === "deny") && (o["denyReason"] === void 0 || typeof o["denyReason"] === "string");
+}
+function isArtifactRef(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const o = v;
+  return isNonEmptyString(o["role"]) && typeof o["round"] === "number" && Number.isInteger(o["round"]) && o["round"] >= 0 && isNonEmptyString(o["phase"]) && isNonEmptyString(o["relPath"]) && typeof o["sha256"] === "string" && /^[0-9a-f]{64}$/.test(o["sha256"]) && typeof o["bytes"] === "number" && o["bytes"] >= 0 && isNonEmptyString(o["presentAt"]) && (o["rc"] === null || typeof o["rc"] === "number") && (o["signal"] === null || typeof o["signal"] === "string") && typeof o["timedOut"] === "boolean";
+}
+function validateChamberRecord(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return { ok: false, reason: "record is not an object" };
+  const o = raw;
+  if (o["schema"] !== RECORD_SCHEMA) return { ok: false, reason: `schema must be ${RECORD_SCHEMA}` };
+  if (!isNonEmptyString(o["runId"])) return { ok: false, reason: "runId must be a non-empty string" };
+  if (typeof o["serial"] !== "number" || !Number.isInteger(o["serial"]) || o["serial"] < 1) return { ok: false, reason: "serial must be a positive integer" };
+  if (!RUN_PROFILES.includes(o["profile"])) return { ok: false, reason: `profile must be one of ${RUN_PROFILES.join("|")}` };
+  if (!isNonEmptyString(o["goal"])) return { ok: false, reason: "goal must be a non-empty string" };
+  if (typeof o["target"] !== "string") return { ok: false, reason: "target must be a string" };
+  if (!isNonEmptyString(o["runDir"]) || !isAbsolute(o["runDir"])) return { ok: false, reason: "runDir must be an absolute path" };
+  if (!isNonEmptyString(o["createdAt"]) || Number.isNaN(Date.parse(o["createdAt"]))) return { ok: false, reason: "createdAt must be ISO" };
+  if (!isNonEmptyString(o["updatedAt"]) || Number.isNaN(Date.parse(o["updatedAt"]))) return { ok: false, reason: "updatedAt must be ISO" };
+  if (o["terminal"] !== null && !TERMINAL_STATES.includes(o["terminal"])) return { ok: false, reason: "terminal must be null or a TerminalState" };
+  if (!Array.isArray(o["roster"]) || !o["roster"].every(isRosterRef)) return { ok: false, reason: "roster must be an array of RosterRef" };
+  const judgePool = asStringArray(o["judgePool"]);
+  if (judgePool === null) return { ok: false, reason: "judgePool must be a string array" };
+  if (!isNonEmptyString(o["seed"])) return { ok: false, reason: "seed must be a non-empty string" };
+  if (typeof o["drawCommit"] !== "string" || !/^[0-9a-f]{64}$/.test(o["drawCommit"])) return { ok: false, reason: "drawCommit must be 64-hex" };
+  if (typeof o["judgeModelId"] !== "string") return { ok: false, reason: "judgeModelId must be a string" };
+  if (typeof o["rounds"] !== "number" || !Number.isInteger(o["rounds"]) || o["rounds"] < 0) return { ok: false, reason: "rounds must be a non-negative integer" };
+  if (!Array.isArray(o["artifacts"]) || !o["artifacts"].every(isArtifactRef)) return { ok: false, reason: "artifacts must be an array of ArtifactRef" };
+  if (typeof o["evidenceRows"] !== "number" || !Number.isInteger(o["evidenceRows"]) || o["evidenceRows"] < 0) return { ok: false, reason: "evidenceRows must be a non-negative integer" };
+  if (o["notes"] !== void 0 && typeof o["notes"] !== "string") return { ok: false, reason: "notes must be a string when present" };
+  if (o["instrument"] !== void 0 && !isInstrumentShape(o["instrument"])) {
+    return { ok: false, reason: "instrument must be {rulesHash: 64-hex, components: name->64-hex} when present" };
+  }
+  if (o["independence"] !== void 0 && !isIndependenceShape(o["independence"])) {
+    return { ok: false, reason: "independence must be {status: INDEPENDENT|NOT-INDEPENDENT|UNVERIFIABLE, convenerChain: string[], evidence: string} when present" };
+  }
+  const record3 = {
+    schema: RECORD_SCHEMA,
+    runId: o["runId"],
+    serial: o["serial"],
+    profile: o["profile"],
+    goal: o["goal"],
+    target: o["target"],
+    runDir: o["runDir"],
+    createdAt: o["createdAt"],
+    updatedAt: o["updatedAt"],
+    terminal: o["terminal"],
+    roster: [...o["roster"]],
+    judgePool,
+    seed: o["seed"],
+    drawCommit: o["drawCommit"],
+    judgeModelId: o["judgeModelId"],
+    rounds: o["rounds"],
+    artifacts: [...o["artifacts"]],
+    evidenceRows: o["evidenceRows"]
+  };
+  if (typeof o["notes"] === "string") record3.notes = o["notes"];
+  if (o["instrument"] !== void 0) record3.instrument = rebuildInstrument(o["instrument"]);
+  if (o["independence"] !== void 0) record3.independence = rebuildIndependence(o["independence"]);
+  return { ok: true, record: record3 };
+}
+function parseLedgerLine(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return { ok: false, reason: "blank line" };
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: `not a single JSON document (merged-row guard): ${msg}` };
+  }
+  const v = validateChamberRecord(parsed);
+  if (!v.ok) return { ok: false, reason: v.reason };
+  return { ok: true, record: v.record };
+}
+async function loadLedger(ledgerPath) {
+  let text;
+  try {
+    text = await readFile2(ledgerPath, "utf8");
+  } catch {
+    return { rows: [], dropped: [] };
+  }
+  const rows = [];
+  const dropped = [];
+  const lines = text.split("\n");
+  for (const [i, line] of lines.entries()) {
+    if (line.trim().length === 0) continue;
+    const v = parseLedgerLine(line);
+    if (v.ok) rows.push(v.record);
+    else dropped.push({ line: i + 1, reason: v.reason });
+  }
+  return { rows, dropped };
+}
+
+// src/chamber/protocol.ts
+var CONTRACT = (writeTo, sections) => `OUTPUT CONTRACT: as you work, WRITE your result incrementally to ${writeTo} (create parent dirs as needed). Required structure: ${sections}. The file on disk is the only receipt that counts; keep the chat reply short. Write ONLY inside your run directory.`;
+function evidencePrompt(cfg, abs) {
+  return `You are the EVIDENCE GATHERER of a Sibyl review chamber. Goal: "${cfg.goal}". Artifact under review: ${cfg.targetPath}. Enumerate evidence sources BROADLY first (list directories, then sample candidates: the target, adjacent docs/notes, logs, prior reviews). Breadth over depth; no deep analysis. Append one JSON object per line to ${abs}: {"probe":"<command or path read>","found":"<path>","class":"<doc|log|ledger|transcript|other>","note":"<one line>"}. ` + CONTRACT(abs, "one JSON object per line");
+}
+function proPrompt(cfg, round, abs, charges) {
+  const chargeBlock = charges.length > 0 ? ` Prior open charges you must answer: ${JSON.stringify(charges)}.` : "";
+  return `You are PRO (round ${String(round)}) in a Sibyl adversarial chamber. Goal: "${cfg.goal}". Read ${cfg.targetPath} and the evidence ledger ${join4(cfg.runDir, "evidence/evidence.jsonl")}, then argue for the strongest DEFENSIBLE version of the artifact: real merits, each claim citing ledger rows/paths, no spin.` + chargeBlock + " " + CONTRACT(abs, "## Case (numbered claims C1..Cn) and ## Evidence (claim -> cited paths)");
+}
+function conPrompt(cfg, round, abs, charges) {
+  const chargeBlock = charges.length > 0 ? ` Previously contested \u2014 sharpen or drop: ${JSON.stringify(charges)}.` : "";
+  return `You are CON (round ${String(round)}) in a Sibyl adversarial chamber. Goal: "${cfg.goal}". Read ${cfg.targetPath} and the evidence ledger ${join4(cfg.runDir, "evidence/evidence.jsonl")}, then attack the artifact: REAL defects only (correctness, missing evidence, unactionable claims), every charge citing a path or quote.` + chargeBlock + " " + CONTRACT(abs, "## Charges (numbered N1..Nn, each with cited evidence)");
+}
+function rebuttalPrompt(cfg, role, round, otherAbs, abs) {
+  return `You are ${role.toUpperCase()} in cross-critique (round ${String(round)}). Read your opponent's artifact at ${otherAbs} plus the evidence ledger under ${join4(cfg.runDir, "evidence")} (you may re-probe primary sources). Respond point by point: CONCEDE what is right, REBUT what is wrong, replies keyed to the opponent's numbering. Never edit the opponent's file; write only your own new file. ` + CONTRACT(abs, "## Replies (K1..Kn keyed to opponent numbering) and ## Still Open");
+}
+function judgePrompt(cfg, round, paths, abs) {
+  return `You are the INDEPENDENT JUDGE (round ${String(round)}) of a Sibyl chamber. You wrote nothing here. FIRST ACTION (no analysis before it): write a valid interim JSON to ${abs} \u2014 {"convergence":"NEEDS_ROUND","conclusion":"NEEDS_HUMAN","confidence":0,"reasons":["interim - judging"],"must_fix":[],"charges":[]} \u2014 then read the materials and OVERWRITE it with your final verdict as your last action. Read ALL of: ${paths.join(" ; ")} and the original target ${cfg.targetPath}. Re-probe AT MOST the three most load-bearing citations (open the cited file; a citation to a non-existent path is an automatic charge) \u2014 time-box yourself, breadth of verification below 3 is enough. Decide if the debate has CONVERGED (no material open charges) and the single review conclusion. The file must end holding EXACTLY ONE JSON object: {"convergence":"CONVERGED"|"NEEDS_ROUND","conclusion":"APPROVE"|"REJECT"|"NEEDS_HUMAN","confidence":<0..1>,"reasons":[...],"must_fix":[...],"charges":[...open charges; empty when CONVERGED]}. Also print the same JSON in your reply. Partial or non-JSON output = failure.`;
+}
+
 // src/personas.ts
 var ARCHITECT_OUTPUT_CONTRACT = 'Respond with EXACTLY one JSON object and nothing else - no prose, no markdown fences, no extra keys - matching: {"tasks":[{"id":<string>,"title":<string>,"instructions":<string>,"dependsOn":[<task id strings>]}],"concurrency":<integer >= 1>,"notes":<string>}. "tasks" are the units of work decomposing the goal, "dependsOn" lists task ids that must finish first, "concurrency" is the maximum number of tasks safe to run in parallel, "notes" carries planning remarks (empty string if none).';
 var ARCHITECT_SYSTEM = "You are ARCHITECT, the SIBYL planning persona. Decompose the given artifact-production goal into a dependency-ordered workflow of minimal, independently executable tasks. " + ARCHITECT_OUTPUT_CONTRACT;
@@ -32055,6 +32347,11 @@ var ARCHITECT_PERSONA = {
   system: ARCHITECT_SYSTEM,
   modelSlot: "architect"
 };
+function repairDemand(why) {
+  return `Your previous reply was not a valid verdict JSON (${why}). Reply again with EXACTLY one JSON object and nothing else - no prose, no markdown fences: {"verdict":"APPROVE"|"REJECT","confidence":<number between 0 and 1>,"reasons":[<strings>],"must_fix":[<strings>]}`;
+}
+var SWARM_JUDGE_SYSTEM = "You are the SIBYL swarm judge. You rule on pipeline reports with exactly one word: APPROVE, REJECT, or EXHAUSTED.";
+var SWARM_JUDGE_WORD_CONTRACT = "Respond with EXACTLY one word and nothing else: APPROVE, REJECT, or EXHAUSTED.";
 var PERSONAS = {
   MELCHIOR: {
     id: "MELCHIOR",
@@ -32081,9 +32378,108 @@ var BY_ID = new Map(
   PERSONA_IDS.map((id) => [id, PERSONAS[id]])
 );
 
+// src/instrument.ts
+function sha256Hex(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+var REPAIR_SENTINEL = "<parse-failure-why>";
+var SENTINEL_CFG = {
+  runId: "sibyl-sentinel",
+  runDir: "/sentinel/run",
+  goal: "<goal>",
+  targetPath: "/sentinel/target.md",
+  ledgerPath: "/sentinel/ledger.jsonl",
+  seed: "<seed>",
+  maxRounds: 1,
+  pool: { default: { providerID: "", modelID: "" } },
+  policy: null,
+  slots: { evidence: "default", pro: "default", con: "default", judge: "default" },
+  judgePoolIds: [],
+  lane: null
+};
+function chamberRoleTexts() {
+  return {
+    "chamber-evidence-prompt": evidencePrompt(SENTINEL_CFG, "/sentinel/evidence.jsonl"),
+    "chamber-pro-prompt": proPrompt(SENTINEL_CFG, 1, "/sentinel/pro.md", []),
+    "chamber-con-prompt": conPrompt(SENTINEL_CFG, 1, "/sentinel/con.md", []),
+    "chamber-rebuttal-prompt": rebuttalPrompt(SENTINEL_CFG, "pro", 1, "/sentinel/con.md", "/sentinel/pro-rebuttal.md"),
+    "chamber-judge-prompt": judgePrompt(SENTINEL_CFG, 1, ["/sentinel/pro.md", "/sentinel/con.md"], "/sentinel/judge.json")
+  };
+}
+function componentTexts() {
+  const texts = {
+    "repair-grammar": repairDemand(REPAIR_SENTINEL),
+    "swarm-judge-system": SWARM_JUDGE_SYSTEM,
+    "swarm-judge-word-contract": SWARM_JUDGE_WORD_CONTRACT,
+    ...chamberRoleTexts()
+  };
+  for (const id of COUNCILORS) {
+    texts[`councilor-${id.toLowerCase()}`] = COUNCILOR_PERSONAS[id].system;
+  }
+  texts["architect-system"] = ARCHITECT_SYSTEM;
+  return texts;
+}
+var cached3 = null;
+function instrumentFace() {
+  if (cached3 !== null) return cached3;
+  const components = {};
+  for (const [name, text] of Object.entries(componentTexts())) {
+    components[name] = sha256Hex(text);
+  }
+  const canonical = JSON.stringify(
+    Object.keys(components).sort().map((name) => [name, components[name]])
+  );
+  cached3 = { rulesHash: sha256Hex(canonical), components };
+  return cached3;
+}
+function rulesLabel(face) {
+  return `rules=${face.rulesHash.slice(0, 12)}`;
+}
+
+// src/terminal.ts
+var TERMINAL_STATUSES = ["ok", "error", "timeout"];
+var TERMINAL_DETAIL_MAX = 240;
+function sanitizeDetail(text) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length <= TERMINAL_DETAIL_MAX ? flat : `${flat.slice(0, TERMINAL_DETAIL_MAX)}\u2026`;
+}
+function classifyFailure(error105) {
+  return /timeout|timed out|deadline/i.test(error105) ? "timeout" : "error";
+}
+function formatTerminalRow(at, row) {
+  return `ts=${at.toISOString()} task=${row.task} worker=${row.worker} status=${row.status} session=${row.session.length > 0 ? row.session : "-"} detail=${sanitizeDetail(row.detail)}`;
+}
+function parseTerminalRows(text) {
+  const byTask = /* @__PURE__ */ new Map();
+  const lines = text.split("\n");
+  for (const [i, line] of lines.entries()) {
+    if (line.trim().length === 0) continue;
+    const task = /(?:^| )task=(\S+)/.exec(line)?.[1];
+    const statusRaw = /(?:^| )status=(\S+)/.exec(line)?.[1];
+    if (task === void 0 || statusRaw === void 0) continue;
+    const status = TERMINAL_STATUSES.includes(statusRaw) ? statusRaw : void 0;
+    if (status === void 0) continue;
+    byTask.set(task, {
+      task,
+      worker: /(?:^| )worker=(\S+)/.exec(line)?.[1] ?? "-",
+      status,
+      session: /(?:^| )session=(\S+)/.exec(line)?.[1] ?? "-",
+      detail: /(?:^| )detail=([\s\S]*)$/.exec(line)?.[1] ?? "",
+      line: i + 1
+    });
+  }
+  return byTask;
+}
+function deadWithoutRecord(declaredTaskIds, rows) {
+  return declaredTaskIds.filter((id) => !rows.has(id));
+}
+function deadFaceCount(dead) {
+  return `dead-without-record=${String(dead.length)}`;
+}
+
 // src/tools/shared.ts
-import { readFile as readFile2, stat } from "node:fs/promises";
-import { isAbsolute, resolve } from "node:path";
+import { readFile as readFile3, stat } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
 var ARTIFACT_MAX_BYTES = 262144;
 var DEFAULT_SLOT2 = "default";
 function slotForModel(pool, overrideSlot, personaSlot) {
@@ -32108,7 +32504,7 @@ async function readArtifact(raw, cwd) {
       text: trimmed
     };
   }
-  const path = isAbsolute(trimmed) ? trimmed : resolve(cwd, trimmed);
+  const path = isAbsolute2(trimmed) ? trimmed : resolve2(cwd, trimmed);
   let info;
   try {
     info = await stat(path);
@@ -32126,7 +32522,7 @@ async function readArtifact(raw, cwd) {
   }
   let text;
   try {
-    text = await readFile2(path, "utf8");
+    text = await readFile3(path, "utf8");
   } catch (err) {
     return { ok: false, error: `artifact "${path}": ${errMessage(err)}` };
   }
@@ -32196,7 +32592,8 @@ function formatRunLine(record3) {
   const verdict = record3.verdict === void 0 ? "-" : `${record3.verdict.verdict}(A${String(record3.verdict.approvals)}/R${String(record3.verdict.rejects)}/E${String(record3.verdict.errors)}/M${String(record3.verdict.missing)})`;
   const rounds = record3.rounds === void 0 ? "" : ` rounds=${String(record3.rounds)}`;
   const goal = record3.goal === void 0 ? "" : ` goal="${record3.goal}"`;
-  return `${record3.runId} ${record3.kind} ${record3.status} ${verdict}${rounds}${goal} created=${record3.createdAt} updated=${record3.updatedAt} space=${record3.spaceDir}`;
+  const rules = record3.instrument === void 0 ? "" : ` rules=${record3.instrument.rulesHash.slice(0, 12)}`;
+  return `${record3.runId} ${record3.kind} ${record3.status} ${verdict}${rounds}${goal}${rules} created=${record3.createdAt} updated=${record3.updatedAt} space=${record3.spaceDir}`;
 }
 
 // src/tools/consult.ts
@@ -32210,9 +32607,6 @@ ${goal}
 ARTIFACT:
 ${artifactText}`;
 }
-function buildRepairDemand(why) {
-  return `Your previous reply was not a valid verdict JSON (${why}). Reply again with EXACTLY one JSON object and nothing else - no prose, no markdown fences: {"verdict":"APPROVE"|"REJECT","confidence":<number between 0 and 1>,"reasons":[<strings>],"must_fix":[<strings>]}`;
-}
 var REPLY_HEADER = "<!-- SIBYL consult voter reply (plan task 8). Full raw session text below; parse/repair metadata at the end. -->\n";
 function renderReply(voter, text, meta3) {
   return `${REPLY_HEADER}
@@ -32230,7 +32624,7 @@ async function castVote(job) {
   const { client, options } = deps;
   const persona = PERSONAS[id];
   const model = slotForModel(options.modelPool, options.voters[id], persona.modelSlot);
-  const replyPath = join3(spaceDir, `${id}.md`);
+  const replyPath = join5(spaceDir, `${id}.md`);
   const result = await runPersona({
     client,
     directory,
@@ -32244,7 +32638,7 @@ async function castVote(job) {
     const error105 = `${result.stage ?? "engine"}: ${result.error ?? "unknown error"}`;
     const vote2 = { id, ok: false, error: error105 };
     const replyAt2 = await safeWrite(replyPath, renderReply(id, "(no reply \u2014 engine call failed)", `ballot: ERROR ${error105}`));
-    return { id, vote: vote2, replyPath: replyAt2, modelApplied: result.modelApplied, latencyMs: result.latencyMs };
+    return { id, vote: vote2, replyPath: replyAt2, sessionId: result.sessionID, modelApplied: result.modelApplied, latencyMs: result.latencyMs };
   }
   const verdict = await parseVerdict(result.text, async (_badText, why) => {
     const followed = await runInSession(
@@ -32252,7 +32646,7 @@ async function castVote(job) {
       directory,
       result.sessionID,
       model,
-      buildRepairDemand(why),
+      repairDemand(why),
       options.timeoutMs
     );
     return followed.ok ? followed.text : "";
@@ -32261,11 +32655,11 @@ async function castVote(job) {
   const vote = unparseable ? { id, ok: false, error: verdict.reasons[0] ?? "verdict-unparseable" } : { id, ok: true, verdict };
   const meta3 = unparseable ? `ballot: ERROR ${verdict.reasons[0] ?? "verdict-unparseable"} (reply did not parse)` : `ballot: ${verdict.verdict} (confidence ${String(verdict.confidence)}) \xB7 session ${result.sessionID} \xB7 model ${result.modelApplied ?? "host-picked"} \xB7 ${String(result.latencyMs)}ms`;
   const replyAt = await safeWrite(replyPath, renderReply(id, result.text, meta3));
-  return { id, vote, replyPath: replyAt, modelApplied: result.modelApplied, latencyMs: result.latencyMs };
+  return { id, vote, replyPath: replyAt, sessionId: result.sessionID, modelApplied: result.modelApplied, latencyMs: result.latencyMs };
 }
 async function safeWrite(path, text) {
   try {
-    await writeFile2(path, text, "utf8");
+    await writeFile3(path, text, "utf8");
     return path;
   } catch (err) {
     return `<${path} write failed: ${errMessage(err)}>`;
@@ -32292,6 +32686,7 @@ async function consultExecute(deps, args, context) {
   if (!read.ok) {
     return `SIBYL consult: ${read.error}`;
   }
+  const independence = await assessIndependence(deps.client, context.directory, context.sessionID, read);
   const { record: record3 } = await deps.store.createRun({
     kind: "consult",
     artifact: read.source,
@@ -32303,25 +32698,51 @@ async function consultExecute(deps, args, context) {
     )
   );
   const tally = tallyVotes(outcomes.map((o) => o.vote));
+  const terminalsPath = join5(record3.spaceDir, "TERMINALS.txt");
+  await Promise.all(
+    outcomes.map((o) => {
+      const vote = o.vote;
+      const status = "missing" in vote ? "error" : vote.ok ? "ok" : classifyFailure(vote.error);
+      const detail = "missing" in vote || !vote.ok ? `ballot=${ballotTag(vote)}` : `ballot=${vote.verdict.verdict}`;
+      const line = formatTerminalRow(/* @__PURE__ */ new Date(), {
+        task: o.id,
+        worker: o.id,
+        status,
+        session: o.sessionId,
+        detail
+      });
+      return appendFile(terminalsPath, `${line}
+`, "utf8").catch((err) => {
+        console.error(`[sibyl consult] terminal row for ${o.id} failed to write: ${errMessage(err)}`);
+      });
+    })
+  );
+  const rows = parseTerminalRows(await readFile4(terminalsPath, "utf8").catch(() => ""));
+  const dead = deadWithoutRecord([...COUNCILORS], rows);
+  const effectiveVerdict = dead.length > 0 ? "CANNOT_ANSWER" : tally.verdict;
   const finalRecord = {
     ...record3,
     status: "done",
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     verdict: {
-      verdict: tally.verdict,
+      verdict: effectiveVerdict,
       approvals: tally.approvals,
       rejects: tally.rejects,
       errors: tally.errors,
       missing: tally.missing
     },
-    notes: `policy=${tally.policy} ` + outcomes.map((o) => `${o.id}=${ballotTag(o.vote)} reply=${o.replyPath}`).join(" \xB7 ")
+    instrument: instrumentFace(),
+    independence,
+    notes: `policy=${tally.policy} ${deadFaceCount(dead)}${dead.length > 0 ? ` (${dead.join(",")} left no terminal row: instrument wounded, not a verdict)` : ""} independence=${independence.status}${independence.status === "NOT-INDEPENDENT" ? " (self-convoked: ballot preserved, not in any effective path)" : ""} ` + outcomes.map((o) => `${o.id}=${ballotTag(o.vote)} reply=${o.replyPath}`).join(" \xB7 ")
   };
   await deps.store.appendOrUpdate(finalRecord);
   const lines = [
-    `SIBYL CONSULT: ${tally.verdict} (votes ${String(tally.approvals)}A/${String(tally.rejects)}R/${String(tally.errors)}E/${String(tally.missing)}M) run ${record3.runId}`,
+    `SIBYL CONSULT: ${effectiveVerdict} (${deadFaceCount(dead)} votes ${String(tally.approvals)}A/${String(tally.rejects)}R/${String(tally.errors)}E/${String(tally.missing)}M) run ${record3.runId}`,
+    `  ${independenceLabel(independence)}`,
     ...tally.reasons.map((r) => `  reason: ${r}`),
     ...tally.must_fix.map((m) => `  must_fix: ${m}`),
     ...outcomes.map((o) => `  reply: ${o.id} -> ${o.replyPath}`),
+    `  ${rulesLabel(finalRecord.instrument ?? instrumentFace())} components=${String(Object.keys(instrumentFace().components).length)}`,
     `  store: ${deps.store.runsFile}`
   ];
   return lines.join("\n");
@@ -32335,20 +32756,20 @@ function ballotTag(vote) {
 import { spawn } from "node:child_process";
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
-import { mkdir as mkdir2, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname2, join as join4 } from "node:path";
+import { mkdir as mkdir3, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname3, join as join6 } from "node:path";
 import { fileURLToPath } from "node:url";
 var REVIEW_TOOL_NAME = "sibyl_review";
 function nodeBinary() {
   return existsSync2("/usr/bin/node") ? "/usr/bin/node" : process.execPath;
 }
 function cliCommand(thisUrl, node2) {
-  const moduleDir = dirname2(fileURLToPath(thisUrl));
-  const repoRoot = dirname2(dirname2(moduleDir));
-  const distCli = join4(repoRoot, "dist", "cli.js");
+  const moduleDir = dirname3(fileURLToPath(thisUrl));
+  const repoRoot = dirname3(dirname3(moduleDir));
+  const distCli = join6(repoRoot, "dist", "cli.js");
   if (existsSync2(distCli)) return { bin: node2, args: [distCli] };
-  const srcCli = join4(repoRoot, "src", "cli.ts");
-  const hooks = join4(repoRoot, "tools", "register-ts.mjs");
+  const srcCli = join6(repoRoot, "src", "cli.ts");
+  const hooks = join6(repoRoot, "tools", "register-ts.mjs");
   return { bin: node2, args: ["--import", hooks, srcCli] };
 }
 async function reviewExecute(deps, args, context) {
@@ -32357,29 +32778,38 @@ async function reviewExecute(deps, args, context) {
     const opts = deps.options;
     const now = /* @__PURE__ */ new Date();
     const runId = `sibyl-${compactIso(now)}-${randomBytes2(2).toString("hex")}`;
-    const runDir = join4(opts.lane.runRoot, `sibyl-run-${runId}`);
-    await mkdir2(runDir, { recursive: true });
+    const runDir = join6(opts.lane.runRoot, `sibyl-run-${runId}`);
+    await mkdir3(runDir, { recursive: true });
     const artifact = await readArtifact(args.target, context.directory);
     if (!artifact.ok) return `SIBYL review: ${artifact.error}`;
     let targetArg;
     if (artifact.kind === "inline") {
-      targetArg = join4(runDir, "target-inline.md");
-      await writeFile3(targetArg, artifact.text, "utf8");
+      targetArg = join6(runDir, "target-inline.md");
+      await writeFile4(targetArg, artifact.text, "utf8");
     } else {
       targetArg = artifact.source;
     }
-    await writeFile3(join4(runDir, "run-config.json"), `${JSON.stringify(opts, null, 2)}
+    await writeFile4(join6(runDir, "run-config.json"), `${JSON.stringify(opts, null, 2)}
 `, "utf8");
+    const independence = await assessIndependence(deps.client, context.directory, context.sessionID, artifact);
+    await writeFile4(
+      join6(runDir, "launch-context.json"),
+      `${JSON.stringify({ convenerSessionID: context.sessionID, independence }, null, 2)}
+`,
+      "utf8"
+    );
     const cmd = cliCommand(import.meta.url, nodeBinary());
     const spawnArgs = [
       ...cmd.args,
       "run",
+      "--run-id",
+      runId,
       "--target",
       targetArg,
       "--goal",
       args.goal,
       "--config",
-      join4(runDir, "run-config.json"),
+      join6(runDir, "run-config.json"),
       "--run-root",
       opts.lane.runRoot,
       "--seed",
@@ -32402,8 +32832,10 @@ async function reviewExecute(deps, args, context) {
       `  run:      ${receipt.runId}`,
       `  dir:      ${receipt.runDir}`,
       `  status:   ${receipt.statusCmd}`,
-      `  voice at: ${join4(runDir, "run-record.json")} + chamber-ledger.jsonl (append-only)`,
-      `  verify:   ${receipt.spotcheck}`
+      `  voice at: ${join6(runDir, "run-record.json")} + chamber-ledger.jsonl (append-only)`,
+      `  verify:   ${receipt.spotcheck}`,
+      `  ${rulesLabel(instrumentFace())} (the runner records its own full face into the run record)`,
+      `  ${independenceLabel(independence)}`
     ].join("\n");
   } catch (err) {
     return internalError(REVIEW_TOOL_NAME, err);
@@ -32423,7 +32855,7 @@ function buildReviewTool(deps) {
 }
 
 // src/tools/anchor.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 function canonicalView(rows) {
   return JSON.stringify(
     rows.map((r) => ({
@@ -32436,7 +32868,7 @@ function canonicalText(raw) {
   return raw.replace(/\s*<dcp-message-id[^>]*>[\s\S]*?<\/dcp-message-id>\s*$/g, "").trim();
 }
 function sha256(text) {
-  return createHash("sha256").update(text, "utf8").digest("hex");
+  return createHash2("sha256").update(text, "utf8").digest("hex");
 }
 function anchorText(row) {
   return (row.parts ?? []).filter((p) => p.type === "text").map((p) => p.text ?? "").join("\n");
@@ -32633,110 +33065,9 @@ function buildAttributeTool(deps) {
   });
 }
 
-// src/state/chamber.ts
-import { mkdir as mkdir3, readFile as readFile3, readdir, rename as rename2, unlink as unlink2, writeFile as writeFile4 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname3, isAbsolute as isAbsolute2, join as join5, resolve as resolve2 } from "node:path";
-var DEFAULT_CHAMBER_LEDGER = join5(homedir3(), ".sibyl", "chamber-ledger.jsonl");
-var TERMINAL_STATES = ["CONVERGED", "NEEDS_ROUND", "MEMBER_LOST", "TIMEOUT"];
-var RUN_PROFILES = ["review", "exam"];
-var RECORD_SCHEMA = 1;
-function asStringArray(v) {
-  return Array.isArray(v) && v.every((x) => typeof x === "string") ? [...v] : null;
-}
-function isRosterRef(v) {
-  if (typeof v !== "object" || v === null) return false;
-  const o = v;
-  const modelOk = o["policyCheck"] === "deny" ? typeof o["modelId"] === "string" : isNonEmptyString(o["modelId"]);
-  return isNonEmptyString(o["role"]) && isNonEmptyString(o["slot"]) && modelOk && (o["policyCheck"] === "allow" || o["policyCheck"] === "deny") && (o["denyReason"] === void 0 || typeof o["denyReason"] === "string");
-}
-function isArtifactRef(v) {
-  if (typeof v !== "object" || v === null) return false;
-  const o = v;
-  return isNonEmptyString(o["role"]) && typeof o["round"] === "number" && Number.isInteger(o["round"]) && o["round"] >= 0 && isNonEmptyString(o["phase"]) && isNonEmptyString(o["relPath"]) && typeof o["sha256"] === "string" && /^[0-9a-f]{64}$/.test(o["sha256"]) && typeof o["bytes"] === "number" && o["bytes"] >= 0 && isNonEmptyString(o["presentAt"]) && (o["rc"] === null || typeof o["rc"] === "number") && (o["signal"] === null || typeof o["signal"] === "string") && typeof o["timedOut"] === "boolean";
-}
-function validateChamberRecord(raw) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return { ok: false, reason: "record is not an object" };
-  const o = raw;
-  if (o["schema"] !== RECORD_SCHEMA) return { ok: false, reason: `schema must be ${RECORD_SCHEMA}` };
-  if (!isNonEmptyString(o["runId"])) return { ok: false, reason: "runId must be a non-empty string" };
-  if (typeof o["serial"] !== "number" || !Number.isInteger(o["serial"]) || o["serial"] < 1) return { ok: false, reason: "serial must be a positive integer" };
-  if (!RUN_PROFILES.includes(o["profile"])) return { ok: false, reason: `profile must be one of ${RUN_PROFILES.join("|")}` };
-  if (!isNonEmptyString(o["goal"])) return { ok: false, reason: "goal must be a non-empty string" };
-  if (typeof o["target"] !== "string") return { ok: false, reason: "target must be a string" };
-  if (!isNonEmptyString(o["runDir"]) || !isAbsolute2(o["runDir"])) return { ok: false, reason: "runDir must be an absolute path" };
-  if (!isNonEmptyString(o["createdAt"]) || Number.isNaN(Date.parse(o["createdAt"]))) return { ok: false, reason: "createdAt must be ISO" };
-  if (!isNonEmptyString(o["updatedAt"]) || Number.isNaN(Date.parse(o["updatedAt"]))) return { ok: false, reason: "updatedAt must be ISO" };
-  if (o["terminal"] !== null && !TERMINAL_STATES.includes(o["terminal"])) return { ok: false, reason: "terminal must be null or a TerminalState" };
-  if (!Array.isArray(o["roster"]) || !o["roster"].every(isRosterRef)) return { ok: false, reason: "roster must be an array of RosterRef" };
-  const judgePool = asStringArray(o["judgePool"]);
-  if (judgePool === null) return { ok: false, reason: "judgePool must be a string array" };
-  if (!isNonEmptyString(o["seed"])) return { ok: false, reason: "seed must be a non-empty string" };
-  if (typeof o["drawCommit"] !== "string" || !/^[0-9a-f]{64}$/.test(o["drawCommit"])) return { ok: false, reason: "drawCommit must be 64-hex" };
-  if (typeof o["judgeModelId"] !== "string") return { ok: false, reason: "judgeModelId must be a string" };
-  if (typeof o["rounds"] !== "number" || !Number.isInteger(o["rounds"]) || o["rounds"] < 0) return { ok: false, reason: "rounds must be a non-negative integer" };
-  if (!Array.isArray(o["artifacts"]) || !o["artifacts"].every(isArtifactRef)) return { ok: false, reason: "artifacts must be an array of ArtifactRef" };
-  if (typeof o["evidenceRows"] !== "number" || !Number.isInteger(o["evidenceRows"]) || o["evidenceRows"] < 0) return { ok: false, reason: "evidenceRows must be a non-negative integer" };
-  if (o["notes"] !== void 0 && typeof o["notes"] !== "string") return { ok: false, reason: "notes must be a string when present" };
-  const record3 = {
-    schema: RECORD_SCHEMA,
-    runId: o["runId"],
-    serial: o["serial"],
-    profile: o["profile"],
-    goal: o["goal"],
-    target: o["target"],
-    runDir: o["runDir"],
-    createdAt: o["createdAt"],
-    updatedAt: o["updatedAt"],
-    terminal: o["terminal"],
-    roster: [...o["roster"]],
-    judgePool,
-    seed: o["seed"],
-    drawCommit: o["drawCommit"],
-    judgeModelId: o["judgeModelId"],
-    rounds: o["rounds"],
-    artifacts: [...o["artifacts"]],
-    evidenceRows: o["evidenceRows"]
-  };
-  if (typeof o["notes"] === "string") record3.notes = o["notes"];
-  return { ok: true, record: record3 };
-}
-function parseLedgerLine(line) {
-  const trimmed = line.trim();
-  if (trimmed.length === 0) return { ok: false, reason: "blank line" };
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { ok: false, reason: `not a single JSON document (merged-row guard): ${msg}` };
-  }
-  const v = validateChamberRecord(parsed);
-  if (!v.ok) return { ok: false, reason: v.reason };
-  return { ok: true, record: v.record };
-}
-async function loadLedger(ledgerPath) {
-  let text;
-  try {
-    text = await readFile3(ledgerPath, "utf8");
-  } catch {
-    return { rows: [], dropped: [] };
-  }
-  const rows = [];
-  const dropped = [];
-  const lines = text.split("\n");
-  for (const [i, line] of lines.entries()) {
-    if (line.trim().length === 0) continue;
-    const v = parseLedgerLine(line);
-    if (v.ok) rows.push(v.record);
-    else dropped.push({ line: i + 1, reason: v.reason });
-  }
-  return { rows, dropped };
-}
-
 // src/tools/status.ts
 import { dirname as dirname4 } from "node:path";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var STATUS_TOOL_NAME = "sibyl_status";
 function buildStatusTool(deps) {
   return tool({
@@ -32757,7 +33088,7 @@ async function statusExecute(deps, args, _context) {
       return [`SIBYL RUN ${run2.runId}`, formatRunLine(run2)].join("\n");
     }
     const runs = await deps.store.load();
-    const ledger = await loadLedger(join6(dirname4(deps.store.runsFile), "chamber-ledger.jsonl"));
+    const ledger = await loadLedger(join7(dirname4(deps.store.runsFile), "chamber-ledger.jsonl"));
     const chamberLines = ledger.rows.slice(-5).map(
       (r) => `${r.runId} chamber/${r.profile} ${r.terminal ?? "running"} rounds=${String(r.rounds)} artifacts=${String(r.artifacts.length)} judge=${r.judgeModelId} dir=${r.runDir}`
     );
@@ -32773,8 +33104,8 @@ async function statusExecute(deps, args, _context) {
 }
 
 // src/tools/swarm.ts
-import { join as join7 } from "node:path";
-import { writeFile as writeFile5 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+import { appendFile as appendFile2, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
 
 // src/swarm/types.ts
 var SWARM_VERDICTS = {
@@ -32911,11 +33242,24 @@ function composeTaskPrompt(ctx, taskId) {
 Upstream conclusions (from completed dependencies):
 ${lines.join("\n")}`;
 }
+async function recordTerminal(ctx, taskId, workerId, status, session, detail) {
+  if (ctx.writeTerminal === void 0) return true;
+  try {
+    await ctx.writeTerminal(
+      formatTerminalRow(/* @__PURE__ */ new Date(), { task: taskId, worker: workerId, status, session, detail })
+    );
+    return true;
+  } catch (e) {
+    console.error(`[sibyl dispatch] terminal line for ${taskId} failed to write: ${describeFailure(e)}`);
+    return false;
+  }
+}
 async function runTask(ctx, task) {
   const worker = ctx.workerByTask.get(task.taskId);
   if (worker === void 0) {
     task.status = "failed";
     task.error = `no worker spec for task "${task.taskId}"`;
+    await recordTerminal(ctx, task.taskId, "-", "error", "-", task.error);
     return;
   }
   for (let attempt = 1; attempt <= ctx.maxAttempts; attempt++) {
@@ -32936,30 +33280,45 @@ async function runTask(ctx, task) {
     } catch (e) {
       task.status = "failed";
       task.error = `runPersona threw: ${describeFailure(e)}`;
+      await recordTerminal(ctx, task.taskId, worker.workerId, classifyFailure(task.error), "-", task.error);
       return;
     }
     if (result.ok) {
-      let ref;
-      try {
-        ref = await ctx.writeDraft({ taskId: task.taskId, workerId: worker.workerId, text: result.text });
-      } catch (e) {
-        task.status = "failed";
-        task.error = `draft write failed: ${describeFailure(e)}`;
+      if (result.text.trim().length === 0) {
+        task.error = "empty-reply: worker session ended with no content (absence is not a ballot)";
+      } else {
+        let ref;
+        try {
+          ref = await ctx.writeDraft({ taskId: task.taskId, workerId: worker.workerId, text: result.text });
+        } catch (e) {
+          task.status = "failed";
+          task.error = `draft write failed: ${describeFailure(e)}`;
+          await recordTerminal(ctx, task.taskId, worker.workerId, "error", result.sessionID, task.error);
+          return;
+        }
+        const recorded = await recordTerminal(ctx, task.taskId, worker.workerId, "ok", result.sessionID, `draft=${ref}`);
+        if (!recorded) {
+          task.status = "failed";
+          task.error = "terminal record write failed (W2: done without its record never stands)";
+          return;
+        }
+        task.refs.push(ref);
+        task.summary = summarizeTaskOutput(result.text, ctx.summaryMaxChars);
+        if (result.sessionID !== "") task.sessionId = result.sessionID;
+        task.status = "done";
         return;
       }
-      task.refs.push(ref);
-      task.summary = summarizeTaskOutput(result.text, ctx.summaryMaxChars);
-      if (result.sessionID !== "") task.sessionId = result.sessionID;
-      task.status = "done";
-      return;
+    } else {
+      task.error = result.error ?? "unknown engine error";
     }
-    task.error = result.error ?? "unknown engine error";
     if (isRateLimitError(task.error)) {
       task.status = "suspended";
+      await recordTerminal(ctx, task.taskId, worker.workerId, "error", "-", `suspended: ${task.error}`);
       return;
     }
   }
   task.status = "failed";
+  await recordTerminal(ctx, task.taskId, worker.workerId, classifyFailure(task.error ?? ""), "-", task.error ?? "attempts exhausted");
 }
 async function runWaves(ctx, state) {
   for (; ; ) {
@@ -32967,7 +33326,12 @@ async function runWaves(ctx, state) {
     if (schedulable.length === 0) break;
     if (state.rounds >= ctx.maxRounds) {
       state.exhausted = true;
-      for (const t of state.tasks) if (t.status === "pending") t.status = "suspended";
+      for (const t of state.tasks) {
+        if (t.status === "pending") {
+          t.status = "suspended";
+          await recordTerminal(ctx, t.taskId, ctx.workerByTask.get(t.taskId)?.workerId ?? "-", "error", "-", "exhausted: round budget spent before launch");
+        }
+      }
       break;
     }
     state.rounds += 1;
@@ -32978,9 +33342,12 @@ async function runWaves(ctx, state) {
     })());
     await Promise.all(launches);
   }
-  for (const t of state.tasks) if (t.status === "pending") {
-    t.status = "failed";
-    t.error = "blocked by non-done dependency";
+  for (const t of state.tasks) {
+    if (t.status === "pending") {
+      t.status = "failed";
+      t.error = "blocked by non-done dependency";
+      await recordTerminal(ctx, t.taskId, ctx.workerByTask.get(t.taskId)?.workerId ?? "-", "error", "-", t.error);
+    }
   }
 }
 function materialize(state) {
@@ -33028,7 +33395,8 @@ async function run(prior, roster, opts) {
       summaryMaxChars,
       maxRounds,
       clock: opts.clock ?? realClock(),
-      writeDraft: opts.writeDraft
+      writeDraft: opts.writeDraft,
+      writeTerminal: opts.writeTerminal
     };
     let state = prior ?? makeState(roster);
     if (prior !== void 0) {
@@ -33252,7 +33620,7 @@ function buildJudgeInput(report) {
     ...report.tasks.map((t) => `TASK ${t.id}: ${t.status}${t.summary === void 0 ? "" : ` \u2014 ${t.summary}`}`),
     ...report.artifacts.map((a) => `ARTIFACT: ${a}`),
     "",
-    "Respond with EXACTLY one word and nothing else: APPROVE, REJECT, or EXHAUSTED."
+    SWARM_JUDGE_WORD_CONTRACT
   ];
   return lines.join("\n");
 }
@@ -33294,6 +33662,7 @@ async function swarmExecute(deps, args, context) {
   if (!read.ok) {
     return `SIBYL swarm: ${read.error}`;
   }
+  const independence = await assessIndependence(client, directory, context.sessionID, read);
   const { record: record3 } = await store.createRun({ kind: "swarm", artifact: read.source, goal: args.goal });
   const architectModel = slotForModel(options.modelPool, void 0, PERSONAS.ARCHITECT.modelSlot);
   const plan = await planWorkflow({
@@ -33311,7 +33680,7 @@ async function swarmExecute(deps, args, context) {
         directory,
         persona: { system: PERSONAS.ARCHITECT.system },
         model: architectModel,
-        inputText: `${buildRepairDemand(why)} matching the workflow-schema contract: {"tasks":[{"id","title","instructions","dependsOn"}],"concurrency":<int >= 1>,"notes":<string>}`,
+        inputText: `${repairDemand(why)} matching the workflow-schema contract: {"tasks":[{"id","title","instructions","dependsOn"}],"concurrency":<int >= 1>,"notes":<string>}`,
         timeoutMs: options.timeoutMs,
         parentID: context.sessionID
       });
@@ -33334,7 +33703,7 @@ async function swarmExecute(deps, args, context) {
     staggerMs: options.staggerMs,
     maxRounds: options.maxRounds,
     writeDraft: async ({ taskId, workerId, text }) => {
-      const path = join7(record3.spaceDir, `${workerId}.draft.md`);
+      const path = join8(record3.spaceDir, `${workerId}.draft.md`);
       try {
         await writeFile5(path, `<!-- SIBYL swarm draft task=${taskId} worker=${workerId} -->
 ${text}
@@ -33343,7 +33712,9 @@ ${text}
       } catch (err) {
         return `<${path} write failed: ${errMessage(err)}>`;
       }
-    }
+    },
+    writeTerminal: (line) => appendFile2(join8(record3.spaceDir, "TERMINALS.txt"), `${line}
+`, "utf8")
   });
   if (!dispatch.ok) return failRun(deps, record3, { stage: "dispatch", error: dispatch.error });
   let report = buildReport({
@@ -33357,7 +33728,7 @@ ${text}
     const judged = await runPersona({
       client,
       directory,
-      persona: { system: "You are the SIBYL swarm judge. You rule on pipeline reports with exactly one word: APPROVE, REJECT, or EXHAUSTED." },
+      persona: { system: SWARM_JUDGE_SYSTEM },
       model: slotForModel(options.modelPool, options.swarm.judge, void 0),
       inputText: buildJudgeInput(report),
       timeoutMs: options.timeoutMs,
@@ -33369,23 +33740,32 @@ ${text}
   }
   const counts = countTasks(report.tasks);
   const noSignal = counts.done === 0;
-  const tag = noSignal ? "CANNOT_ANSWER" : report.verdict === "APPROVE" ? "APPROVE" : "REJECT";
+  const terminalsText = await readFile5(join8(record3.spaceDir, "TERMINALS.txt"), "utf8").catch(() => "");
+  const dead = deadWithoutRecord(
+    plan.schema.tasks.map((t) => t.id),
+    parseTerminalRows(terminalsText)
+  );
+  const tag = dead.length > 0 || noSignal ? "CANNOT_ANSWER" : report.verdict === "APPROVE" ? "APPROVE" : "REJECT";
   await finishRun(deps, record3, {
     status: "done",
     rounds: report.rounds,
+    instrument: instrumentFace(),
+    independence,
     verdict: {
       verdict: tag,
       approvals: counts.done,
-      rejects: noSignal ? 0 : tag === "REJECT" ? 1 : 0,
+      rejects: noSignal || dead.length > 0 ? 0 : tag === "REJECT" ? 1 : 0,
       errors: counts.failed,
       missing: counts.suspended
     },
-    notes: `${judgeNote}${noSignal ? " \xB7 zero drafts produced: instrument failure, not a verdict on the artifact" : ""} \xB7 ${report.tasks.map((t) => `${t.id}=${t.status}`).join(",")}`
+    notes: `${judgeNote} \xB7 independence=${independence.status}${independence.status === "NOT-INDEPENDENT" ? " (self-convoked: report preserved, not in any effective path)" : ""} \xB7 ${deadFaceCount(dead)}${dead.length > 0 ? ` (${dead.join(",")} left no terminal row: instrument wounded, not a verdict on the artifact)` : ""}${noSignal ? " \xB7 zero drafts produced: instrument failure, not a verdict on the artifact" : ""} \xB7 ${report.tasks.map((t) => `${t.id}=${t.status}`).join(",")}`
   });
   const lines = [
-    `SIBYL SWARM: ${tag} run ${record3.runId} (rounds=${String(report.rounds)} done=${String(counts.done)} failed=${String(counts.failed)} suspended=${String(counts.suspended)} ${judgeNote})`,
+    `SIBYL SWARM: ${tag} run ${record3.runId} (${deadFaceCount(dead)} rounds=${String(report.rounds)} done=${String(counts.done)} failed=${String(counts.failed)} suspended=${String(counts.suspended)} ${judgeNote})`,
+    `  ${independenceLabel(independence)}`,
     ...report.tasks.map((t) => `  task: ${t.id} ${t.status}${t.sessionId === void 0 ? "" : ` session=${t.sessionId}`}`),
     ...report.artifacts.map((a) => `  artifact: ${a}`),
+    `  ${rulesLabel(instrumentFace())} components=${String(Object.keys(instrumentFace().components).length)}`,
     `  space: ${record3.spaceDir}`,
     `  store: ${store.runsFile}`
   ];
@@ -33485,12 +33865,29 @@ function toEngineClient(sdk) {
               },
               parts: m.parts.map((p) => ({
                 type: p.type,
-                ..."text" in p && p.text !== void 0 && { text: p.text }
+                ..."text" in p && p.text !== void 0 && { text: p.text },
+                // W1 drafting-evidence read: tool name + input bag of tool parts
+                ...p.type === "tool" && {
+                  tool: p.tool,
+                  ...p.state.input !== void 0 && { input: p.state.input }
+                }
               }))
             }))
           },
           ...r.error !== void 0 && { error: r.error }
         };
+      },
+      async get(args) {
+        const r = await sdk.session.get(args);
+        return {
+          ...r.data !== void 0 && {
+            data: {
+              ...r.data.id !== void 0 && { id: r.data.id },
+              ...r.data.parentID !== void 0 && { parentID: r.data.parentID }
+            }
+          },
+          ...r.error !== void 0 && { error: r.error }
+        };
       }
     }
   };