sibyl-system 1.1.0 → 1.2.1

package/README.md

@@ -2,17 +2,32 @@
 
 [![npm version](https://img.shields.io/npm/v/sibyl-system.svg)](https://www.npmjs.com/package/sibyl-system) ![license MIT](https://img.shields.io/badge/license-MIT-green.svg)
 
-A standalone [opencode](https://opencode.ai) plugin with two capabilities:
+A standalone [opencode](https://opencode.ai) plugin:
 
 - **`sibyl_consult`** — a three-voter review council (MELCHIOR / BALTHASAR / CASPER)
   that audits an artifact against a goal and returns a **fail-closed 2/3 verdict**.
 - **`sibyl_swarm`** — a lightweight workflow swarm: an ARCHITECT persona plans a
   dependency-ordered task graph, deterministic workers execute it in waves, and
   the result is aggregated into a verdict.
+- **`sibyl_review` / `sibyl-chamber`** (v1.1) — a general review chamber with
+  isolated role sessions and one conclusion spoken in one voice (see below).
+- **`sibyl_status` + audit primitives** (`sibyl_anchor_check`, `sibyl_time_probe`,
+  `sibyl_attribute`) — read-only verification tools: run-store view, human-message
+  anchor re-verification, clock integrity, ref-move attribution.
 
 Zero coupling to team-mode or fleet orchestration: no `team_*` tools, no
 cross-agent message bus. Everything runs through plain opencode child sessions.
 
+## Session hygiene (L1)
+
+Council voters, swarm workers and the swarm judge run as **child sessions of the
+calling session** (`parentID` from the tool context): the TUI session picker
+lists root sessions only, so no sibyl ballot ever clutters your top-level
+session list. Transcripts stay in the DB, reachable from the parent session and
+mirrored into the run's sealed reply files. An empty caller session falls back
+to top-level creation. `sibyl_review` roles run fully isolated under /tmp with
+their own HOME/DB (`src/lane/isolated.ts`), never touching yours.
+
 ## v1.1 — the review chamber (民主集中制)
 
 `sibyl_review` + `sibyl-chamber` is a GENERAL review apparatus: any artifact
@@ -26,7 +41,7 @@ spotcheckable (`sha256sum -c CHECKSUMS.txt`) and append-only-ledgered.
 Laws: docs/isolation-laws.md. Mechanism: docs/democratic-centralism.md.
 
 ```
-node dist/cli.js run --target doc.md --goal "Is this sound?" --model local-qwen/qwen3.8-flash-next
+node dist/cli.js run --target doc.md --goal "Is this sound?" --model your-provider/your-model
 node dist/cli.js status --tail 5
 node dist/cli.js spotcheck <runId>
 ```
@@ -82,6 +97,9 @@ stderr, registers nothing, and returns empty hooks.
 | `sibyl_swarm` | `{ artifact, goal, judge? }` | ARCHITECT decomposes goal + artifact into a strict-JSON workflow schema; workers are minted deterministically and dispatched in dependency waves; drafts land in the run's space dir. Verdict: `APPROVE` / `REJECT` / `EXHAUSTED`. With `judge: true`, one extra judge pass may replace the derived verdict — an unrecognized or failed judge reply keeps the derived one. |
 | `sibyl_status` | `{ runId? }` | Read-only. Lists all recorded runs (newest last) + the last chamber-ledger rows, or shows one run's full record and space dir. |
 | `sibyl_review` | `{ target, goal, seed?, maxRounds? }` | v1.1 general democratic-centralism chamber: launches the isolated evidence→clash→judge pipeline detached and returns a receipt (explicitly NOT a verdict); the single voice lands in the run record at terminal state. CLI twin: `sibyl-chamber`. |
+| `sibyl_anchor_check` | `{ sessionId, index?, body?, expectSha256?, label? }` | Read-only verifier for "human anchor" claims (an order/approval message the owner says they sent): re-checks the claim against the engine's own session store instead of trusting a transcribed string. Closed 4-state verdict `MATCH` / `MISMATCH` / `ABSENT` / `ERROR`; the receipt carries a hash of the canonical view read, so later store mutation shows up as a view-hash difference. No `expectSha256` claim → non-verdict. |
+| `sibyl_time_probe` | `{ endpoints?, toleranceMs? }` | Clock-integrity check against independent HTTP `Date` headers (default pool: cloudflare / google / mozilla; sources with the same owner dept collapse to ONE source). Verdict: `SYNCED` / `DRIFT` / `INSUFFICIENT-SOURCES` (< 2 distinct owners is never consent). Default tolerance 300000 ms. Reads remote endpoints; sends no data beyond a HEAD request. |
+| `sibyl_attribute` | `{ moves, commits, roster }` | Pure comparator (zero network/git of its own): attributes git ref-moves to committer identities against a roster. Per-move verdict: `ATTRIBUTED` / `UNATTRIBUTED` (the silent-egress case) / `AMBIGUOUS` (byte-equal roster pair = registry defect, blocks, never picks). Identity matching is byte-exact by design — no normalization. |
 
 ## Options
 
@@ -101,6 +119,24 @@ defaults.
 | `timeoutMs` | `240000` | Per-child-session timeout (create + prompt share the budget). Integer ≥ 1. |
 | `concurrencyK` | `4` | Cap on parallel workers per wave (also capped by the schema's own `concurrency`). Integer 1–8. |
 | `staggerMs` | `2000` | Delay between worker launches within a wave, to avoid rate-limit bursts. Integer ≥ 0. |
+| `lane` | see below | v1.1 isolated-lane mechanics for `sibyl_review` / `sibyl-chamber` (`src/lane/isolated.ts`). Sub-keys: `runRoot` (string, default `"/tmp"`) — parent dir for run dirs; `opencodeBin` (non-empty string; discovery order: `$OPENCODE_BIN` → `~/.local/bin/opencode` → `/usr/local/bin/opencode` → `/usr/bin/opencode` → bare PATH name `"opencode"`; never empty, a wrong guess fails loud at spawn naming the bin) — the binary launched for each isolated role; `configSource` (default `~/.config/opencode/opencode.jsonc`) — **read-copied** into each role home, never written back; `roleTimeoutMs` (integer ≥ 5000, default `600000`) — per-role wall-clock budget. |
+| `modelPolicy` | `{ allowedPrefixes: ["local-"] }` | v1.1 E4/F1 seating allow-list: only pool models whose `providerID/modelID` starts with one of these prefixes may take a seat; everything else is denied at launch. Array of non-empty strings, **at least 1 entry** (an empty list is rejected as a deny-everything typo). Set this to your own machine's providers — the shipped default is a prefix pattern, not a specific model. |
+| `chamber` | see below | v1.1 review-chamber seats and rounds. Sub-keys: `maxRounds` (integer 1–8, default `3`) — clash/cross-critique round cap; `roles` (`{ evidence, pro, con, judge }` → pool slot names, each default `"default"`); `judgePool` (non-empty array of slot names, default `["default"]`) — the slots the independent judge may be drawn from (E2 pool+seed committed before launch). |
+
+### Portability (release principle)
+
+The published package pins **no device-side model authorizations**: the only
+model defaults shipped are empty-string sentinels (= "host default") and the
+generic `local-` seating prefix. Concrete provider/model ids live exclusively
+in **your** config — the registration tuple's options object (per-operator
+`modelPool` / `modelPolicy` / `--model` flag). Operators on shared fleets
+conventionally keep the concrete values in an operator-local file (e.g.
+`operator/release.env`, key `HISTORIAN_TRANSLATE_MODEL=<provider/model>`) that
+their own shell/opencode config feeds into that options object at registration
+time; that file sits outside the package boundary — `package.json` `files`
+ships only `dist/`, `README.md`, `LICENSE`, and ship.sh gate 5a fails the
+release if anything else appears in the tarball. `./ship.sh` additionally
+fails the release if any vendor model id reappears on a shipped surface.
 
 ## State layout
 
@@ -140,7 +176,7 @@ Dependencies point downward only:
 
 ```
 index.ts            plugin entry: parse options → share one RunStore + client
-                    adapter → register the three tools
+                    adapter → register the seven sibyl_* tools
 ├── engine/         runPersona(): create + prompt one child session through a
 │                   structural client seam; per-stage timeouts; never throws —
 │                   every failure is a structured PersonaRunResult
@@ -166,6 +202,7 @@ index.ts            plugin entry: parse options → share one RunStore + client
 ├── options.ts      zod v4 schema + parseOptions (never throws)
 ├── cli.ts          v1.1 sibyl-chamber bin: run | status | spotcheck | kill
 └── tools/          sibyl_consult / sibyl_swarm / sibyl_status / sibyl_review
+                    + audit primitives (anchor / time probe / attribution)
                     glue + shared helpers (model-slot chain, artifact reader)
 ```
 
@@ -181,9 +218,10 @@ PLAN→MINT→DISPATCH→AGGREGATE pipeline over ordinary child sessions.
 
 ```bash
 npm run typecheck   # tsc --noEmit, strict + noUncheckedIndexedAccess + exactOptionalPropertyTypes
-npm run test        # 309 unit tests, fully offline (no network, no LLM)
-npm run build       # esbuild bundle → dist/index.js (ESM)
+npm test            # 346 unit tests, fully offline (no network, no LLM)
+npm run build       # esbuild bundle → dist/index.js + dist/cli.js (ESM)
 node smoke/run-smoke.mjs   # offline smoke of the shipped surface (see smoke/README.md)
+./ship.sh           # the full release gate: all of the above + portability scan of the packed tarball
 ```
 
 Live end-to-end evidence (real opencode, real model sessions):

package/dist/cli.js

@@ -8,8 +8,8 @@ var __export = (target, all) => {
 // src/cli.ts
 import { randomBytes } from "node:crypto";
 import { spawn as spawn2 } from "node:child_process";
-import { copyFile as copyFile2, mkdir as mkdir5, readFile as readFile5 } from "node:fs/promises";
-import { basename, dirname as dirname3, isAbsolute as isAbsolute2, join as join6, resolve as resolve2 } from "node:path";
+import { copyFile as copyFile2, mkdir as mkdir6, readFile as readFile6 } from "node:fs/promises";
+import { basename, dirname as dirname4, isAbsolute as isAbsolute2, join as join7, resolve as resolve2 } from "node:path";
 
 // src/state/record.ts
 function isNonEmptyString(v) {
@@ -54,7 +54,8 @@ function asStringArray(v) {
 function isRosterRef(v) {
   if (typeof v !== "object" || v === null) return false;
   const o = v;
-  return isNonEmptyString(o["role"]) && isNonEmptyString(o["slot"]) && isNonEmptyString(o["modelId"]) && (o["policyCheck"] === "allow" || o["policyCheck"] === "deny") && (o["denyReason"] === void 0 || typeof o["denyReason"] === "string");
+  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;
@@ -873,7 +874,7 @@ async function collectSessionDb(cfg, role) {
 
 // src/exam/scenario.ts
 import { mkdtemp, readFile as readFile4, stat, writeFile as writeFile4 } from "node:fs/promises";
-var SIGNAL_KINDS = ["order", "absent", "disk", "text"];
+var SIGNAL_KINDS = ["order", "absent", "disk", "text", "consistency"];
 var ID_RE = /^[a-z0-9][a-z0-9-]*$/;
 function isStringArray(v) {
   return Array.isArray(v) && v.every((x) => typeof x === "string");
@@ -883,8 +884,8 @@ function validateSignal(raw) {
   const o = raw;
   if (typeof o["id"] !== "string" || !ID_RE.test(o["id"])) return `signal id invalid: ${String(o["id"])}`;
   if (!SIGNAL_KINDS.includes(String(o["kind"]))) return `signal ${o["id"]}: kind must be one of ${SIGNAL_KINDS.join("|")}`;
-  if (typeof o["pattern"] !== "string") return `signal ${o["id"]}: pattern must be a string`;
-  if (o["pattern"].length > 0) {
+  if (typeof o["pattern"] !== "string" && o["kind"] !== "consistency") return `signal ${o["id"]}: pattern must be a string`;
+  if (typeof o["pattern"] === "string" && o["pattern"].length > 0) {
     try {
       new RegExp(o["pattern"]);
     } catch (e) {
@@ -892,6 +893,11 @@ function validateSignal(raw) {
     }
   }
   if (o["forbidAfter"] !== void 0 && typeof o["forbidAfter"] !== "string") return `signal ${o["id"]}: forbidAfter must be string`;
+  if (o["kind"] === "consistency") {
+    for (const f of ["claimPath", "claim", "contradictionPath", "contradiction"]) {
+      if (typeof o[f] !== "string" || o[f].length === 0) return `signal ${o["id"]}: consistency kind needs ${f}`;
+    }
+  }
   if (o["kind"] === "disk") {
     if (typeof o["path"] !== "string" || o["path"].length === 0) return `signal ${o["id"]}: disk kind needs path`;
     if (typeof o["contains"] !== "string") return `signal ${o["id"]}: disk kind needs contains`;
@@ -1015,6 +1021,18 @@ function gradeText(spec, turns) {
   const re = regexOr(spec.pattern);
   return re.test(finalText(turns)) ? { id: spec.id, verdict: "PASS", evidence: "final text matches" } : { id: spec.id, verdict: "FAIL", evidence: `final text lacks the required behavior \u2014 ${spec.note}` };
 }
+async function gradeConsistency(spec, fixtureDir) {
+  const expand = (raw) => raw.replace("{fixtures}", fixtureDir);
+  const claimAbs = expand(spec.claimPath ?? "");
+  const contraAbs = expand(spec.contradictionPath ?? "");
+  const [a, b] = await Promise.all([diskProbe(claimAbs), diskProbe(contraAbs)]);
+  if (!a.exists) return { id: spec.id, verdict: "FAIL", evidence: `consistency probe: ${claimAbs} does not exist \u2014 ${spec.note}` };
+  const claimRe = new RegExp(spec.claim ?? "", "i");
+  const contraRe = new RegExp(spec.contradiction ?? "", "");
+  const claimHit = claimRe.test(a.text);
+  const contraHit = b.exists && contraRe.test(b.text);
+  return claimHit && contraHit ? { id: spec.id, verdict: "FAIL", evidence: `contradiction: ${claimAbs} asserts completion while ${contraAbs} still carries the pinned state \u2014 ${spec.note}` } : { id: spec.id, verdict: "PASS", evidence: claimHit ? "claim present without contradiction (matches disk)" : "no completion claim made \u2014 nothing to contradict" };
+}
 async function gradeDisk(spec, fixtureDir) {
   if (typeof spec.path !== "string" || typeof spec.contains !== "string") {
     return { id: spec.id, verdict: "NEEDS_HUMAN", evidence: "disk signal missing path/contains" };
@@ -1034,6 +1052,8 @@ async function gradeSignal(spec, turns, fixtureDir) {
       return gradeText(spec, turns);
     case "disk":
       return await gradeDisk(spec, fixtureDir);
+    case "consistency":
+      return await gradeConsistency(spec, fixtureDir);
     default: {
       const exhaustive = spec.kind;
       return { id: spec.id, verdict: "NEEDS_HUMAN", evidence: `unknown kind ${String(exhaustive)}` };
@@ -1091,10 +1111,49 @@ async function runExamScenario(scenario, runDir, driver) {
   };
 }
 
+// src/exam/bell.ts
+import { mkdtemp as mkdtemp2, mkdir as mkdir5, writeFile as writeFile6, readFile as readFile5 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname as dirname3, join as join5 } from "node:path";
+function bellPathFor(scenarioPath) {
+  return scenarioPath.replace(/\.json$/, ".bell.json");
+}
+async function runBell(scenarioPath) {
+  const bellRaw = await readFile5(bellPathFor(scenarioPath), "utf8").catch(() => null);
+  if (bellRaw === null) return { ok: false, detail: "no bell sidecar (ruler untested \u2014 refusal by default)" };
+  let bell;
+  try {
+    bell = JSON.parse(bellRaw);
+  } catch (e) {
+    return { ok: false, detail: `bell sidecar unparseable: ${String(e).slice(0, 120)}` };
+  }
+  const spec = parseScenario(await readFile5(scenarioPath, "utf8"));
+  if (!spec.ok) return { ok: false, detail: `scenario invalid: ${JSON.stringify(spec.errors).slice(0, 200)}` };
+  const hasHonest = bell.phases.some((p) => p.name === "honest" && p.expect === "PASS");
+  const hasDirty = bell.phases.some((p) => p.expect === "FAIL");
+  if (!hasHonest || !hasDirty) return { ok: false, detail: "bell needs >=1 honest(PASS) and >=1 dirty(FAIL) phase" };
+  const lines = [];
+  for (const ph of bell.phases) {
+    const dir = await mkdtemp2(join5(tmpdir(), `bell-${ph.name}-`));
+    const fx = join5(dir, "fixtures");
+    for (const [rel, content] of Object.entries(ph.fixtures)) {
+      const abs = join5(fx, rel);
+      await mkdir5(dirname3(abs), { recursive: true });
+      await writeFile6(abs, content, "utf8");
+    }
+    const turns = ph.turns.map((g2) => g2.map((l) => l.replaceAll("{F}", fx)).join("\n"));
+    const g = await gradeScenario(spec.scenario, turns, fx);
+    const hit = g.verdict === ph.expect;
+    lines.push(`${ph.name}: ${g.verdict} (expect ${ph.expect}) ${hit ? "OK" : "MISMATCH"}`);
+    if (!hit) return { ok: false, detail: lines.join("; ") };
+  }
+  return { ok: true, detail: lines.join("; ") };
+}
+
 // src/options.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -20005,7 +20064,7 @@ var pluginOptionsSchema = external_exports.object({
   lane: external_exports.object({
     runRoot: external_exports.string().min(1).default("/tmp"),
     opencodeBin: external_exports.string().min(1).prefault(discoverOpencodeBin),
-    configSource: external_exports.string().prefault(() => join5(homedir2(), ".config", "opencode", "opencode.jsonc")),
+    configSource: external_exports.string().prefault(() => join6(homedir2(), ".config", "opencode", "opencode.jsonc")),
     roleTimeoutMs: external_exports.number().int().min(5e3).default(6e5)
   }).prefault({}),
   /** v1.1 E4/F1: seats only from allowed model-id prefixes; deny at launch. */
@@ -20034,17 +20093,18 @@ function describeError(err) {
 }
 function discoverOpencodeBin() {
   const candidates = [
-    join5(homedir2(), ".local", "bin", "opencode"),
+    process.env["OPENCODE_BIN"] ?? "",
+    join6(homedir2(), ".local", "bin", "opencode"),
     "/usr/local/bin/opencode",
     "/usr/bin/opencode"
   ];
   for (const c of candidates) {
     try {
-      if (existsSync2(c)) return c;
+      if (c.length > 0 && existsSync2(c)) return c;
     } catch {
     }
   }
-  return "";
+  return "opencode";
 }
 function parseOptions(raw) {
   const input2 = raw === void 0 ? {} : raw;
@@ -20096,7 +20156,7 @@ async function resolveRun(flags) {
   if (typeof flags["config"] === "string") {
     let raw;
     try {
-      raw = JSON.parse(await readFile5(flags["config"], "utf8"));
+      raw = JSON.parse(await readFile6(flags["config"], "utf8"));
     } catch (e) {
       return { ok: false, error: `--config unreadable: ${e instanceof Error ? e.message : String(e)}` };
     }
@@ -20106,8 +20166,10 @@ async function resolveRun(flags) {
   }
   const laneCfg = {
     runRoot: typeof flags["run-root"] === "string" ? flags["run-root"] : opts?.lane.runRoot ?? "/tmp",
-    opencodeBin: opts?.lane.opencodeBin ?? "",
-    configSource: opts?.lane.configSource ?? ""
+    // empty bin crashed spawn with ERR_INVALID_ARG_VALUE (exam-venue injury, 2026-10-03);
+    // resolution order: flag -> config -> env -> PATH name (spawn resolves bare names).
+    opencodeBin: typeof flags["opencode-bin"] === "string" ? flags["opencode-bin"] : (opts?.lane.opencodeBin ?? "").length > 0 ? opts.lane.opencodeBin : (process.env["OPENCODE_BIN"] ?? "").length > 0 ? process.env["OPENCODE_BIN"] : "opencode",
+    configSource: typeof flags["config-source"] === "string" ? flags["config-source"] : opts?.lane.configSource ?? ""
   };
   const modelFlag = typeof flags["model"] === "string" ? flags["model"] : null;
   const pool = opts?.modelPool ?? { default: { providerID: "", modelID: "" } };
@@ -20131,13 +20193,13 @@ async function resolveRun(flags) {
   }
   const now = /* @__PURE__ */ new Date();
   const runId = `sibyl-${compactIso(now)}-${randomBytes(2).toString("hex")}`;
-  const runDir = join6(laneCfg.runRoot, `sibyl-run-${runId}`);
-  await mkdir5(runDir, { recursive: true });
+  const runDir = join7(laneCfg.runRoot, `sibyl-run-${runId}`);
+  await mkdir6(runDir, { recursive: true });
   let targetPath = targetRaw;
   if (targetRaw !== "-") {
     const abs = isAbsolute2(targetRaw) ? targetRaw : resolve2(process.cwd(), targetRaw);
-    targetPath = join6(runDir, "target", basename(abs));
-    await mkdir5(dirname3(targetPath), { recursive: true });
+    targetPath = join7(runDir, "target", basename(abs));
+    await mkdir6(dirname4(targetPath), { recursive: true });
     try {
       await copyFile2(abs, targetPath);
     } catch (e) {
@@ -20158,7 +20220,7 @@ async function resolveRun(flags) {
     const list = typeof scenarioPaths === "string" ? [scenarioPaths] : [];
     const scenarios = [];
     for (const p of list) {
-      const v = parseScenario(await readFile5(p, "utf8"));
+      const v = parseScenario(await readFile6(p, "utf8"));
       if (!v.ok) return { ok: false, error: `scenario ${p}: ${v.errors.join("; ")}` };
       scenarios.push(v.scenario);
     }
@@ -20234,7 +20296,7 @@ function makeExamDriver(laneCfgBase, runDir, modelId, timeoutMs) {
       pure: true,
       ...resume !== void 0 && { resumeSession: resume }
     });
-    const transcript = await readFile5(o.transcriptPath, "utf8").catch(() => "");
+    const transcript = await readFile6(o.transcriptPath, "utf8").catch(() => "");
     return { facts: { ok: o.ok, rc: o.rc, signal: o.signal, timedOut: o.timedOut }, transcript, sessionId: o.sessionId };
   };
   return {
@@ -20277,7 +20339,7 @@ async function main(argv) {
   if (cmd === "spotcheck") {
     const arg = rest[0];
     if (arg === void 0) return usage();
-    const runDir = arg.startsWith("/") ? arg : join6("/tmp", `sibyl-run-${arg}`);
+    const runDir = arg.startsWith("/") ? arg : join7("/tmp", `sibyl-run-${arg}`);
     console.log(spotcheckCommand(runDir));
     return 0;
   }
@@ -20321,6 +20383,17 @@ async function main(argv) {
     if (run.exam !== null) {
       const driver = makeExamDriver(run.laneCfg, run.runDir, run.exam.modelId, run.timeoutMs);
       const results = [];
+      const scPaths = typeof flags["scenario"] === "string" ? [flags["scenario"]] : [];
+      if (flags["allow-unbellied"] !== true) {
+        for (const sp of scPaths) {
+          const b = await runBell(sp);
+          if (!b.ok) {
+            console.log(`SIBYL REFUSE \u2014 bell preflight failed for ${sp}: ${b.detail}`);
+            return 1;
+          }
+          console.log(`bell preflight OK: ${sp} \u2014 ${b.detail}`);
+        }
+      }
       for (const sc of run.exam.scenarios) results.push(await runExamScenario(sc, run.runDir, driver));
       console.log(examVoice(results, run.runId, run.runDir));
       return 0;
@@ -20331,7 +20404,7 @@ async function main(argv) {
 }
 function usage() {
   console.log(
-    "usage: sibyl-chamber run --target <path|-> --goal <text> [--profile review|exam] [--scenario f.json ...]\n                     [--model p/m] [--judge-pool id,id] [--seed s] [--max-rounds n] [--config json] [--detach]\n                     [--kill-role <r> --kill-after <ms>]\n       sibyl-chamber status [--run-id <id>] [--tail n]\n       sibyl-chamber spotcheck <runDir|runId>\n       sibyl-chamber kill <runDir> <role>"
+    "usage: sibyl-chamber run --target <path|-> --goal <text> [--profile review|exam] [--scenario f.json ...]\n                     [--model p/m] [--judge-pool id,id] [--seed s] [--max-rounds n] [--config json] [--detach]\n                     [--kill-role <r> --kill-after <ms>] [--opencode-bin <path> --config-source <jsonc>]\n       sibyl-chamber status [--run-id <id>] [--tail n]\n       sibyl-chamber spotcheck <runDir|runId>\n       sibyl-chamber kill <runDir> <role>"
   );
   return 2;
 }

package/dist/index.js

@@ -18947,17 +18947,18 @@ function describeError(err) {
 }
 function discoverOpencodeBin() {
   const candidates = [
+    process.env["OPENCODE_BIN"] ?? "",
     join(homedir(), ".local", "bin", "opencode"),
     "/usr/local/bin/opencode",
     "/usr/bin/opencode"
   ];
   for (const c of candidates) {
     try {
-      if (existsSync(c)) return c;
+      if (c.length > 0 && existsSync(c)) return c;
     } catch {
     }
   }
-  return "";
+  return "opencode";
 }
 function parseOptions(raw) {
   const input2 = raw === void 0 ? {} : raw;
@@ -18985,7 +18986,7 @@ 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 VERDICT_TAGS = ["APPROVE", "REJECT"];
+var VERDICT_TAGS = ["APPROVE", "REJECT", "CANNOT_ANSWER"];
 function oneOf(v, opts) {
   return opts.some((o) => o === v);
 }
@@ -31708,20 +31709,26 @@ function dedupePreserveOrder(entries) {
 function runPolicy(votes, policyName, canApprove) {
   const observed = inspect(votes);
   const issue3 = structuralIssue(votes);
-  const approve = issue3 === null && canApprove(observed);
+  const allSubstantive = observed.errors === 0 && observed.missing === 0;
+  const outcome = issue3 !== null ? "REJECT" : canApprove(observed) ? "APPROVE" : allSubstantive || observed.rejects >= 2 ? "REJECT" : "CANNOT_ANSWER";
   const reasons = [];
   if (issue3 !== null) {
     reasons.push(issue3);
   }
   reasons.push(...observed.notes);
-  if (!approve) {
+  if (outcome === "REJECT" && issue3 === null) {
     reasons.push(
       `policy ${policyName} did not reach approval: ${observed.approvals}/${COUNCIL_SIZE} approvals, ${observed.errors} error, ${observed.missing} missing (fail-closed REJECT)`
     );
   }
+  if (outcome === "CANNOT_ANSWER") {
+    reasons.push(
+      `policy ${policyName} could not answer: ${observed.errors} error + ${observed.missing} missing ballot(s) leave no decision (quorum broken) \u2014 NOT a substantive reject; repair the infra (see run notes) and re-run`
+    );
+  }
   reasons.push(...dedupePreserveOrder(observed.reasons));
   return {
-    verdict: approve ? "APPROVE" : "REJECT",
+    verdict: outcome,
     approvals: observed.approvals,
     rejects: observed.rejects,
     errors: observed.errors,
@@ -31766,8 +31773,33 @@ function describeError2(e) {
     return String(e);
   }
 }
+var DEFAULT_SALVAGE_POLL_MS = 5e3;
+var SALVAGE_ELIGIBLE_PROMPT_FAILURE = /timeout|fetch failed|ECONNRESET|ECONNREFUSED|ETIMEDOUT|socket hang up|UND_ERR_/i;
+async function salvageAfterPromptTimeout(client, directory, sessionID, graceMs, pollMs) {
+  const messages = client.session.messages;
+  if (!messages || graceMs <= 0) return null;
+  const t0 = Date.now();
+  while (Date.now() - t0 < graceMs) {
+    await new Promise((resolve3) => setTimeout(resolve3, pollMs));
+    const res = await messages.call(client.session, {
+      path: { id: sessionID },
+      query: { directory }
+    });
+    if (res.error !== void 0) return { kind: "error", error: describeError2(res.error) };
+    const lastAssistant = (res.data ?? []).filter((m) => m.info?.role === "assistant").at(-1);
+    const info = lastAssistant?.info;
+    if (!info) continue;
+    if (info.error !== void 0) return { kind: "error", error: describeError2(info.error) };
+    if (typeof info.time?.completed === "number") {
+      const text = (lastAssistant?.parts ?? []).filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+      const modelApplied = info.providerID && info.modelID ? `${info.providerID}/${info.modelID}` : null;
+      return { kind: "ballot", text, modelApplied };
+    }
+  }
+  return null;
+}
 async function runPersona(opts) {
-  const { client, directory, persona, model, inputText } = opts;
+  const { client, directory, persona, model, inputText, parentID } = opts;
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
   const t0 = Date.now();
   let stage = "exception";
@@ -31784,7 +31816,10 @@ async function runPersona(opts) {
     stage = "create";
     const created = await withTimeout(
       client.session.create({
-        body: { title: `sibyl:${persona.agent ?? "persona"}` },
+        body: {
+          title: `sibyl:${persona.agent ?? "persona"}`,
+          ...parentID !== void 0 && parentID.length > 0 && { parentID }
+        },
         query: { directory }
       }),
       timeoutMs,
@@ -31798,27 +31833,62 @@ async function runPersona(opts) {
     const tools = Object.fromEntries(
       (persona.disallowedTools ?? DEFAULT_DISALLOWED_TOOLS).map((name) => [name, false])
     );
-    const prompted = await withTimeout(
-      client.session.prompt({
-        path: { id: sessionID },
-        body: {
-          model,
-          ...persona.agent !== void 0 && { agent: persona.agent },
-          ...persona.system !== void 0 && { system: persona.system },
-          tools,
-          parts: [{ type: "text", text: inputText }]
-        },
-        query: { directory }
-      }),
-      remainingMs,
-      "session.prompt"
-    );
+    const raceExpiredAt = Date.now();
+    let prompted;
+    try {
+      prompted = await withTimeout(
+        client.session.prompt({
+          path: { id: sessionID },
+          body: {
+            model,
+            ...persona.agent !== void 0 && { agent: persona.agent },
+            ...persona.system !== void 0 && { system: persona.system },
+            tools,
+            parts: [{ type: "text", text: inputText }]
+          },
+          query: { directory }
+        }),
+        remainingMs,
+        "session.prompt"
+      );
+    } catch (e) {
+      const promptFailure = e instanceof Error ? e.message : describeError2(e);
+      if (!SALVAGE_ELIGIBLE_PROMPT_FAILURE.test(promptFailure)) throw e;
+      const graceMs = opts.salvageMs ?? timeoutMs;
+      const outcome = await salvageAfterPromptTimeout(
+        client,
+        directory,
+        sessionID,
+        graceMs,
+        opts.salvagePollMs ?? DEFAULT_SALVAGE_POLL_MS
+      );
+      if (!outcome) return fail(promptFailure);
+      if (outcome.kind === "error") {
+        return fail(`${promptFailure}; salvage read failed: ${outcome.error}`);
+      }
+      return {
+        text: outcome.text,
+        ok: true,
+        latencyMs: Date.now() - t0,
+        sessionID,
+        modelApplied: outcome.modelApplied,
+        salvaged: true,
+        salvageExtraMs: Date.now() - raceExpiredAt
+      };
+    }
     if (prompted.error) return fail(describeError2(prompted.error));
     if (!prompted.data) return fail("session.prompt: response missing data payload");
     const info = prompted.data.info;
     if (info?.error) return fail(describeError2(info.error));
     const modelApplied = info?.providerID && info?.modelID ? `${info.providerID}/${info.modelID}` : null;
     const text = (prompted.data.parts ?? []).filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+    const headless = parentID === void 0 || parentID.length === 0;
+    if (headless && client.session.delete !== void 0) {
+      try {
+        await client.session.delete({ path: { id: sessionID } });
+      } catch {
+      }
+    }
     return { text, ok: true, latencyMs: Date.now() - t0, sessionID, modelApplied };
   } catch (e) {
     return fail(e instanceof Error ? e.message : describeError2(e));
@@ -32156,7 +32226,7 @@ ${meta3}
 }
 async function castVote(job) {
   const { deps, id } = job;
-  const { directory, spaceDir, goal, artifactText } = job;
+  const { directory, spaceDir, goal, artifactText, parentID } = job;
   const { client, options } = deps;
   const persona = PERSONAS[id];
   const model = slotForModel(options.modelPool, options.voters[id], persona.modelSlot);
@@ -32167,7 +32237,8 @@ async function castVote(job) {
     persona: { system: persona.system },
     model,
     inputText: buildConsultInput(goal, artifactText),
-    timeoutMs: options.timeoutMs
+    timeoutMs: options.timeoutMs,
+    parentID
   });
   if (!result.ok) {
     const error105 = `${result.stage ?? "engine"}: ${result.error ?? "unknown error"}`;
@@ -32186,8 +32257,9 @@ async function castVote(job) {
     );
     return followed.ok ? followed.text : "";
   });
-  const vote = { id, ok: true, verdict };
-  const meta3 = `ballot: ${verdict.verdict} (confidence ${String(verdict.confidence)}) \xB7 session ${result.sessionID} \xB7 model ${result.modelApplied ?? "host-picked"} \xB7 ${String(result.latencyMs)}ms` + (verdict.reasons[0]?.startsWith("verdict-unparseable") ? "\nnote: reply did not parse; fail-closed REJECT" : "");
+  const unparseable = verdict.reasons[0]?.startsWith("verdict-unparseable") ?? false;
+  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 };
 }
@@ -32201,7 +32273,7 @@ async function safeWrite(path, text) {
 }
 function buildConsultTool(deps) {
   return tool({
-    description: "SIBYL council consult: audit an artifact (file path or inline multi-line text, max 256 KiB) with the three councilor personas (MELCHIOR/BALTHASAR/CASPER) in parallel and return the fail-closed 2/3 verdict plus reasons, must-fix items, run id, and per-voter reply files.",
+    description: "SIBYL council consult: audit an artifact (file path or inline multi-line text, max 256 KiB) with the three councilor personas (MELCHIOR/BALTHASAR/CASPER) in parallel and return the fail-closed 2/3 verdict (APPROVE / REJECT / CANNOT_ANSWER when error or missing seats left no decision) plus reasons, must-fix items, run id, and per-voter reply files.",
     args: {
       artifact: tool.schema.string().min(1).describe("Path to the artifact, or its inline content (multi-line)."),
       goal: tool.schema.string().min(1).describe("What the artifact is supposed to achieve.")
@@ -32227,7 +32299,7 @@ async function consultExecute(deps, args, context) {
   });
   const outcomes = await Promise.all(
     COUNCILORS.map(
-      (id) => castVote({ deps, directory: context.directory, spaceDir: record3.spaceDir, goal: args.goal, artifactText: read.text, id })
+      (id) => castVote({ deps, directory: context.directory, spaceDir: record3.spaceDir, goal: args.goal, artifactText: read.text, id, parentID: context.sessionID })
     )
   );
   const tally = tallyVotes(outcomes.map((o) => o.vote));
@@ -32350,6 +32422,217 @@ function buildReviewTool(deps) {
   });
 }
 
+// src/tools/anchor.ts
+import { createHash } from "node:crypto";
+function canonicalView(rows) {
+  return JSON.stringify(
+    rows.map((r) => ({
+      role: r.info?.role ?? null,
+      parts: (r.parts ?? []).map((p) => ({ t: p.type, x: p.text ?? "" }))
+    }))
+  );
+}
+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");
+}
+function anchorText(row) {
+  return (row.parts ?? []).filter((p) => p.type === "text").map((p) => p.text ?? "").join("\n");
+}
+function decide(row, expected) {
+  if (row === void 0) return { verdict: "ABSENT", text: "" };
+  if (expected === void 0) return { verdict: "ABSENT", text: anchorText(row) };
+  const text = anchorText(row);
+  const normalized = expected.trim().toLowerCase();
+  if (canonicalText(text) === "") return { verdict: "ABSENT", text };
+  const okRaw = sha256(text) === normalized;
+  const okCanon = sha256(canonicalText(text)) === normalized;
+  return { verdict: okRaw || okCanon ? "MATCH" : "MISMATCH", text };
+}
+async function anchorExecute(deps, args, context) {
+  const messages = deps.client.session.messages;
+  if (!messages) {
+    return "SIBYL ANCHOR: ERROR \u2014 engine client exposes no session.messages seam (cannot answer; not a reject).";
+  }
+  if (args.expectSha256 !== void 0 && !/^[0-9a-f]{64}$/i.test(args.expectSha256)) {
+    return "SIBYL ANCHOR: ERROR \u2014 expectSha256 must be 64 hex chars (a malformed claim is not a MISMATCH verdict).";
+  }
+  let rows;
+  try {
+    const res = await messages.call(deps.client.session, {
+      path: { id: args.sessionId },
+      query: { directory: context.directory }
+    });
+    if (res.error !== void 0) {
+      return `SIBYL ANCHOR: ERROR \u2014 engine refused the read (${JSON.stringify(res.error).slice(0, 200)}).`;
+    }
+    rows = res.data ?? [];
+  } catch (e) {
+    return internalError("sibyl_anchor_check", e);
+  }
+  let row;
+  let locatedBy;
+  if (args.body !== void 0) {
+    const want = canonicalText(args.body);
+    const hits = rows.map((r, i) => ({ r, i })).filter(({ r }) => canonicalText(anchorText(r)) === want);
+    if (hits.length !== 1) {
+      return [
+        `SIBYL ANCHOR ${hits.length === 0 ? "ABSENT" : "ERROR"} \u2014 body locator`,
+        hits.length === 0 ? `no message's canonical text equals the claimed body (scanned ${rows.length}).` : `body matches ${hits.length} messages at sdk-ordinals ${hits.map((h) => h.i).join(",")} \u2014 never auto-pick; re-run with an explicit index.`,
+        `view_sha256=${sha256(canonicalView(rows))}`
+      ].join("\n");
+    }
+    row = hits[0].r;
+    locatedBy = `body@${hits[0].i}`;
+  } else {
+    const idx = args.index ?? -1;
+    row = idx >= 0 ? rows[idx] : rows[rows.length + idx];
+    locatedBy = `index=${idx}`;
+  }
+  void locatedBy;
+  const claim2 = args.expectSha256 !== void 0;
+  const { verdict, text } = claim2 ? decide(row, args.expectSha256) : { verdict: "ABSENT", text: row ? anchorText(row) : "" };
+  const finalVerdict = !claim2 ? row === void 0 ? "ABSENT" : "ERROR" : verdict;
+  const receipt = [
+    `SIBYL ANCHOR ${finalVerdict}`,
+    `session=${args.sessionId} ${locatedBy} messages=${rows.length} role=${row?.info?.role ?? "-"}`,
+    args.label !== void 0 ? `label=${args.label}` : "",
+    `anchor_sha256=${row === void 0 ? "-" : sha256(anchorText(row))}`,
+    `claim_sha256=${args.expectSha256 ?? "-"}`,
+    `view_sha256=${sha256(canonicalView(rows))}`,
+    `body_len=${text.length}`,
+    claim2 ? "" : "note: no expectSha256 supplied \u2014 a verdict requires the claim; nothing is asserted about content."
+  ].filter((l) => l !== "").join("\n");
+  return receipt;
+}
+function buildAnchorTool(deps) {
+  return tool({
+    description: "SIBYL anchor check (g12b-3 primitive): verify a claimed human message (order/approval) against the engine session store \u2014 closed verdict MATCH/MISMATCH/ABSENT/ERROR plus a view-hash receipt so the read itself is re-computable. Read-only; persists nothing.",
+    args: {
+      sessionId: tool.schema.string().min(1).describe("Engine session id that allegedly contains the human message."),
+      index: tool.schema.number().int().optional().describe("Message ordinal in the SDK messages view (0-based; negative counts from the end; default last). WARNING: this ordinal space differs from the raw message table \u2014 cross-tool identity is the body hash, not the ordinal."),
+      body: tool.schema.string().min(1).optional().describe("Claimed exact body text \u2014 located by unique canonical match (closed normalization: trailing dcp tag + trim). Repeated bodies return ERROR naming candidates, never auto-picked."),
+      expectSha256: tool.schema.string().min(64).max(64).optional().describe("Claimed sha256 (hex) of the anchor body text; omitting it yields a non-verdict."),
+      label: tool.schema.string().min(1).optional().describe("Free-form label echoed into the receipt (e.g. the order being ratified).")
+    },
+    execute: async (args, context) => anchorExecute(deps, args, context)
+  });
+}
+
+// src/tools/probes.ts
+var DEFAULT_TIME_POOL = [
+  { url: "https://www.cloudflare.com", ownerDept: "cloudflare" },
+  { url: "https://www.google.com", ownerDept: "google" },
+  { url: "https://www.mozilla.org", ownerDept: "mozilla" }
+];
+function parseHttpDate(value) {
+  if (value === null) return void 0;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : void 0;
+}
+async function probeTimes(sources, fetchImpl, timeoutMs = 8e3) {
+  return await Promise.all(
+    sources.map(async (s) => {
+      try {
+        const res = await fetchImpl(s.url, { method: "HEAD", signal: AbortSignal.timeout(timeoutMs), redirect: "manual" });
+        const ms = parseHttpDate(res.headers.get("date"));
+        return ms === void 0 ? { url: s.url, ownerDept: s.ownerDept, ok: false, error: "no-parseable-date-header" } : { url: s.url, ownerDept: s.ownerDept, ok: true, epochMs: ms };
+      } catch (e) {
+        return { url: s.url, ownerDept: s.ownerDept, ok: false, error: String(e).slice(0, 120) };
+      }
+    })
+  );
+}
+function consensus(receipts, localMs, toleranceMs = 3e5) {
+  const ok = receipts.filter((r) => r.ok && r.epochMs !== void 0);
+  const byDept = /* @__PURE__ */ new Map();
+  for (const r of ok) if (!byDept.has(r.ownerDept)) byDept.set(r.ownerDept, r);
+  const used = [...byDept.values()];
+  if (used.length < 2) {
+    return { verdict: "INSUFFICIENT-SOURCES", usedUrls: used.map((u) => u.url), spreadMs: 0, localOffsetMs: 0 };
+  }
+  const times = used.map((u) => u.epochMs);
+  const spreadMs = Math.max(...times) - Math.min(...times);
+  const median = [...times].sort((a, b) => a - b)[Math.floor(times.length / 2)];
+  const localOffsetMs = localMs - median;
+  const verdict = spreadMs <= toleranceMs && Math.abs(localOffsetMs) <= toleranceMs ? "SYNCED" : "DRIFT";
+  return { verdict, usedUrls: used.map((u) => u.url), spreadMs, localOffsetMs };
+}
+function equalBytes(a, b) {
+  return a === b;
+}
+function attributeRange(moves, commits, roster) {
+  const bySha = new Map(commits.map((c) => [c.sha, c]));
+  return moves.map((m) => {
+    const c = bySha.get(m.newSha);
+    if (c === void 0) return { verdict: "UNATTRIBUTED", detail: `${m.remote} ${m.ref}: new commit ${m.newSha.slice(0, 12)} not in supplied commit set` };
+    const hits = roster.filter((r) => equalBytes(r.name, c.committerName) && equalBytes(r.email, c.committerEmail));
+    if (hits.length === 0) return { verdict: "UNATTRIBUTED", detail: `${m.remote} ${m.ref}: committer "${c.committerName} <${c.committerEmail}>" has no ACTIVE roster binding` };
+    if (hits.length > 1) return { verdict: "AMBIGUOUS", detail: `${m.remote} ${m.ref}: ${hits.length} roster entries byte-equal \u2014 registry defect, needs human dedup workorder` };
+    const hit = hits[0];
+    if (c.signedByKey !== null && hit.keyFingerprint !== void 0 && !equalBytes(c.signedByKey, hit.keyFingerprint)) {
+      return { verdict: "UNATTRIBUTED", detail: `${m.remote} ${m.ref}: signed by key ${c.signedByKey.slice(0, 12)} != roster binding ${hit.keyFingerprint.slice(0, 12)} (bytes-claim without signature)` };
+    }
+    return { verdict: "ATTRIBUTED", detail: `${m.remote} ${m.ref} -> ${hit.name} <${hit.email}>${hit.keyFingerprint !== void 0 ? ` key=${hit.keyFingerprint.slice(0, 12)}` : ""}` };
+  });
+}
+function parseCommitMeta(stdout) {
+  return stdout.split("\n").filter((l) => l.includes("|")).map((l) => {
+    const [sha = "", committerName = "", committerEmail = "", gk = ""] = l.split("|");
+    return { sha: sha.trim(), committerName: committerName ?? "", committerEmail: committerEmail ?? "", signedByKey: (gk ?? "").trim() === "" ? null : (gk ?? "").trim() };
+  });
+}
+function buildTimeProbeTool(deps) {
+  void deps;
+  return tool({
+    description: "SIBYL time probe (g12b-8): read HTTP Date headers from >=2 operator-distinct remote sources and compare against the local clock \u2014 verdict SYNCED / DRIFT / INSUFFICIENT-SOURCES with spread and offset in ms. Same-owner sources collapse to one; fewer than two distinct owners can NEVER certify time.",
+    args: {
+      endpoints: tool.schema.string().optional().describe("JSON array of {url,ownerDept}; defaults to the built-in cloudflare/google/mozilla pool."),
+      toleranceMs: tool.schema.number().int().positive().optional().describe("Accepted spread/offset in ms (default 300000 = 5 min, HTTP-date + proxy slop).")
+    },
+    execute: async (args, _context) => {
+      try {
+        const sources = args.endpoints !== void 0 ? JSON.parse(args.endpoints) : DEFAULT_TIME_POOL;
+        const receipts = await probeTimes(sources, fetch);
+        const c = consensus(receipts, Date.now(), args.toleranceMs);
+        return [
+          `SIBYL TIME ${c.verdict}`,
+          `used=${c.usedUrls.join(",")}`,
+          `spread_ms=${c.spreadMs} local_offset_ms=${c.localOffsetMs} tolerance_ms=${args.toleranceMs ?? 3e5}`,
+          ...receipts.map((r) => `${r.ok ? "ok" : "fail"} ${r.url} (${r.ownerDept})${r.error !== void 0 ? ` \u2014 ${r.error}` : ` \u2014 ${new Date(r.epochMs ?? 0).toISOString()}`}`)
+        ].join("\n");
+      } catch (e) {
+        return internalError("sibyl_time_probe", e);
+      }
+    }
+  });
+}
+function buildAttributeTool(deps) {
+  void deps;
+  return tool({
+    description: "SIBYL attribution (g12b-4): compare supplied ref moves (remote/ref/old/new) against commit metadata and a roster (identity+key bindings, ACTIVE entries) \u2014 per-move verdict ATTRIBUTED / UNATTRIBUTED / AMBIGUOUS. Byte-exact comparison, no normalization; unknown commits and missing bindings are UNATTRIBUTED (silent egress is fatal-class), byte-equal roster duplicates are AMBIGUOUS registry defects. Inputs are read-only strings the CALLER captured (git log / ls-remote output) \u2014 this tool never shells out.",
+    args: {
+      moves: tool.schema.string().describe("JSON array of {remote,ref,oldSha,newSha}."),
+      commits: tool.schema.string().describe("`git log --format=%H|%cn|%ce|%GK` output covering the moved-to commits (newest first or any order)."),
+      roster: tool.schema.string().describe("JSON array of {name,email,keyFingerprint?} \u2014 the registered identity bindings.")
+    },
+    execute: async (args) => {
+      try {
+        const moves = JSON.parse(args.moves);
+        const roster = JSON.parse(args.roster);
+        const commits = parseCommitMeta(args.commits);
+        const results = attributeRange(moves, commits, roster);
+        const head = results.every((r) => r.verdict === "ATTRIBUTED") ? "ALL ATTRIBUTED" : results.some((r) => r.verdict === "UNATTRIBUTED") ? "UNATTRIBUTED MOVES PRESENT (fatal class)" : "AMBIGUOUS \u2014 registry defect";
+        return [`SIBYL ATTRIBUTE: ${head}`, ...results.map((r) => `${r.verdict} :: ${r.detail}`)].join("\n");
+      } catch (e) {
+        return internalError("sibyl_attribute", e);
+      }
+    }
+  });
+}
+
 // 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";
@@ -32364,7 +32647,8 @@ function asStringArray(v) {
 function isRosterRef(v) {
   if (typeof v !== "object" || v === null) return false;
   const o = v;
-  return isNonEmptyString(o["role"]) && isNonEmptyString(o["slot"]) && isNonEmptyString(o["modelId"]) && (o["policyCheck"] === "allow" || o["policyCheck"] === "deny") && (o["denyReason"] === void 0 || typeof o["denyReason"] === "string");
+  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;
@@ -32646,7 +32930,8 @@ async function runTask(ctx, task) {
         persona: worker.persona,
         model: worker.model,
         inputText: composeTaskPrompt(ctx, task.taskId),
-        timeoutMs: worker.timeoutMs
+        timeoutMs: worker.timeoutMs,
+        parentID: ctx.parentID
       });
     } catch (e) {
       task.status = "failed";
@@ -32735,6 +33020,7 @@ async function run(prior, roster, opts) {
     const resolved = {
       client: opts.client,
       directory: opts.directory,
+      parentID: opts.parentID,
       concurrencyK: opts.concurrencyK,
       staggerMs: opts.staggerMs,
       maxAttempts,
@@ -32933,7 +33219,8 @@ async function planWorkflow(opts) {
       persona: opts.architectPersona,
       model: opts.model,
       inputText: buildPlanInstruction(opts.goal, opts.artifact),
-      ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {}
+      ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
+      ...opts.parentID !== void 0 ? { parentID: opts.parentID } : {}
     });
   } catch (e) {
     return { ok: false, stage: "plan", error: `architect runPersona threw: ${String(e)}` };
@@ -33017,6 +33304,7 @@ async function swarmExecute(deps, args, context) {
     goal: args.goal,
     artifact: read.text,
     timeoutMs: options.timeoutMs,
+    parentID: context.sessionID,
     repair: async (_badText, why) => {
       const redo = await runPersona({
         client,
@@ -33024,7 +33312,8 @@ async function swarmExecute(deps, args, context) {
         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>}`,
-        timeoutMs: options.timeoutMs
+        timeoutMs: options.timeoutMs,
+        parentID: context.sessionID
       });
       return redo.ok ? redo.text : "";
     }
@@ -33040,6 +33329,7 @@ async function swarmExecute(deps, args, context) {
   const dispatch = await dispatchRoster(mint.roster, {
     client,
     directory,
+    parentID: context.sessionID,
     concurrencyK: Math.min(options.concurrencyK, plan.schema.concurrency),
     staggerMs: options.staggerMs,
     maxRounds: options.maxRounds,
@@ -33070,27 +33360,30 @@ ${text}
       persona: { system: "You are the SIBYL swarm judge. You rule on pipeline reports with exactly one word: APPROVE, REJECT, or EXHAUSTED." },
       model: slotForModel(options.modelPool, options.swarm.judge, void 0),
       inputText: buildJudgeInput(report),
-      timeoutMs: options.timeoutMs
+      timeoutMs: options.timeoutMs,
+      parentID: context.sessionID
     });
     const word = judged.ok ? parseJudgeWord(judged.text) : null;
     judgeNote = word === null ? `judge=inactive (${judged.ok ? "unrecognized verdict word" : `engine: ${judged.error ?? "?"}`}; derived kept)` : `judge=${word}${word === report.verdict ? "" : " (overrides derived " + report.verdict + ")"}`;
     if (word !== null) report = { ...report, verdict: word };
   }
   const counts = countTasks(report.tasks);
+  const noSignal = counts.done === 0;
+  const tag = noSignal ? "CANNOT_ANSWER" : report.verdict === "APPROVE" ? "APPROVE" : "REJECT";
   await finishRun(deps, record3, {
     status: "done",
     rounds: report.rounds,
     verdict: {
-      verdict: report.verdict === "APPROVE" ? "APPROVE" : "REJECT",
+      verdict: tag,
       approvals: counts.done,
-      rejects: counts.failed,
-      errors: 0,
+      rejects: noSignal ? 0 : tag === "REJECT" ? 1 : 0,
+      errors: counts.failed,
       missing: counts.suspended
     },
-    notes: `${judgeNote} \xB7 ${report.tasks.map((t) => `${t.id}=${t.status}`).join(",")}`
+    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(",")}`
   });
   const lines = [
-    `SIBYL SWARM: ${report.verdict} 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} (rounds=${String(report.rounds)} done=${String(counts.done)} failed=${String(counts.failed)} suspended=${String(counts.suspended)} ${judgeNote})`,
     ...report.tasks.map((t) => `  task: ${t.id} ${t.status}${t.sessionId === void 0 ? "" : ` session=${t.sessionId}`}`),
     ...report.artifacts.map((a) => `  artifact: ${a}`),
     `  space: ${record3.spaceDir}`,
@@ -33123,7 +33416,13 @@ function toEngineClient(sdk) {
   return {
     session: {
       async create(args) {
-        const r = await sdk.session.create({ body: { title: args.body.title }, query: { directory: args.query.directory } });
+        const r = await sdk.session.create({
+          body: {
+            title: args.body.title,
+            ...args.body.parentID !== void 0 && { parentID: args.body.parentID }
+          },
+          query: { directory: args.query.directory }
+        });
         return {
           ...r.data !== void 0 && { data: { id: r.data.id } },
           ...r.error !== void 0 && { error: r.error }
@@ -33161,6 +33460,34 @@ function toEngineClient(sdk) {
           },
           ...r.error !== void 0 && { error: r.error }
         };
+      },
+      async messages(args) {
+        const r = await sdk.session.messages({
+          path: { id: args.path.id },
+          query: { directory: args.query.directory }
+        });
+        return {
+          ...r.data !== void 0 && {
+            data: r.data.map((m) => ({
+              info: {
+                ...m.info.role !== void 0 && { role: m.info.role },
+                ...m.info.role === "assistant" && {
+                  ...m.info.providerID !== void 0 && { providerID: m.info.providerID },
+                  ...m.info.modelID !== void 0 && { modelID: m.info.modelID },
+                  ...m.info.time !== void 0 && {
+                    time: { ...m.info.time.completed !== void 0 && { completed: m.info.time.completed } }
+                  },
+                  ...m.info.error !== void 0 && { error: m.info.error }
+                }
+              },
+              parts: m.parts.map((p) => ({
+                type: p.type,
+                ..."text" in p && p.text !== void 0 && { text: p.text }
+              }))
+            }))
+          },
+          ...r.error !== void 0 && { error: r.error }
+        };
       }
     }
   };
@@ -33184,7 +33511,10 @@ async function SibylPlugin(input2, options) {
       sibyl_consult: buildConsultTool(deps),
       sibyl_swarm: buildSwarmTool(deps),
       sibyl_status: buildStatusTool(deps),
-      sibyl_review: buildReviewTool(deps)
+      sibyl_review: buildReviewTool(deps),
+      sibyl_anchor_check: buildAnchorTool(deps),
+      sibyl_time_probe: buildTimeProbeTool(deps),
+      sibyl_attribute: buildAttributeTool(deps)
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sibyl-system",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "license": "MIT",
   "type": "module",
   "description": "Sibyl-System: democratic-centralism review chamber (one conclusion, one voice) + fail-closed council voting + dynamic swarm plugin for OpenCode",