sibyl-system 1.3.2 → 1.3.3

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/index.js

@@ -33031,6 +33031,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 +34064,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.3",
   "license": "MIT",
   "type": "module",
   "description": "Sibyl-System: democratic-centralism review chamber (one conclusion, one voice) + fail-closed council voting + dynamic swarm plugin for OpenCode",