sibyl-system 1.3.2 → 1.3.4

package/README.md

@@ -12,6 +12,7 @@ A standalone [opencode](https://opencode.ai) plugin:
   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_audit`** — the outside lane as a product organ: completion-state ballots convene themselves from a fresh root session (see Tools).
 - **`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.
@@ -98,6 +99,7 @@ stderr, registers nothing, and returns empty hooks.
 | Tool | Arguments | Behavior |
 |------|-----------|----------|
 | `sibyl_consult` | `{ artifact, goal }` | `artifact` is a file path or inline multi-line text (≤ 256 KiB). The three councilors audit it in parallel; each reply is parsed into a verdict (one in-session JSON-only repair shot per voter). Returns the tally, merged reasons/must-fix, run id, and per-voter reply file paths. |
+| `sibyl_audit` | `{ artifact, goal }` | Independent audit lane: the council is convened by a FRESH engine-provisioned root session (structurally non-kin to any drafting chain), so the ballot enters the effective path without the caller's identity touching it. Receipt: auditor session id (retained, DB-reconcilable), artifact sha256 bound at start and end (mid-flight drift => VOID), verdict face; anything but INDEPENDENT on the fresh convener => REFUSED, no receipt. |
 | `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`, forced to `CANNOT_ANSWER` when a declared worker left no terminal row (W2) or zero drafts were produced. 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`. |
@@ -211,7 +213,7 @@ Dependencies point downward only:
 
 ```
 index.ts            plugin entry: parse options → share one RunStore + client
-                    adapter → register the seven sibyl_* tools
+                    adapter → register the eight 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

package/dist/cli.js

@@ -801,6 +801,11 @@ function conclude(result) {
   }
   return { conclusion: "NEEDS_HUMAN", confidence: 0 };
 }
+function voiceIndependence(record2) {
+  const ind = record2.independence;
+  if (ind === void 0) return "MISSING-PRE-W1 \u2014 this record predates convener capture; never treat as independent";
+  return ind.status === "INDEPENDENT" ? "INDEPENDENT" : `${ind.status} \u2014 ${ind.evidence}`;
+}
 function buildVoice(result) {
   const { record: record2, judge, terminal, gaps } = result;
   const { conclusion, confidence } = conclude(result);
@@ -819,6 +824,7 @@ function buildVoice(result) {
     open_charges: judge?.charges.length ?? 0,
     dissent_sealed_in: sealed,
     terminal,
+    independence: voiceIndependence(record2),
     run_id: record2.runId,
     serial: record2.serial,
     spotcheck: spotcheckCommand(record2.runDir)
@@ -828,6 +834,7 @@ function renderVoice(voice) {
   const lines = [
     `SIBYL \u2014 ONE CONCLUSION, ONE VOICE  [${voice.label}]`,
     `conclusion: ${voice.conclusion}  confidence: ${String(voice.confidence)}  terminal: ${voice.terminal}`,
+    `independence: ${voice.independence}`,
     `run: ${voice.run_id} (serial ${String(voice.serial)})  open charges: ${String(voice.open_charges)}`,
     `honesty: ${voice.honesty} (until C-09/C-14 containment rulings \u2014 see docs/isolation-laws.md)`,
     "rationale:",
@@ -20379,8 +20386,17 @@ async function resolveRun(flags) {
   let launchIndependence;
   try {
     const lc = JSON.parse(await readFile6(join7(runDir, "launch-context.json"), "utf8"));
-    if (isIndependenceShape(lc["independence"])) launchIndependence = lc["independence"];
+    launchIndependence = isIndependenceShape(lc["independence"]) ? lc["independence"] : {
+      status: "UNVERIFIABLE",
+      convenerChain: [],
+      evidence: "launch-context staged but its independence leg is malformed \u2014 not trusted; this review carries no independence anchor"
+    };
   } catch {
+    launchIndependence = {
+      status: "UNVERIFIABLE",
+      convenerChain: [],
+      evidence: "bare CLI launch: no convener session staged; the drafting-chain read was impossible by construction"
+    };
   }
   let targetPath = targetRaw;
   if (targetRaw !== "-") {

package/dist/index.js

@@ -31844,7 +31844,7 @@ async function salvageAfterPromptTimeout(client, directory, sessionID, graceMs,
   }
   return null;
 }
-async function runPersona(opts) {
+async function runPersonaAttempt(opts, attempt) {
   const { client, directory, persona, model, inputText, parentID } = opts;
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
   const t0 = Date.now();
@@ -31863,7 +31863,7 @@ async function runPersona(opts) {
     const created = await withTimeout(
       client.session.create({
         body: {
-          title: `sibyl:${persona.agent ?? "persona"}`,
+          title: `sibyl:${persona.agent ?? "persona"}${attempt === 1 ? "" : ` r${String(attempt)}`}`,
           ...parentID !== void 0 && parentID.length > 0 && { parentID }
         },
         query: { directory }
@@ -31908,9 +31908,9 @@ async function runPersona(opts) {
         graceMs,
         opts.salvagePollMs ?? DEFAULT_SALVAGE_POLL_MS
       );
-      if (!outcome) return fail(promptFailure);
+      if (!outcome) return { ...fail(promptFailure), retryable: true };
       if (outcome.kind === "error") {
-        return fail(`${promptFailure}; salvage read failed: ${outcome.error}`);
+        return { ...fail(`${promptFailure}; salvage read failed: ${outcome.error}`), retryable: true };
       }
       return {
         text: outcome.text,
@@ -31922,7 +31922,10 @@ async function runPersona(opts) {
         salvageExtraMs: Date.now() - raceExpiredAt
       };
     }
-    if (prompted.error) return fail(describeError2(prompted.error));
+    if (prompted.error) {
+      const channel = describeError2(prompted.error);
+      return SALVAGE_ELIGIBLE_PROMPT_FAILURE.test(channel) ? { ...fail(channel), retryable: true } : fail(channel);
+    }
     if (!prompted.data) return fail("session.prompt: response missing data payload");
     const info = prompted.data.info;
     if (info?.error) return fail(describeError2(info.error));
@@ -31937,9 +31940,18 @@ async function runPersona(opts) {
     }
     return { text, ok: true, latencyMs: Date.now() - t0, sessionID, modelApplied };
   } catch (e) {
-    return fail(e instanceof Error ? e.message : describeError2(e));
+    const thrown = e instanceof Error ? e.message : describeError2(e);
+    return SALVAGE_ELIGIBLE_PROMPT_FAILURE.test(thrown) ? { ...fail(thrown), retryable: true } : fail(thrown);
   }
 }
+async function runPersona(opts) {
+  const first = await runPersonaAttempt(opts, 1);
+  if (first.ok || first.retryable !== true) return first;
+  const second = await runPersonaAttempt(opts, 2);
+  if (second.ok) return { ...second, retried: true };
+  const { retryable: _dropped, ...settled } = second;
+  return { ...settled, retried: true, error: `${second.error} (one transport retry spent; first death: ${first.error})` };
+}
 
 // src/independence.ts
 var MAX_CHAIN_DEPTH = 16;
@@ -32676,6 +32688,7 @@ function formatRunLine(record3) {
 
 // src/tools/consult.ts
 var CONSULT_TOOL_NAME = "sibyl_consult";
+var BALLOT_BUDGET_LINES = 25;
 function buildConsultInput(goal, artifactText) {
   return `Audit the artifact below against the stated goal and cast your verdict.
 
@@ -32683,7 +32696,9 @@ GOAL:
 ${goal}
 
 ARTIFACT:
-${artifactText}`;
+${artifactText}
+
+BALLOT BUDGET (hard): total output at most ${String(BALLOT_BUDGET_LINES)} lines; one line per reason and per must-fix; no headings, no blank lines, no code blocks. The cap binds every seat alike \u2014 it is a transport protection, not a depth limit.`;
 }
 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) {
@@ -33031,6 +33046,79 @@ function buildAnchorTool(deps) {
   });
 }
 
+// src/tools/audit.ts
+import { createHash as createHash3 } from "node:crypto";
+var AUDIT_TOOL_NAME = "sibyl_audit";
+var RUN_ID_RE = /run (sibyl-[0-9TZ-]+-[0-9a-f]+)/;
+function sha2562(text) {
+  return createHash3("sha256").update(text, "utf8").digest("hex");
+}
+async function artifactHash(raw, dir) {
+  const art = await readArtifact(raw, dir);
+  return art.ok ? sha2562(art.text) : null;
+}
+function buildAuditTool(deps) {
+  return tool({
+    description: "SIBYL independent audit lane: convenes the three-councilor consult from a FRESH engine-provisioned root session (structurally non-kin to any drafting chain), so the ballot enters the effective path without the caller's identity touching it. Emits an audit receipt \u2014 auditor session id (retained, DB-reconcilable), artifact sha256 bound at start and end, verdict face. REFUSES (no receipt) if the fresh convener resolves to anything but INDEPENDENT, or the artifact drifts mid-ballot (VOID).",
+    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("The question the audit must answer.")
+    },
+    execute: async (args, context) => {
+      try {
+        return await auditExecute(deps, args, context);
+      } catch (err) {
+        return internalError(AUDIT_TOOL_NAME, err);
+      }
+    }
+  });
+}
+async function auditExecute(deps, args, ctx) {
+  const start = await readArtifact(args.artifact, ctx.directory);
+  if (!start.ok) {
+    return `SIBYL AUDIT: refused \u2014 artifact unreadable: ${start.error}`;
+  }
+  const shaStart = sha2562(start.text);
+  const created = await deps.client.session.create({
+    body: { title: `sibyl:audit ${(/* @__PURE__ */ new Date()).toISOString()}` },
+    query: { directory: ctx.directory }
+  });
+  const auditor = created.data?.id ?? "";
+  if (auditor.length === 0) {
+    const why = created.error === void 0 ? "no id in response" : JSON.stringify(created.error).slice(0, 140);
+    return `SIBYL AUDIT: refused \u2014 engine did not provision the fresh root convener (${why}); an audit without a resolvable auditor session is not an audit`;
+  }
+  const caller = ctx.sessionID.length > 0 ? ctx.sessionID : "headless";
+  const ballot = await consultExecute(deps, args, { ...ctx, sessionID: auditor });
+  const runId = RUN_ID_RE.exec(ballot)?.[1] ?? "";
+  const runs = await deps.store.load();
+  const rec = runs.find((r) => r.runId === runId);
+  const ind = rec?.independence;
+  const independence = ind?.status ?? "MISSING-RECORD";
+  if (independence !== "INDEPENDENT") {
+    const ev = ind?.evidence ?? `run ${runId.length > 0 ? runId : "(unresolvable)"} not found in the store`;
+    return `SIBYL AUDIT: REFUSED \u2014 the fresh convener ${auditor} resolved to independence=${independence}: ${ev}
+  the ballot ${runId.length > 0 ? runId : "(no run id)"} is archived as DATA and carries no audit receipt; requested-by=` + caller + " (DATA only)";
+  }
+  const shaEnd = await artifactHash(args.artifact, ctx.directory);
+  if (shaEnd !== shaStart) {
+    return `SIBYL AUDIT: VOID \u2014 artifact bytes moved while the ballot was in flight (start sha256 ${shaStart.slice(0, 16)}\u2026, end ${shaEnd === null ? "unreadable" : `${shaEnd.slice(0, 16)}\u2026`}); run ${runId} archived as DATA; re-audit the current bytes`;
+  }
+  const v = rec?.verdict;
+  const counts = v === void 0 ? "no verdict" : `${String(v.approvals)}A/${String(v.rejects)}R/${String(v.errors)}E/${String(v.missing)}M`;
+  const rules = rec?.instrument?.rulesHash.slice(0, 12) ?? "no-instrument-face";
+  return [
+    `SIBYL AUDIT RECEIPT run=${runId}`,
+    `  verdict=${v?.verdict ?? "unknown"} (${counts}) rules=${rules}`,
+    `  auditor-convener=${auditor} (fresh engine-provisioned root; session row RETAINED for DB reconciliation)`,
+    `  requested-by=${caller} \u2014 recorded as ledger data only; it neither convenes nor votes`,
+    `  artifact-sha256=${shaStart} (re-hashed after the ballot, identical \u2014 the receipt binds to these bytes)`,
+    "",
+    "--- ballot face ---",
+    ballot
+  ].join("\n");
+}
+
 // src/tools/probes.ts
 var DEFAULT_TIME_POOL = [
   { url: "https://www.cloudflare.com", ownerDept: "cloudflare" },
@@ -33991,6 +34079,7 @@ async function SibylPlugin(input2, options) {
   return {
     tool: {
       sibyl_consult: buildConsultTool(deps),
+      sibyl_audit: buildAuditTool(deps),
       sibyl_swarm: buildSwarmTool(deps),
       sibyl_status: buildStatusTool(deps),
       sibyl_review: buildReviewTool(deps),

package/package.json

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