omnius 1.0.237 → 1.0.239

package/dist/index.js

@@ -2405,6 +2405,80 @@ function inspectRealProcess(pid) {
   }
   return identity3;
 }
+function formatProcessLeaseSummary(leases) {
+  const active = leases.filter((l2) => l2.status === "active").length;
+  const stale = leases.filter((l2) => l2.status === "suspect_unverified" || l2.status === "terminating").length;
+  const dead = leases.filter((l2) => l2.status === "dead" || l2.status === "killed").length;
+  const lines = [
+    `[PROCESS LEASES]`,
+    `Active: ${active} | Stale: ${stale} | Dead: ${dead} | Total: ${leases.length}`
+  ];
+  for (const lease of leases.filter((l2) => l2.status !== "dead" && l2.status !== "killed").slice(0, 20)) {
+    const age = Math.round((Date.now() - lease.startedAt) / 1e3);
+    lines.push(`  ${lease.leaseId.slice(0, 24).padEnd(24)} pid=${String(lease.pid).padEnd(6)} ${lease.lifecycle}/${lease.status} age=${age}s owner=${lease.ownerId}`);
+  }
+  return lines.join("\n");
+}
+function adoptDaemonPidFileLease(pidFilePath, options2) {
+  try {
+    if (!existsSync5(pidFilePath))
+      return null;
+    const pidStr = readFileSync4(pidFilePath, "utf8").trim();
+    const pid = Number(pidStr);
+    if (!Number.isFinite(pid) || pid <= 0)
+      return null;
+    if (!isProcessAlive(pid))
+      return null;
+    const cwd4 = process.platform !== "win32" && existsSync5(`/proc/${pid}/cwd`) ? readlinkSync(`/proc/${pid}/cwd`) : void 0;
+    const cmdline = process.platform !== "win32" && existsSync5(`/proc/${pid}/cmdline`) ? readFileSync4(`/proc/${pid}/cmdline`, "utf8").replace(/\0/g, " ").trim() : void 0;
+    return registerProcessLease({
+      pid,
+      ownerKind: "daemon",
+      ownerId: "daemon",
+      projectRoot: process.cwd(),
+      lifecycle: "daemon",
+      persistent: true,
+      reason: options2?.reason ?? "adopted from daemon pid file",
+      command: cmdline,
+      cwd: cwd4
+    }, options2);
+  } catch {
+    return null;
+  }
+}
+function adoptSchedulerLease(record, options2) {
+  try {
+    if (!record.pid || !isProcessAlive(record.pid))
+      return null;
+    return registerProcessLease({
+      pid: record.pid,
+      ownerKind: "scheduler",
+      ownerId: `job:${record.jobId}`,
+      projectRoot: process.cwd(),
+      lifecycle: "scheduler",
+      persistent: true,
+      reason: `adopted from scheduler job ${record.jobId}`
+    }, options2);
+  } catch {
+    return null;
+  }
+}
+function adoptInFlightChatLease(record, options2) {
+  try {
+    if (!record.pid || !isProcessAlive(record.pid))
+      return null;
+    return registerProcessLease({
+      pid: record.pid,
+      ownerKind: "chat",
+      ownerId: record.chatId,
+      projectRoot: process.cwd(),
+      lifecycle: "task",
+      reason: `adopted from in-flight chat run ${record.runId}`
+    }, options2);
+  } catch {
+    return null;
+  }
+}
 function tryAcquireSweeperLock(lockDir, ownerLabel) {
   try {
     mkdirSync4(lockDir, { recursive: false });
@@ -35307,11 +35381,11 @@ function deleteCustomToolDefinition(name10, scope, repoRoot) {
   const dir = scope === "project" && repoRoot ? projectToolsDir(repoRoot) : globalToolsDir();
   const filePath = join34(dir, `${name10}.json`);
   if (existsSync32(filePath)) {
-    const { unlinkSync: unlinkSync32 } = __require("node:fs");
-    unlinkSync32(filePath);
+    const { unlinkSync: unlinkSync33 } = __require("node:fs");
+    unlinkSync33(filePath);
     const docsPath = toolDocsPath(name10, scope, repoRoot);
     if (existsSync32(docsPath))
-      unlinkSync32(docsPath);
+      unlinkSync33(docsPath);
     if (scope === "project" && repoRoot)
       writeCustomToolRegistry(repoRoot);
     return true;
@@ -290328,7 +290402,7 @@ var init_working_notes = __esm({
 });
 
 // packages/execution/dist/tools/workboard.js
-import { appendFileSync as appendFileSync3, existsSync as existsSync50, mkdirSync as mkdirSync26, readFileSync as readFileSync36, renameSync as renameSync4, writeFileSync as writeFileSync23 } from "node:fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync50, mkdirSync as mkdirSync26, readFileSync as readFileSync36, renameSync as renameSync4, unlinkSync as unlinkSync9, writeFileSync as writeFileSync23 } from "node:fs";
 import { join as join64 } from "node:path";
 import { randomBytes as randomBytes16 } from "node:crypto";
 function workboardRoot(workingDir = process.cwd()) {
@@ -290383,7 +290457,7 @@ function writeActiveWorkboardSnapshot(workingDir, snapshot) {
     renameSync4(tmpPath, paths.activePath);
   } catch (err) {
     try {
-      writeFileSync23(tmpPath, "", "utf8");
+      unlinkSync9(tmpPath);
     } catch {
     }
     throw err;
@@ -290391,9 +290465,9 @@ function writeActiveWorkboardSnapshot(workingDir, snapshot) {
 }
 function loadWorkboardSnapshot(workingDir, runId) {
   const active = readActiveWorkboardSnapshot(workingDir, runId);
-  if (active)
-    return active;
   const events = readWorkboardEvents(workingDir, runId);
+  if (active && active.eventCount === events.length)
+    return active;
   if (events.length === 0)
     return null;
   const snapshot = replayWorkboardEvents(events);
@@ -292155,7 +292229,7 @@ var init_project_scaffolding = __esm({
 });
 
 // packages/execution/dist/tools/todo-store.js
-import { existsSync as existsSync51, readFileSync as readFileSync37, writeFileSync as writeFileSync24, mkdirSync as mkdirSync27, renameSync as renameSync5, unlinkSync as unlinkSync9, readdirSync as readdirSync16 } from "node:fs";
+import { existsSync as existsSync51, readFileSync as readFileSync37, writeFileSync as writeFileSync24, mkdirSync as mkdirSync27, renameSync as renameSync5, unlinkSync as unlinkSync10, readdirSync as readdirSync16 } from "node:fs";
 import { join as join65 } from "node:path";
 import { homedir as homedir16 } from "node:os";
 import { randomBytes as randomBytes17 } from "node:crypto";
@@ -292219,7 +292293,7 @@ function writeTodos(sessionId, incoming) {
     renameSync5(tmpPath, finalPath);
   } catch (err) {
     try {
-      unlinkSync9(tmpPath);
+      unlinkSync10(tmpPath);
     } catch {
     }
     throw err;
@@ -292245,7 +292319,7 @@ function deleteTodos(sessionId) {
   if (!existsSync51(p2))
     return false;
   try {
-    unlinkSync9(p2);
+    unlinkSync10(p2);
     return true;
   } catch {
     return false;
@@ -538586,7 +538660,7 @@ var init_process_health = __esm({
 
 // packages/execution/dist/tools/camera-capture.js
 import { execSync as execSync29 } from "node:child_process";
-import { readFileSync as readFileSync40, writeFileSync as writeFileSync25, unlinkSync as unlinkSync10, existsSync as existsSync54, mkdirSync as mkdirSync29, statSync as statSync23 } from "node:fs";
+import { readFileSync as readFileSync40, writeFileSync as writeFileSync25, unlinkSync as unlinkSync11, existsSync as existsSync54, mkdirSync as mkdirSync29, statSync as statSync23 } from "node:fs";
 import { join as join70 } from "node:path";
 import { tmpdir as tmpdir10 } from "node:os";
 var KANDAO_USB_VENDORS, QOOCAM_WIFI_PASSWORD, QOOCAM_DEFAULT_IP, OSC_TIMEOUT, CameraCaptureTool;
@@ -539059,7 +539133,7 @@ Saved to: ${userOutputPath}`,
           };
         }
         try {
-          unlinkSync10(filePath);
+          unlinkSync11(filePath);
         } catch {
         }
         const base642 = data.toString("base64");
@@ -539079,7 +539153,7 @@ Saved to: ${outputPath3}`;
 
 // packages/execution/dist/tools/audio-capture.js
 import { execSync as execSync30 } from "node:child_process";
-import { readFileSync as readFileSync41, unlinkSync as unlinkSync11, existsSync as existsSync55, mkdirSync as mkdirSync30, statSync as statSync24 } from "node:fs";
+import { readFileSync as readFileSync41, unlinkSync as unlinkSync12, existsSync as existsSync55, mkdirSync as mkdirSync30, statSync as statSync24 } from "node:fs";
 import { join as join71 } from "node:path";
 import { tmpdir as tmpdir11 } from "node:os";
 var AudioCaptureTool;
@@ -539282,7 +539356,7 @@ Saved to: ${tempFile}`,
           }
           const raw = readFileSync41(tempFile);
           try {
-            unlinkSync11(tempFile);
+            unlinkSync12(tempFile);
           } catch {
           }
           let sumSquares = 0;
@@ -539318,7 +539392,7 @@ Saved to: ${tempFile}`,
           };
         } catch (err) {
           try {
-            unlinkSync11(tempFile);
+            unlinkSync12(tempFile);
           } catch {
           }
           return { success: false, output: "", error: `Mic level check failed: ${err instanceof Error ? err.message : String(err)}`, durationMs: performance.now() - start2 };
@@ -541088,7 +541162,7 @@ ${info}`, durationMs: performance.now() - start2 };
 
 // packages/execution/dist/tools/sdr-scan.js
 import { execSync as execSync34 } from "node:child_process";
-import { readFileSync as readFileSync42, unlinkSync as unlinkSync12, existsSync as existsSync57, mkdirSync as mkdirSync32, statSync as statSync26 } from "node:fs";
+import { readFileSync as readFileSync42, unlinkSync as unlinkSync13, existsSync as existsSync57, mkdirSync as mkdirSync32, statSync as statSync26 } from "node:fs";
 import { join as join73 } from "node:path";
 import { tmpdir as tmpdir13 } from "node:os";
 var SdrScanTool;
@@ -541280,7 +541354,7 @@ Tools installed but rtl_test failed — device may be in use by another process.
           const csv = readFileSync42(outFile, "utf8");
           const lines = csv.trim().split("\n");
           try {
-            unlinkSync12(outFile);
+            unlinkSync13(outFile);
           } catch {
           }
           const signals = [];
@@ -544139,7 +544213,7 @@ ${lines.join("\n")}`,
 
 // packages/execution/dist/tools/asr-listen.js
 import { execSync as execSync41, spawnSync as spawnSync8 } from "node:child_process";
-import { existsSync as existsSync63, mkdirSync as mkdirSync37, writeFileSync as writeFileSync31, readFileSync as readFileSync47, unlinkSync as unlinkSync13 } from "node:fs";
+import { existsSync as existsSync63, mkdirSync as mkdirSync37, writeFileSync as writeFileSync31, readFileSync as readFileSync47, unlinkSync as unlinkSync14 } from "node:fs";
 import { dirname as dirname19, join as join78, resolve as resolve39 } from "node:path";
 import { tmpdir as tmpdir18, homedir as homedir22 } from "node:os";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
@@ -544438,7 +544512,7 @@ print(json.dumps({"ok": False, "error": "No whisper backend available"}))
           }
         } finally {
           try {
-            unlinkSync13(scriptFile);
+            unlinkSync14(scriptFile);
           } catch {
           }
         }
@@ -547544,7 +547618,7 @@ var init_plugin_system = __esm({
 });
 
 // packages/execution/dist/tools/notebook-edit.js
-import { readFileSync as readFileSync51, writeFileSync as writeFileSync34, existsSync as existsSync68, renameSync as renameSync6, unlinkSync as unlinkSync14 } from "node:fs";
+import { readFileSync as readFileSync51, writeFileSync as writeFileSync34, existsSync as existsSync68, renameSync as renameSync6, unlinkSync as unlinkSync15 } from "node:fs";
 import { resolve as resolve41 } from "node:path";
 function readNotebook(path12) {
   if (!existsSync68(path12))
@@ -547568,7 +547642,7 @@ function writeNotebook(path12, nb) {
     renameSync6(tempPath, path12);
   } catch (err) {
     try {
-      unlinkSync14(tempPath);
+      unlinkSync15(tempPath);
     } catch {
     }
     throw err;
@@ -547966,7 +548040,7 @@ var init_environment_snapshot = __esm({
 
 // packages/execution/dist/tools/video-understand.js
 import { execSync as execSync44 } from "node:child_process";
-import { existsSync as existsSync69, mkdirSync as mkdirSync41, writeFileSync as writeFileSync35, readFileSync as readFileSync52, readdirSync as readdirSync22, unlinkSync as unlinkSync15 } from "node:fs";
+import { existsSync as existsSync69, mkdirSync as mkdirSync41, writeFileSync as writeFileSync35, readFileSync as readFileSync52, readdirSync as readdirSync22, unlinkSync as unlinkSync16 } from "node:fs";
 import { join as join83, basename as basename16 } from "node:path";
 import { createHash as createHash24 } from "node:crypto";
 function isYouTubeUrl2(url) {
@@ -549709,9 +549783,6 @@ __export(dist_exports2, {
   OcrImageAdvancedTool: () => OcrImageAdvancedTool,
   OcrPdfTool: () => OcrPdfTool,
   OpenCodeTool: () => OpenCodeTool,
-  PROCESS_LEASE_STALE_MS: () => PROCESS_LEASE_STALE_MS,
-  PROCESS_LEASE_SWEEP_INTERVAL_MS: () => PROCESS_LEASE_SWEEP_INTERVAL_MS,
-  PROCESS_LEASE_TERM_GRACE_MS: () => PROCESS_LEASE_TERM_GRACE_MS,
   PdfToTextTool: () => PdfToTextTool,
   PhaseRecallTool: () => PhaseRecallTool,
   PlaywrightBrowserTool: () => PlaywrightBrowserTool,
@@ -549777,6 +549848,9 @@ __export(dist_exports2, {
   addProjectConstraint: () => addProjectConstraint,
   addSessionConstraint: () => addSessionConstraint,
   addWorkboardCard: () => addWorkboardCard,
+  adoptDaemonPidFileLease: () => adoptDaemonPidFileLease,
+  adoptInFlightChatLease: () => adoptInFlightChatLease,
+  adoptSchedulerLease: () => adoptSchedulerLease,
   aliasTool: () => aliasTool,
   applyMediaCudaDeviceFilterToEnv: () => applyMediaCudaDeviceFilterToEnv,
   applyPatch: () => applyPatch,
@@ -549863,6 +549937,7 @@ __export(dist_exports2, {
   flattenSlug: () => flattenSlug,
   formatBytes: () => formatBytes,
   formatMessagesForContext: () => formatMessagesForContext,
+  formatProcessLeaseSummary: () => formatProcessLeaseSummary,
   formatProvenanceSummary: () => formatProvenanceSummary,
   formatSecurityNotice: () => formatSecurityNotice,
   formatSnapshotForContext: () => formatSnapshotForContext,
@@ -553161,6 +553236,391 @@ var init_textSanitize = __esm({
   }
 });
 
+// packages/orchestrator/dist/completionContract.js
+function normalizeText(value2, max = 500) {
+  const text2 = String(value2 ?? "").trim().replace(/\s+/g, " ");
+  return text2 ? text2.slice(0, max) : "";
+}
+function normalizeCompletionKey(value2, fallback = "item") {
+  const key = String(value2 ?? fallback).trim().toLowerCase().replace(/[^a-z0-9_.:-]+/g, "_").replace(/_{2,}/g, "_").replace(/^[_:.-]+|[_:.-]+$/g, "").slice(0, 96);
+  return key || fallback;
+}
+function genericField(key, label, description, acceptanceCriteria) {
+  return {
+    key: normalizeCompletionKey(key),
+    label,
+    fieldType: "json",
+    elevation: "required",
+    sourceMode: "derived",
+    description,
+    acceptanceCriteria
+  };
+}
+function inferCompletionContract(taskText) {
+  const goalSummary = normalizeText(taskText);
+  const fields = [
+    genericField("claims.evidence_map", "Claim evidence map", "A run-local mapping from each final claim to the observed result that supports it.", "Each material claim is either backed by observed evidence from this run or named as unverified/blocked."),
+    genericField("claims.unverified", "Unverified claims", "Claims that could not be proven from the run's observations.", "Unverified claims are not presented as completed work.")
+  ];
+  const phases = [
+    {
+      key: "execute",
+      label: "Execute",
+      instructions: "Do the requested work while preserving observations needed to evaluate the result.",
+      requirementIds: [],
+      fields: [],
+      gate: {
+        key: "execution_trace",
+        instructions: "Keep enough concrete run output to distinguish facts from assumptions."
+      }
+    },
+    {
+      key: "verify",
+      label: "Verify",
+      instructions: "Derive the needed evidence from the actual request and final claims, then compare those claims to observed results.",
+      requirementIds: [],
+      fields,
+      gate: {
+        key: "claim_evidence_review",
+        instructions: "Judge whether the actual claim is supported by the actual observations."
+      }
+    },
+    {
+      key: "deliver",
+      label: "Deliver",
+      instructions: "Report completed, verified, unverified, and blocked items without overstating what was observed.",
+      requirementIds: [],
+      fields: [],
+      gate: {
+        key: "result_readback",
+        instructions: "Final wording must not exceed the observed evidence."
+      }
+    }
+  ];
+  return {
+    goalSummary,
+    surfaces: [],
+    fields,
+    requirements: [],
+    phases,
+    acceptanceCriteria: [
+      "The final response distinguishes completed work from verified evidence and unverified or blocked claims."
+    ]
+  };
+}
+function inferCompletionContractFromTexts(texts, fallbackSummary = "") {
+  const combined = texts.map((text2) => String(text2 ?? "").trim()).filter(Boolean).join("\n\n");
+  return inferCompletionContract(combined || fallbackSummary);
+}
+function clip2(value2, max = 500) {
+  return normalizeText(value2, max);
+}
+function listLines(items, empty2 = "- none observed") {
+  return items.length > 0 ? items.map((item) => `- ${item}`) : [empty2];
+}
+function formatEvidenceEntry(entry) {
+  const parts = [
+    entry.success === true ? "ok" : entry.success === false ? "failed" : "unknown",
+    entry.name ? `tool=${clip2(entry.name, 80)}` : "",
+    typeof entry.turn === "number" ? `turn=${entry.turn}` : "",
+    entry.mutated ? "mutated=true" : "",
+    entry.argsKey ? `args=${clip2(entry.argsKey, 180)}` : "",
+    entry.outputPreview ? `observed=${clip2(entry.outputPreview, 260)}` : ""
+  ].filter(Boolean);
+  return parts.join(" ");
+}
+function deriveScenarioSeed(input) {
+  const text2 = [
+    input.taskText,
+    input.contract.goalSummary,
+    input.proposedSummary,
+    input.answerText
+  ].map((part) => String(part ?? "").trim()).filter(Boolean).join("\n");
+  const normalized = normalizeCompletionKey(text2.slice(0, 140), "completion_scenario");
+  return normalized || "completion_scenario";
+}
+function buildCompletionScenarioDecomposition(input) {
+  const proposedClaimText = [
+    input.proposedSummary ? `task_complete summary:
+${String(input.proposedSummary).trim()}` : "",
+    input.answerText ? `assistant visible answer:
+${String(input.answerText).trim()}` : ""
+  ].filter(Boolean).join("\n\n").slice(0, 4e3);
+  const observedEvidence = (input.log ?? []).slice(-40).map(formatEvidenceEntry);
+  const unresolvedSignals = [
+    ...(input.openLoops ?? []).map((item) => `open loop: ${clip2(item, 260)}`),
+    ...(input.recentFailures ?? []).map((item) => `recent failure: ${clip2(item, 260)}`),
+    ...(input.planStatus ?? []).filter((item) => item.status || item.reconciled || item.rationale).map((item) => {
+      const state = [item.status, item.reconciled].filter(Boolean).join("/");
+      const suffix = item.rationale ? ` (${clip2(item.rationale, 180)})` : "";
+      return `plan ${state || "observed"}: ${clip2(item.content, 220)}${suffix}`;
+    })
+  ];
+  const modifiedFiles = (input.modifiedFiles ?? []).slice(0, 30).map((file) => {
+    const meta = [
+      file.status ? `status=${clip2(file.status, 40)}` : "",
+      typeof file.bytes === "number" ? `bytes=${file.bytes}` : ""
+    ].filter(Boolean).join(" ");
+    return `${clip2(file.path, 220)}${meta ? ` (${meta})` : ""}`;
+  });
+  const scenarioSeed = deriveScenarioSeed(input);
+  const lines = [];
+  lines.push(`[COMPLETION META-DECOMPOSITION]`);
+  lines.push(`Scenario seed: ${scenarioSeed}`);
+  lines.push(``);
+  lines.push(`Original request / goal text:`);
+  lines.push(clip2(input.taskText || input.contract.goalSummary, 1200) || "(not provided)");
+  lines.push(``);
+  lines.push(`Proposed completion claim text:`);
+  lines.push(proposedClaimText || "(no proposed completion text yet)");
+  lines.push(``);
+  lines.push(`Observed run evidence:`);
+  lines.push(...listLines(observedEvidence, "- no tool evidence recorded"));
+  lines.push(``);
+  lines.push(`Unresolved or caution signals:`);
+  lines.push(...listLines(unresolvedSignals, "- none recorded"));
+  lines.push(``);
+  lines.push(`Modified artifact digest:`);
+  lines.push(...listLines(modifiedFiles, "- no modified artifacts listed"));
+  lines.push(``);
+  lines.push(`Reviewer decomposition task:`);
+  lines.push(`- Invent a situation-specific completion scenario from the request, proposed claims, and observed run data above.`);
+  lines.push(`- Enumerate the material claims in the proposed completion text, including implied claims about created state, external effects, recipient-visible outcomes, runtime behavior, research facts, or absence of blockers when those claims appear in the text.`);
+  lines.push(`- For each claim, derive what would make it true from the claim's semantics, the user's request, and this run's observations.`);
+  lines.push(`- Map the claim to the observed evidence, contradictions, missing observations, and unresolved loops shown above.`);
+  lines.push(`- If an unsupported claim is material, propose the smallest next observation or correction; if the final wording already marks it unverified or blocked, treat that honesty as part of the evidence review.`);
+  return {
+    scenarioSeed,
+    prompt: lines.join("\n"),
+    proposedClaimText,
+    observedEvidence,
+    unresolvedSignals
+  };
+}
+function formatCompletionContract(contract, scenario) {
+  const lines = [];
+  lines.push(`[COMPLETION CONTRACT]`);
+  lines.push(`Goal: ${contract.goalSummary || "(no goal text)"}`);
+  lines.push(``);
+  lines.push(`Completion review policy:`);
+  lines.push(`- Derive material claims from the current request and proposed final answer.`);
+  lines.push(`- Compare those claims to observed tool results from this run.`);
+  lines.push(`- Treat missing, ambiguous, or failed observations as unverified rather than complete.`);
+  lines.push(`- Use the current request, proposed claims, and recorded observations as the source of truth.`);
+  lines.push(``);
+  lines.push(`Flow: execute -> scenario decomposition -> evidence review -> delivery readback.`);
+  if (scenario) {
+    lines.push(``);
+    lines.push(buildCompletionScenarioDecomposition({ contract, ...scenario }).prompt);
+  }
+  return lines.join("\n");
+}
+var init_completionContract = __esm({
+  "packages/orchestrator/dist/completionContract.js"() {
+    "use strict";
+  }
+});
+
+// packages/orchestrator/dist/completionLedger.js
+import { mkdirSync as mkdirSync44, readFileSync as readFileSync59, writeFileSync as writeFileSync38 } from "node:fs";
+import { dirname as dirname26 } from "node:path";
+function nowIso2(now = /* @__PURE__ */ new Date()) {
+  return now instanceof Date ? now.toISOString() : new Date(now).toISOString();
+}
+function cleanText(value2, max = 600) {
+  return String(value2 ?? "").replace(/\s+/g, " ").trim().slice(0, max);
+}
+function nextId2(prefix, count) {
+  return `${prefix}_${String(count + 1).padStart(4, "0")}`;
+}
+function createCompletionLedger(input) {
+  const ts = nowIso2(input.now);
+  return {
+    runId: input.runId,
+    goal: cleanText(input.goal, 2e3),
+    createdAtIso: ts,
+    updatedAtIso: ts,
+    proposedClaims: [],
+    evidence: [],
+    critiques: [],
+    unresolved: [],
+    status: "open"
+  };
+}
+function deriveClaimsFromProposedText(input) {
+  const raw = String(input.text ?? "").trim();
+  if (!raw)
+    return [];
+  const segments = raw.replace(/\b(?:done|completed|verified)\s*:\s*/gi, "").split(/(?:\n+|;\s+|,\s+(?=(?:and\s+)?(?:sent|built|created|updated|published|verified|tested|fixed|added|removed|deployed|wrote)\b)|\.\s+)/i).map((part) => cleanText(part, 300)).filter((part) => part.length > 0);
+  const unique2 = Array.from(new Set(segments.length > 0 ? segments : [cleanText(raw, 300)]));
+  const existingIds = new Set((input.existing ?? []).map((claim) => claim.id));
+  return unique2.map((text2, index) => {
+    const base3 = normalizeCompletionKey(text2, `claim_${index + 1}`).slice(0, 64);
+    let id = base3 || `claim_${index + 1}`;
+    let suffix = 2;
+    while (existingIds.has(id)) {
+      id = `${base3}_${suffix++}`;
+    }
+    existingIds.add(id);
+    return {
+      id,
+      text: text2,
+      source: input.source,
+      materiality: "high",
+      evidenceRequirement: "Observed evidence from this run supports the claim or the final response marks it unverified/blocked.",
+      evidenceIds: [],
+      status: "unverified"
+    };
+  });
+}
+function recordCompletionEvidence(ledger, evidence) {
+  const entry = {
+    id: evidence.id ?? nextId2("ev", ledger.evidence.length),
+    kind: evidence.kind,
+    observedAtIso: evidence.observedAtIso ?? nowIso2(),
+    summary: cleanText(evidence.summary, 1200),
+    toolName: evidence.toolName,
+    success: evidence.success,
+    rawRef: evidence.rawRef
+  };
+  return {
+    ...ledger,
+    evidence: [...ledger.evidence, entry],
+    updatedAtIso: entry.observedAtIso
+  };
+}
+function recordToolEvidence(ledger, input) {
+  const summary = [
+    input.name,
+    input.success === true ? "succeeded" : input.success === false ? "failed" : "observed",
+    input.argsKey ? `args=${cleanText(input.argsKey, 180)}` : "",
+    input.outputPreview ? `output=${cleanText(input.outputPreview, 700)}` : ""
+  ].filter(Boolean).join(" ");
+  return recordCompletionEvidence(ledger, {
+    kind: "tool_result",
+    toolName: input.name,
+    success: input.success,
+    summary,
+    rawRef: input.rawRef
+  });
+}
+function addCompletionClaims(ledger, claims) {
+  const byId = new Map(ledger.proposedClaims.map((claim) => [claim.id, claim]));
+  for (const claim of claims)
+    byId.set(claim.id, claim);
+  return {
+    ...ledger,
+    proposedClaims: Array.from(byId.values()),
+    updatedAtIso: nowIso2()
+  };
+}
+function reconcileClaimsWithEvidence(ledger) {
+  const successfulEvidence = ledger.evidence.filter((entry) => entry.success !== false);
+  const failedEvidence = ledger.evidence.filter((entry) => entry.success === false);
+  const claims = ledger.proposedClaims.map((claim) => {
+    const claimTerms = cleanText(claim.text, 300).toLowerCase().split(/[^a-z0-9]+/).filter((part) => part.length >= 4);
+    const matches = successfulEvidence.filter((entry) => {
+      const haystack = `${entry.toolName ?? ""} ${entry.summary}`.toLowerCase();
+      return claimTerms.some((term) => haystack.includes(term));
+    });
+    const contradictions = failedEvidence.filter((entry) => {
+      const haystack = `${entry.toolName ?? ""} ${entry.summary}`.toLowerCase();
+      return claimTerms.some((term) => haystack.includes(term));
+    });
+    if (contradictions.length > 0 && matches.length === 0) {
+      return { ...claim, evidenceIds: contradictions.map((entry) => entry.id), status: "contradicted" };
+    }
+    if (matches.length > 0) {
+      return { ...claim, evidenceIds: matches.map((entry) => entry.id), status: "supported" };
+    }
+    return { ...claim, evidenceIds: [], status: "unverified" };
+  });
+  return {
+    ...ledger,
+    proposedClaims: claims,
+    updatedAtIso: nowIso2()
+  };
+}
+function recordCompletionCritique(ledger, input) {
+  const critique = {
+    id: input.id ?? nextId2("critique", ledger.critiques.length),
+    verdict: input.verdict,
+    rationale: cleanText(input.rationale, 1200),
+    feedback: input.feedback ? cleanText(input.feedback, 3e3) : void 0,
+    recordedAtIso: input.recordedAtIso ?? nowIso2(),
+    evidenceSequence: ledger.evidence.length
+  };
+  return {
+    ...ledger,
+    critiques: [...ledger.critiques, critique],
+    status: input.verdict === "approve" ? "approved" : input.verdict,
+    updatedAtIso: critique.recordedAtIso
+  };
+}
+function buildCriticPacketFromLedger(ledger) {
+  const latestCritique = ledger.critiques.at(-1);
+  const evidenceSinceCritique = latestCritique ? ledger.evidence.slice(latestCritique.evidenceSequence) : [];
+  const lines = [];
+  lines.push("[COMPLETION LEDGER]");
+  lines.push(`Run: ${ledger.runId}`);
+  lines.push(`Goal: ${ledger.goal || "(not recorded)"}`);
+  lines.push(`Status: ${ledger.status}`);
+  lines.push("");
+  lines.push("Claims:");
+  if (ledger.proposedClaims.length === 0)
+    lines.push("- none recorded");
+  for (const claim of ledger.proposedClaims) {
+    lines.push(`- [${claim.status}] ${claim.id}: ${claim.text}`);
+    lines.push(`  evidence: ${claim.evidenceIds.length > 0 ? claim.evidenceIds.join(", ") : "none"}`);
+    lines.push(`  requirement: ${claim.evidenceRequirement}`);
+  }
+  lines.push("");
+  lines.push("Evidence:");
+  if (ledger.evidence.length === 0)
+    lines.push("- none recorded");
+  for (const evidence of ledger.evidence.slice(-40)) {
+    const status = evidence.success === true ? "ok" : evidence.success === false ? "failed" : "unknown";
+    lines.push(`- ${evidence.id} [${status}] ${evidence.kind}${evidence.toolName ? `/${evidence.toolName}` : ""}: ${evidence.summary}`);
+  }
+  if (latestCritique) {
+    lines.push("");
+    lines.push("Prior critique:");
+    lines.push(`- verdict: ${latestCritique.verdict}`);
+    lines.push(`- rationale: ${latestCritique.rationale}`);
+    if (latestCritique.feedback)
+      lines.push(`- feedback: ${latestCritique.feedback}`);
+    lines.push("");
+    lines.push("Evidence recorded after prior critique:");
+    if (evidenceSinceCritique.length === 0)
+      lines.push("- none recorded");
+    for (const evidence of evidenceSinceCritique) {
+      const status = evidence.success === true ? "ok" : evidence.success === false ? "failed" : "unknown";
+      lines.push(`- ${evidence.id} [${status}] ${evidence.summary}`);
+    }
+  }
+  if (ledger.unresolved.length > 0) {
+    lines.push("");
+    lines.push("Unresolved:");
+    for (const item of ledger.unresolved.slice(-20))
+      lines.push(`- ${item.text}`);
+  }
+  return lines.join("\n");
+}
+function saveCompletionLedger(filePath, ledger) {
+  mkdirSync44(dirname26(filePath), { recursive: true });
+  writeFileSync38(filePath, `${JSON.stringify(ledger, null, 2)}
+`, "utf8");
+}
+function loadCompletionLedger(filePath) {
+  return JSON.parse(readFileSync59(filePath, "utf8"));
+}
+var init_completionLedger = __esm({
+  "packages/orchestrator/dist/completionLedger.js"() {
+    "use strict";
+    init_completionContract();
+  }
+});
+
 // packages/orchestrator/dist/ollama-pool-cleanup.js
 var ollama_pool_cleanup_exports = {};
 __export(ollama_pool_cleanup_exports, {
@@ -553820,7 +554280,7 @@ var init_ollama_pool_cleanup = __esm({
 
 // packages/orchestrator/dist/ollama-pool.js
 import { spawn as spawn23, exec as exec2 } from "node:child_process";
-import { existsSync as existsSync76, readFileSync as readFileSync59, readdirSync as readdirSync23, statfsSync as statfsSync3, statSync as statSync29 } from "node:fs";
+import { existsSync as existsSync76, readFileSync as readFileSync60, readdirSync as readdirSync23, statfsSync as statfsSync3, statSync as statSync29 } from "node:fs";
 import { homedir as homedir29 } from "node:os";
 import { join as join89 } from "node:path";
 import { createServer as createServer3 } from "node:net";
@@ -553870,7 +554330,7 @@ function listOllamaPids() {
   try {
     return readdirSync23("/proc", { withFileTypes: true }).filter((d2) => d2.isDirectory() && /^\d+$/.test(d2.name)).map((d2) => d2.name).filter((pid) => {
       try {
-        const comm = readFileSync59(`/proc/${pid}/comm`, "utf8").trim();
+        const comm = readFileSync60(`/proc/${pid}/comm`, "utf8").trim();
         return comm === "ollama";
       } catch {
         return false;
@@ -553882,7 +554342,7 @@ function listOllamaPids() {
 }
 function readProcEnvValue(pid, key) {
   try {
-    const raw = readFileSync59(`/proc/${pid}/environ`, "utf8");
+    const raw = readFileSync60(`/proc/${pid}/environ`, "utf8");
     for (const entry of raw.split("\0")) {
       const idx = entry.indexOf("=");
       if (idx <= 0)
@@ -553898,11 +554358,11 @@ function readProcEnvValue(pid, key) {
 }
 function inferHomeFromProcUid(pid) {
   try {
-    const status = readFileSync59(`/proc/${pid}/status`, "utf8");
+    const status = readFileSync60(`/proc/${pid}/status`, "utf8");
     const uid = status.match(/^Uid:\s+(\d+)/m)?.[1];
     if (!uid)
       return null;
-    const passwd = readFileSync59("/etc/passwd", "utf8");
+    const passwd = readFileSync60("/etc/passwd", "utf8");
     for (const line of passwd.split("\n")) {
       const parts = line.split(":");
       if (parts.length >= 7 && parts[2] === uid)
@@ -553928,7 +554388,7 @@ function detectPeerOmniusOllamaPool() {
     if (e2.name === selfPid || e2.name === selfPpid)
       continue;
     try {
-      const cmdline = readFileSync59(`/proc/${e2.name}/cmdline`, "utf8");
+      const cmdline = readFileSync60(`/proc/${e2.name}/cmdline`, "utf8");
       if (!cmdline.includes("node"))
         continue;
       if (!/[/\\]omnius[/\\]dist[/\\]index\.js|[/\\]omnius[/\\]/i.test(cmdline))
@@ -553941,12 +554401,12 @@ function detectPeerOmniusOllamaPool() {
     return false;
   for (const e2 of entries) {
     try {
-      const cmd = readFileSync59(`/proc/${e2.name}/cmdline`, "utf8");
+      const cmd = readFileSync60(`/proc/${e2.name}/cmdline`, "utf8");
       if (!cmd.includes("ollama"))
         continue;
       if (!cmd.split("\0").includes("serve"))
         continue;
-      const status = readFileSync59(`/proc/${e2.name}/status`, "utf8");
+      const status = readFileSync60(`/proc/${e2.name}/status`, "utf8");
       const ppid = status.match(/^PPid:\s+(\d+)/m)?.[1];
       if (ppid && peerNodePids.has(ppid))
         return true;
@@ -554077,7 +554537,7 @@ function snapshotDisk(path12) {
 }
 function snapshotNetwork() {
   try {
-    const raw = readFileSync59("/proc/net/dev", "utf8");
+    const raw = readFileSync60("/proc/net/dev", "utf8");
     let rxBytes = 0;
     let txBytes = 0;
     for (const line of raw.split("\n")) {
@@ -555627,8 +556087,8 @@ var init_artifact_inspector = __esm({
 });
 
 // packages/orchestrator/dist/lesson-bank.js
-import { existsSync as existsSync78, mkdirSync as mkdirSync44, appendFileSync as appendFileSync4, readFileSync as readFileSync60 } from "node:fs";
-import { join as join90, dirname as dirname26 } from "node:path";
+import { existsSync as existsSync78, mkdirSync as mkdirSync45, appendFileSync as appendFileSync4, readFileSync as readFileSync61 } from "node:fs";
+import { join as join90, dirname as dirname27 } from "node:path";
 import { createHash as createHash25 } from "node:crypto";
 function tokenize4(text2) {
   if (!text2)
@@ -555665,7 +556125,7 @@ function lessonBankPath(workingDir) {
 }
 function bank(lesson, workingDir) {
   const path12 = lessonBankPath(workingDir);
-  mkdirSync44(dirname26(path12), { recursive: true });
+  mkdirSync45(dirname27(path12), { recursive: true });
   appendFileSync4(path12, JSON.stringify(lesson) + "\n", "utf-8");
 }
 function readAll(workingDir) {
@@ -555673,7 +556133,7 @@ function readAll(workingDir) {
   if (!existsSync78(path12))
     return [];
   try {
-    const raw = readFileSync60(path12, "utf-8");
+    const raw = readFileSync61(path12, "utf-8");
     const out = [];
     for (const line of raw.split(/\r?\n/)) {
       const trimmed = line.trim();
@@ -555730,8 +556190,8 @@ var init_lesson_bank = __esm({
 });
 
 // packages/orchestrator/dist/intervention-replay.js
-import { existsSync as existsSync79, mkdirSync as mkdirSync45, readFileSync as readFileSync61, writeFileSync as writeFileSync38, readdirSync as readdirSync24 } from "node:fs";
-import { join as join91, dirname as dirname27 } from "node:path";
+import { existsSync as existsSync79, mkdirSync as mkdirSync46, readFileSync as readFileSync62, writeFileSync as writeFileSync39, readdirSync as readdirSync24 } from "node:fs";
+import { join as join91, dirname as dirname28 } from "node:path";
 function checkpointDir2(workingDir) {
   return workingDir ? join91(workingDir, ".omnius", "checkpoints") : join91(process.env["HOME"] || ".", ".omnius", "checkpoints");
 }
@@ -555748,8 +556208,8 @@ function writeCheckpoint(args) {
       notes: args.notes
     };
     const path12 = checkpointPath(args.workingDir, args.turn);
-    mkdirSync45(dirname27(path12), { recursive: true });
-    writeFileSync38(path12, JSON.stringify(snap), "utf-8");
+    mkdirSync46(dirname28(path12), { recursive: true });
+    writeFileSync39(path12, JSON.stringify(snap), "utf-8");
   } catch {
   }
 }
@@ -555789,13 +556249,13 @@ var init_intervention_replay = __esm({
 });
 
 // packages/orchestrator/dist/world-state-disk-scan.js
-import { existsSync as existsSync80, readFileSync as readFileSync62, readdirSync as readdirSync25, statSync as statSync31 } from "node:fs";
+import { existsSync as existsSync80, readFileSync as readFileSync63, readdirSync as readdirSync25, statSync as statSync31 } from "node:fs";
 import { join as join92, relative as relative8, basename as basename20 } from "node:path";
 function loadIgnoreFile(path12) {
   if (!existsSync80(path12))
     return [];
   try {
-    const lines = readFileSync62(path12, "utf-8").split(/\r?\n/);
+    const lines = readFileSync63(path12, "utf-8").split(/\r?\n/);
     const out = [];
     for (const raw of lines) {
       const line = raw.trim();
@@ -556145,8 +556605,8 @@ var init_world_state_plan_reconciler = __esm({
 });
 
 // packages/orchestrator/dist/world-state-drift-detector.js
-import { existsSync as existsSync82, readFileSync as readFileSync63, statSync as statSync33 } from "node:fs";
-import { dirname as dirname28, isAbsolute as isAbsolute7, join as join94, resolve as pathResolve } from "node:path";
+import { existsSync as existsSync82, readFileSync as readFileSync64, statSync as statSync33 } from "node:fs";
+import { dirname as dirname29, isAbsolute as isAbsolute7, join as join94, resolve as pathResolve } from "node:path";
 function parseImports(source) {
   const out = [];
   const lines = source.split(/\r?\n/);
@@ -556303,7 +556763,7 @@ function loadProjectAliases(workingDir) {
     if (!existsSync82(path12))
       continue;
     try {
-      const raw = readFileSync63(path12, "utf-8");
+      const raw = readFileSync64(path12, "utf-8");
       const parsed = JSON.parse(stripJsonComments(raw));
       const co = parsed?.compilerOptions;
       const paths = co?.paths;
@@ -556344,7 +556804,7 @@ function resolveImportPath2(importingFile, source, workingDir, aliases) {
   }
   if (bestAlias)
     resolvedSpec = aliases[bestAlias] + source.slice(bestAlias.length);
-  const importerDir = dirname28(importingFile);
+  const importerDir = dirname29(importingFile);
   const base3 = resolvedSpec.startsWith(".") ? pathResolve(importerDir, resolvedSpec) : resolvedSpec.startsWith("/") ? resolvedSpec : pathResolve(workingDir, resolvedSpec);
   const candidates = [];
   for (const ext of FILE_EXTENSIONS)
@@ -556392,7 +556852,7 @@ function detectDrift(files, opts) {
   const exportsCache = /* @__PURE__ */ new Map();
   const readSource = (path12) => {
     try {
-      const buf = readFileSync63(path12);
+      const buf = readFileSync64(path12);
       if (buf.length > maxBytes)
         return buf.slice(0, maxBytes).toString("utf-8");
       return buf.toString("utf-8");
@@ -556806,6 +557266,11 @@ function renderCriticPrompt(inputs) {
     }
     lines.push(``);
   }
+  if (inputs.workboardSynthesisContext && inputs.workboardSynthesisContext.trim().length > 0) {
+    lines.push(`## Workboard synthesis context (multi-agent board)`);
+    lines.push(inputs.workboardSynthesisContext.trim().slice(0, 3e3));
+    lines.push(``);
+  }
   lines.push(`## Files modified (${inputs.diff.length} total)`);
   if (inputs.diff.length === 0) {
     lines.push(`(no file changes detected — this run produced no on-disk artifacts)`);
@@ -557002,7 +557467,7 @@ var init_backward_pass_critic = __esm({
 });
 
 // packages/orchestrator/dist/backward-pass-runner.js
-import { existsSync as existsSync83, readFileSync as readFileSync64, statSync as statSync34 } from "node:fs";
+import { existsSync as existsSync83, readFileSync as readFileSync65, statSync as statSync34 } from "node:fs";
 import { execSync as execSync45 } from "node:child_process";
 import { isAbsolute as isAbsolute8, join as join95, relative as relative9 } from "node:path";
 function collectDiff(opts) {
@@ -557062,7 +557527,7 @@ function collectDiff(opts) {
 }
 function readPreview(absPath, maxBytes) {
   try {
-    const buf = readFileSync64(absPath);
+    const buf = readFileSync65(absPath);
     if (buf.length === 0)
       return "";
     const sniff = buf.slice(0, Math.min(8192, buf.length));
@@ -557106,7 +557571,8 @@ async function runBackwardPass(opts) {
     openLoops: opts.openLoops,
     systemPromptDigest: opts.systemPromptDigest,
     cycle: opts.cycle,
-    maxCycles: opts.maxCycles
+    maxCycles: opts.maxCycles,
+    workboardSynthesisContext: opts.workboardSynthesisContext
   };
   const prompt = renderCriticPrompt(inputs);
   const promptBytes = Buffer.byteLength(prompt, "utf-8");
@@ -559162,7 +559628,7 @@ var init_hooks = __esm({
 });
 
 // packages/orchestrator/dist/todo-context-chunker.js
-import { mkdirSync as mkdirSync48, writeFileSync as writeFileSync41, readFileSync as readFileSync67, existsSync as existsSync86, readdirSync as readdirSync26 } from "node:fs";
+import { mkdirSync as mkdirSync49, writeFileSync as writeFileSync42, readFileSync as readFileSync68, existsSync as existsSync86, readdirSync as readdirSync26 } from "node:fs";
 import { join as join98 } from "node:path";
 function chunkDir(workingDir) {
   return join98(workingDir, ".omnius", "todo-chunks");
@@ -559378,16 +559844,16 @@ async function runTodoChunker(opts) {
 function persistTodoChunk(workingDir, chunk) {
   const dir = chunkDir(workingDir);
   if (!existsSync86(dir)) {
-    mkdirSync48(dir, { recursive: true });
+    mkdirSync49(dir, { recursive: true });
   }
-  writeFileSync41(chunkPath(workingDir, chunk.todoId), JSON.stringify(chunk, null, 2), "utf-8");
+  writeFileSync42(chunkPath(workingDir, chunk.todoId), JSON.stringify(chunk, null, 2), "utf-8");
 }
 function loadTodoChunk(workingDir, todoId) {
   const p2 = chunkPath(workingDir, todoId);
   if (!existsSync86(p2))
     return null;
   try {
-    return JSON.parse(readFileSync67(p2, "utf-8"));
+    return JSON.parse(readFileSync68(p2, "utf-8"));
   } catch {
     return null;
   }
@@ -559952,191 +560418,6 @@ var init_specDecomposer = __esm({
   }
 });
 
-// packages/orchestrator/dist/completionContract.js
-function normalizeText(value2, max = 500) {
-  const text2 = String(value2 ?? "").trim().replace(/\s+/g, " ");
-  return text2 ? text2.slice(0, max) : "";
-}
-function normalizeCompletionKey(value2, fallback = "item") {
-  const key = String(value2 ?? fallback).trim().toLowerCase().replace(/[^a-z0-9_.:-]+/g, "_").replace(/_{2,}/g, "_").replace(/^[_:.-]+|[_:.-]+$/g, "").slice(0, 96);
-  return key || fallback;
-}
-function genericField(key, label, description, acceptanceCriteria) {
-  return {
-    key: normalizeCompletionKey(key),
-    label,
-    fieldType: "json",
-    elevation: "required",
-    sourceMode: "derived",
-    description,
-    acceptanceCriteria
-  };
-}
-function inferCompletionContract(taskText) {
-  const goalSummary = normalizeText(taskText);
-  const fields = [
-    genericField("claims.evidence_map", "Claim evidence map", "A run-local mapping from each final claim to the observed result that supports it.", "Each material claim is either backed by observed evidence from this run or named as unverified/blocked."),
-    genericField("claims.unverified", "Unverified claims", "Claims that could not be proven from the run's observations.", "Unverified claims are not presented as completed work.")
-  ];
-  const phases = [
-    {
-      key: "execute",
-      label: "Execute",
-      instructions: "Do the requested work while preserving observations needed to evaluate the result.",
-      requirementIds: [],
-      fields: [],
-      gate: {
-        key: "execution_trace",
-        instructions: "Keep enough concrete run output to distinguish facts from assumptions."
-      }
-    },
-    {
-      key: "verify",
-      label: "Verify",
-      instructions: "Derive the needed evidence from the actual request and final claims, then compare those claims to observed results.",
-      requirementIds: [],
-      fields,
-      gate: {
-        key: "claim_evidence_review",
-        instructions: "Judge whether the actual claim is supported by the actual observations."
-      }
-    },
-    {
-      key: "deliver",
-      label: "Deliver",
-      instructions: "Report completed, verified, unverified, and blocked items without overstating what was observed.",
-      requirementIds: [],
-      fields: [],
-      gate: {
-        key: "result_readback",
-        instructions: "Final wording must not exceed the observed evidence."
-      }
-    }
-  ];
-  return {
-    goalSummary,
-    surfaces: [],
-    fields,
-    requirements: [],
-    phases,
-    acceptanceCriteria: [
-      "The final response distinguishes completed work from verified evidence and unverified or blocked claims."
-    ]
-  };
-}
-function inferCompletionContractFromTexts(texts, fallbackSummary = "") {
-  const combined = texts.map((text2) => String(text2 ?? "").trim()).filter(Boolean).join("\n\n");
-  return inferCompletionContract(combined || fallbackSummary);
-}
-function clip2(value2, max = 500) {
-  return normalizeText(value2, max);
-}
-function listLines(items, empty2 = "- none observed") {
-  return items.length > 0 ? items.map((item) => `- ${item}`) : [empty2];
-}
-function formatEvidenceEntry(entry) {
-  const parts = [
-    entry.success === true ? "ok" : entry.success === false ? "failed" : "unknown",
-    entry.name ? `tool=${clip2(entry.name, 80)}` : "",
-    typeof entry.turn === "number" ? `turn=${entry.turn}` : "",
-    entry.mutated ? "mutated=true" : "",
-    entry.argsKey ? `args=${clip2(entry.argsKey, 180)}` : "",
-    entry.outputPreview ? `observed=${clip2(entry.outputPreview, 260)}` : ""
-  ].filter(Boolean);
-  return parts.join(" ");
-}
-function deriveScenarioSeed(input) {
-  const text2 = [
-    input.taskText,
-    input.contract.goalSummary,
-    input.proposedSummary,
-    input.answerText
-  ].map((part) => String(part ?? "").trim()).filter(Boolean).join("\n");
-  const normalized = normalizeCompletionKey(text2.slice(0, 140), "completion_scenario");
-  return normalized || "completion_scenario";
-}
-function buildCompletionScenarioDecomposition(input) {
-  const proposedClaimText = [
-    input.proposedSummary ? `task_complete summary:
-${String(input.proposedSummary).trim()}` : "",
-    input.answerText ? `assistant visible answer:
-${String(input.answerText).trim()}` : ""
-  ].filter(Boolean).join("\n\n").slice(0, 4e3);
-  const observedEvidence = (input.log ?? []).slice(-40).map(formatEvidenceEntry);
-  const unresolvedSignals = [
-    ...(input.openLoops ?? []).map((item) => `open loop: ${clip2(item, 260)}`),
-    ...(input.recentFailures ?? []).map((item) => `recent failure: ${clip2(item, 260)}`),
-    ...(input.planStatus ?? []).filter((item) => item.status || item.reconciled || item.rationale).map((item) => {
-      const state = [item.status, item.reconciled].filter(Boolean).join("/");
-      const suffix = item.rationale ? ` (${clip2(item.rationale, 180)})` : "";
-      return `plan ${state || "observed"}: ${clip2(item.content, 220)}${suffix}`;
-    })
-  ];
-  const modifiedFiles = (input.modifiedFiles ?? []).slice(0, 30).map((file) => {
-    const meta = [
-      file.status ? `status=${clip2(file.status, 40)}` : "",
-      typeof file.bytes === "number" ? `bytes=${file.bytes}` : ""
-    ].filter(Boolean).join(" ");
-    return `${clip2(file.path, 220)}${meta ? ` (${meta})` : ""}`;
-  });
-  const scenarioSeed = deriveScenarioSeed(input);
-  const lines = [];
-  lines.push(`[COMPLETION META-DECOMPOSITION]`);
-  lines.push(`Scenario seed: ${scenarioSeed}`);
-  lines.push(``);
-  lines.push(`Original request / goal text:`);
-  lines.push(clip2(input.taskText || input.contract.goalSummary, 1200) || "(not provided)");
-  lines.push(``);
-  lines.push(`Proposed completion claim text:`);
-  lines.push(proposedClaimText || "(no proposed completion text yet)");
-  lines.push(``);
-  lines.push(`Observed run evidence:`);
-  lines.push(...listLines(observedEvidence, "- no tool evidence recorded"));
-  lines.push(``);
-  lines.push(`Unresolved or caution signals:`);
-  lines.push(...listLines(unresolvedSignals, "- none recorded"));
-  lines.push(``);
-  lines.push(`Modified artifact digest:`);
-  lines.push(...listLines(modifiedFiles, "- no modified artifacts listed"));
-  lines.push(``);
-  lines.push(`Reviewer decomposition task:`);
-  lines.push(`- Invent a situation-specific completion scenario from the request, proposed claims, and observed run data above.`);
-  lines.push(`- Enumerate the material claims in the proposed completion text, including implied claims about created state, external effects, recipient-visible outcomes, runtime behavior, research facts, or absence of blockers when those claims appear in the text.`);
-  lines.push(`- For each claim, derive what would make it true from the claim's semantics, the user's request, and this run's observations.`);
-  lines.push(`- Map the claim to the observed evidence, contradictions, missing observations, and unresolved loops shown above.`);
-  lines.push(`- If an unsupported claim is material, propose the smallest next observation or correction; if the final wording already marks it unverified or blocked, treat that honesty as part of the evidence review.`);
-  return {
-    scenarioSeed,
-    prompt: lines.join("\n"),
-    proposedClaimText,
-    observedEvidence,
-    unresolvedSignals
-  };
-}
-function formatCompletionContract(contract, scenario) {
-  const lines = [];
-  lines.push(`[COMPLETION CONTRACT]`);
-  lines.push(`Goal: ${contract.goalSummary || "(no goal text)"}`);
-  lines.push(``);
-  lines.push(`Completion review policy:`);
-  lines.push(`- Derive material claims from the current request and proposed final answer.`);
-  lines.push(`- Compare those claims to observed tool results from this run.`);
-  lines.push(`- Treat missing, ambiguous, or failed observations as unverified rather than complete.`);
-  lines.push(`- Use the current request, proposed claims, and recorded observations as the source of truth.`);
-  lines.push(``);
-  lines.push(`Flow: execute -> scenario decomposition -> evidence review -> delivery readback.`);
-  if (scenario) {
-    lines.push(``);
-    lines.push(buildCompletionScenarioDecomposition({ contract, ...scenario }).prompt);
-  }
-  return lines.join("\n");
-}
-var init_completionContract = __esm({
-  "packages/orchestrator/dist/completionContract.js"() {
-    "use strict";
-  }
-});
-
 // packages/orchestrator/dist/modelProfile.js
 function resolveModelProfile(model) {
   const m2 = model.toLowerCase();
@@ -560811,6 +561092,82 @@ context_fabric: included=${included.length} dropped=${dropped.length} truncated=
   }
 });
 
+// packages/orchestrator/dist/contextEngine.js
+function estimateTokens3(messages2) {
+  const chars = messages2.reduce((sum, message2) => sum + message2.content.length + message2.role.length + (message2.name?.length ?? 0), 0);
+  return Math.ceil(chars / 4);
+}
+function evidenceMessage(event) {
+  const status = event.success === true ? "ok" : event.success === false ? "failed" : "unknown";
+  const parts = [
+    `tool=${event.name}`,
+    `status=${status}`,
+    typeof event.turn === "number" ? `turn=${event.turn}` : "",
+    event.evidenceId ? `evidence=${event.evidenceId}` : "",
+    event.outputPreview ? `observed=${event.outputPreview}` : ""
+  ].filter(Boolean);
+  return { role: "system", content: `[RUN EVIDENCE] ${parts.join(" ")}` };
+}
+function createDefaultContextEngine() {
+  return new DefaultContextEngine();
+}
+var DefaultContextEngine;
+var init_contextEngine = __esm({
+  "packages/orchestrator/dist/contextEngine.js"() {
+    "use strict";
+    DefaultContextEngine = class {
+      async build(input) {
+        return this.render(input, false);
+      }
+      async compact(input) {
+        return this.render(input, true);
+      }
+      render(input, allowCompaction) {
+        const evidence = (input.toolEvents ?? []).map(evidenceMessage);
+        const hints = (input.memoryHints ?? []).filter((hint) => hint.trim().length > 0).slice(-8).map((hint) => ({ role: "system", content: `[MEMORY HINT] ${hint.trim()}` }));
+        const contract = input.runState?.completionContract ? [{ role: "system", content: input.runState.completionContract }] : [];
+        const beforeMessages = [...evidence, ...hints, ...contract, ...input.messages];
+        const before = estimateTokens3(beforeMessages);
+        const budget = input.runState?.tokenBudget;
+        let compactedMessages = input.messages;
+        let compacted = false;
+        let evidenceDropped = 0;
+        if (allowCompaction && budget && before > budget) {
+          const overhead = estimateTokens3([...evidence, ...hints, ...contract]);
+          const retained = [];
+          let used = overhead;
+          for (const message2 of [...input.messages].reverse()) {
+            const cost = estimateTokens3([message2]);
+            if (used + cost > budget)
+              continue;
+            retained.push(message2);
+            used += cost;
+          }
+          compactedMessages = retained.reverse();
+          compacted = compactedMessages.length !== input.messages.length;
+          evidenceDropped = 0;
+        }
+        const allMessages = [...evidence, ...hints, ...contract, ...compactedMessages];
+        const after = estimateTokens3(allMessages);
+        return {
+          systemMessages: allMessages.filter((m2) => m2.role === "system"),
+          conversationMessages: allMessages.filter((m2) => m2.role !== "system"),
+          compacted,
+          diagnostics: {
+            surface: input.surface,
+            tokenEstimateBefore: before,
+            tokenEstimateAfter: after,
+            compacted,
+            compactionStrategy: compacted ? "drop_oldest_non_evidence" : "none",
+            evidenceRetained: evidence.length,
+            evidenceDropped
+          }
+        };
+      }
+    };
+  }
+});
+
 // packages/orchestrator/dist/preflightSnapshot.js
 var preflightSnapshot_exports = {};
 __export(preflightSnapshot_exports, {
@@ -560818,7 +561175,7 @@ __export(preflightSnapshot_exports, {
   formatPreflightStatus: () => formatPreflightStatus,
   freeDiskBytes: () => freeDiskBytes
 });
-import { existsSync as existsSync87, readFileSync as readFileSync68, statSync as statSync35 } from "node:fs";
+import { existsSync as existsSync87, readFileSync as readFileSync69, statSync as statSync35 } from "node:fs";
 import { execSync as execSync47 } from "node:child_process";
 import { homedir as homedir30, platform as platform3, arch as arch2, totalmem as totalmem3, freemem as freemem3, hostname as hostname3 } from "node:os";
 import { join as join99 } from "node:path";
@@ -560832,7 +561189,7 @@ function capturePreflightSnapshot(workingDir) {
       continue;
     let raw;
     try {
-      raw = readFileSync68(expanded, "utf8");
+      raw = readFileSync69(expanded, "utf8");
     } catch {
       continue;
     }
@@ -560850,7 +561207,7 @@ function capturePreflightSnapshot(workingDir) {
           continue;
         let raw;
         try {
-          raw = readFileSync68(projectPath, "utf8");
+          raw = readFileSync69(projectPath, "utf8");
         } catch {
           continue;
         }
@@ -561053,7 +561410,7 @@ __export(postActionVerifier_exports, {
   classifyShellIntent: () => classifyShellIntent,
   verifyShellOutcome: () => verifyShellOutcome
 });
-import { existsSync as existsSync88, readFileSync as readFileSync69, readdirSync as readdirSync27, statSync as statSync36 } from "node:fs";
+import { existsSync as existsSync88, readFileSync as readFileSync70, readdirSync as readdirSync27, statSync as statSync36 } from "node:fs";
 import { join as join100 } from "node:path";
 function classifyShellIntent(cmd) {
   const stripped = cmd.replace(/^cd\s+\S+\s*&&\s*/, "").trim();
@@ -561146,7 +561503,7 @@ function checkManifestInvariant(cwd4, fallbackBucket) {
       continue;
     let declared;
     try {
-      declared = pattern.parseDeps(readFileSync69(manifestPath2, "utf8"));
+      declared = pattern.parseDeps(readFileSync70(manifestPath2, "utf8"));
     } catch {
       continue;
     }
@@ -562330,6 +562687,7 @@ var init_agenticRunner = __esm({
   "packages/orchestrator/dist/agenticRunner.js"() {
     "use strict";
     init_textSanitize();
+    init_completionLedger();
     init_dist6();
     init_ollama_pool();
     init_personality();
@@ -562355,6 +562713,7 @@ var init_agenticRunner = __esm({
     init_contextTree();
     init_codeGraphLink();
     init_dist5();
+    init_dist5();
     init_tool_batching();
     init_hooks();
     init_todo_context_chunker();
@@ -562365,6 +562724,7 @@ var init_agenticRunner = __esm({
     init_modelProfile();
     init_failureHandoff();
     init_context_fabric();
+    init_contextEngine();
     TOOL_SUBSETS = {
       web: ["web_search", "web_fetch", "web_crawl"],
       code: [
@@ -562441,6 +562801,7 @@ var init_agenticRunner = __esm({
       backend;
       tools = /* @__PURE__ */ new Map();
       options;
+      _onTypedEvent;
       handlers = [];
       pendingUserMessages = [];
       aborted = false;
@@ -562691,6 +563052,7 @@ var init_agenticRunner = __esm({
       // Reset whenever a completion is allowed.
       _completionHoldState = { count: 0, lastKey: "" };
       _completionIncompleteVerification = null;
+      _completionLedger = null;
       // ── WO-AM-01/04/10: Associative memory stores ──
       // Episode store: every tool call → persistent episode with importance + decay
       // Temporal KG: entities + relations with temporal validity (valid_from/valid_until)
@@ -562811,6 +563173,8 @@ var init_agenticRunner = __esm({
       _lastPprSig = null;
       _lastPprMemoryLines = [];
       _pprSkipCount = 0;
+      // WO-07: Durable Multi-Agent Kanban — workboard integration
+      _workboard = null;
       // Phase 2 — tool subset expansion and usage tracking.
       // Tools promoted from deferred → inline by tool_search (or by subset
       // expansion). They stay inline for the rest of the run unless idle past
@@ -562841,6 +563205,10 @@ var init_agenticRunner = __esm({
       _lastContextPressureSnapshot = null;
       _lastActiveForgettingReport = null;
       _lastContextConsolidationTurn = -1e3;
+      /** WO-CE-BOUNDARY: Context engine instance for structured context assembly */
+      _contextEngine;
+      /** WO-CE-BOUNDARY: Collected tool events for context engine input */
+      _toolEvents = [];
       /** WO-AM-10: Process pending episode embeddings in background batches */
       async processPendingEmbeddings() {
         if (this._pendingEmbeddings.length === 0 || !this._episodeStore)
@@ -562875,6 +563243,126 @@ var init_agenticRunner = __esm({
       }
       // Never block tools: we rely on guidance and repetition handling rather than
       // modifying the available tool set.
+      // ── WO-07: Durable Multi-Agent Kanban integration ──
+      /** Get or create the workboard for this run. Lazily initialized. */
+      _workboardDir() {
+        return this.options.workboardDir || this._workingDirectory || process.cwd();
+      }
+      getOrCreateWorkboard() {
+        if (this._workboard)
+          return this._workboard;
+        const dir = this._workboardDir();
+        const runId = this._sessionId;
+        const existing = loadWorkboardSnapshot(dir, runId);
+        if (existing) {
+          this._workboard = existing;
+          return existing;
+        }
+        try {
+          this._workboard = createWorkboard(dir, {
+            runId,
+            owner: this.options.subAgent ? "sub-agent" : "agent",
+            title: (this._taskState.goal || "").slice(0, 120) || void 0
+          });
+        } catch {
+          this._workboard = loadWorkboardSnapshot(dir, runId);
+        }
+        return this._workboard;
+      }
+      /**
+       * Build a compact workboard context string for injection into the
+       * system prompt. Returns null when no active board exists or when
+       * the board has no active cards worth surfacing (short-lived tasks).
+       * Injects for sub-agents and long-running admin tasks.
+       */
+      injectWorkboardContext() {
+        if (this._workboard || this.options.subAgent) {
+          const dir = this._workboardDir();
+          const snapshot = readActiveWorkboardSnapshot(dir, this._sessionId);
+          if (!snapshot)
+            return null;
+          const activeCards = snapshot.cards.filter((c8) => c8.status === "in_progress" || c8.status === "open" || c8.status === "needs_changes");
+          if (activeCards.length === 0 && snapshot.cards.every((c8) => c8.status === "verified" || c8.status === "completed"))
+            return null;
+          const synthesis = buildWorkboardSynthesisContext(snapshot);
+          const parts = [];
+          if (synthesis.verifiedCards.length > 0) {
+            parts.push(`Verified: ${synthesis.verifiedCards.length}`);
+          }
+          if (synthesis.unresolvedBlockers.length > 0) {
+            parts.push(`Blockers: ${synthesis.unresolvedBlockers.length}`);
+          }
+          if (activeCards.length > 0) {
+            parts.push(`Active: ${activeCards.length}`);
+          }
+          if (snapshot.cards.length > 0) {
+            const compact3 = compactWorkboardSnapshot(snapshot, 12);
+            parts.push(`
+${formatWorkboardCompact(snapshot, 12)}`);
+          }
+          return parts.length > 0 ? `<workboard-status>
+${parts.join("\n")}
+</workboard-status>` : null;
+        }
+        return null;
+      }
+      /**
+       * Record evidence from a tool call against the active workboard.
+       * Matches by card assignee when the card is in progress.
+       * Non-fatal: failures to attach evidence are silently caught.
+       */
+      recordWorkboardToolCall(toolName, args, success, output) {
+        const board = this._workboard ?? this.getOrCreateWorkboard();
+        if (!board)
+          return;
+        if (toolName === "task_complete" || toolName === "workboard_create")
+          return;
+        const dir = this._workboardDir();
+        try {
+          const evidenceSummary = `${toolName} ${success ? "ok" : "fail"}`;
+          const evidenceContent = (success ? typeof output === "string" ? output : "" : "").slice(0, 1e3);
+          const evidence = {
+            kind: "tool_result",
+            summary: evidenceSummary,
+            tool: toolName,
+            content: evidenceContent,
+            command: typeof args["command"] === "string" ? args["command"]?.slice(0, 200) : void 0,
+            ref: typeof args["path"] === "string" ? args["path"]?.slice(0, 200) : void 0
+          };
+          const actor = this.options.subAgent ? "sub-agent" : "agent";
+          for (const card of board.cards) {
+            if (card.status !== "in_progress" && card.status !== "open")
+              continue;
+            if (card.assignee && card.assignee !== actor && card.assignee !== "any")
+              continue;
+            if (toolName === "shell" && !card.evidenceRequirements.some((r2) => r2.toLowerCase().includes("shell") || r2.toLowerCase().includes("build") || r2.toLowerCase().includes("test")))
+              continue;
+            if (toolName === "file_write" && !card.evidenceRequirements.some((r2) => r2.toLowerCase().includes("file") || r2.toLowerCase().includes("write") || r2.toLowerCase().includes("implement")))
+              continue;
+            if (toolName === "file_read" && !card.evidenceRequirements.some((r2) => r2.toLowerCase().includes("read") || r2.toLowerCase().includes("explor") || r2.toLowerCase().includes("understand")))
+              continue;
+            attachWorkboardEvidence(dir, {
+              runId: this._sessionId,
+              cardId: card.id,
+              actor,
+              evidence
+            });
+          }
+        } catch {
+        }
+      }
+      /** Persist the workboard snapshot before run teardown. */
+      _saveWorkboard() {
+        if (!this._workboard)
+          return;
+        try {
+          const dir = this._workboardDir();
+          const refreshed = readActiveWorkboardSnapshot(dir, this._sessionId);
+          if (refreshed)
+            this._workboard = refreshed;
+        } catch {
+        }
+      }
       // -- Session Checkpointing (Priority 5) --
       _sessionId = `session-${Date.now()}`;
       _workingDirectory = "";
@@ -562919,10 +563407,15 @@ var init_agenticRunner = __esm({
           // runner skips cross-task handoff inheritance from the parent's
           // session.
           subAgent: options2?.subAgent ?? false,
+          workboardDir: options2?.workboardDir ?? "",
           skipCrossTaskHandoff: options2?.skipCrossTaskHandoff ?? false
         };
         this._adversaryMode = this.options.adversaryMode;
         this._streamingExecutor.setConcurrencyResolver((name10, args) => this.resolveToolConcurrencySafe(name10, args));
+        this._contextEngine = createDefaultContextEngine();
+        if (options2?.onTypedEvent) {
+          this._onTypedEvent = options2.onTypedEvent;
+        }
       }
       /** Update context window size (e.g. after querying Ollama /api/show) */
       setContextWindowSize(size) {
@@ -562952,6 +563445,16 @@ var init_agenticRunner = __esm({
         } catch {
         }
       }
+      _saveCompletionLedgerSafe() {
+        if (!this._completionLedger)
+          return;
+        try {
+          const dir = _pathJoin(this.omniusStateDir(), "completion-ledgers");
+          _fsMkdirSync(dir, { recursive: true });
+          saveCompletionLedger(_pathJoin(dir, `${this._sessionId}.json`), this._completionLedger);
+        } catch {
+        }
+      }
       _initializeCompletionContract(task, context2) {
         this._completionContractSeedText = [task, context2 ?? ""].map((text2) => String(text2 || "").trim()).filter(Boolean).join("\n\n");
         this._completionContract = inferCompletionContractFromTexts([this._completionContractSeedText], task);
@@ -563017,6 +563520,38 @@ var init_agenticRunner = __esm({
         }));
       }
       // -------------------------------------------------------------------------
+      // WO-CE-BOUNDARY: Context Engine integration (Work Order #02)
+      // -------------------------------------------------------------------------
+      /** Infer the surface identifier from runner configuration and dynamic context. */
+      _inferSurface() {
+        const ctx3 = this._stickyDynamicContext || this.options.dynamicContext || "";
+        if (/Admin Capability/i.test(ctx3) || /telegram-admin/i.test(ctx3))
+          return "telegram-admin";
+        if (/Telegram|telegram|Voice Soul/i.test(ctx3) || this.options.stateDir)
+          return "telegram-public";
+        if (/api/i.test(ctx3))
+          return "api";
+        if (/background/i.test(ctx3))
+          return "background";
+        return "tui";
+      }
+      /**
+       * Build structured context via the context engine.
+       * Converts the runner's internal messages + tool events into
+       * the engine's output format (system messages separated from
+       * conversation, evidence injected, completion contracts placed).
+       */
+      async buildContext(input) {
+        return this._contextEngine.build(input);
+      }
+      /**
+       * Compact structured context via the context engine.
+       * Same as buildContext but allows token-budget-aware compaction.
+       */
+      async compactContext(input) {
+        return this._contextEngine.compact(input);
+      }
+      // -------------------------------------------------------------------------
       // Structured Context Assembly — C = A(c_instr, c_know, c_tools, c_mem, c_state, c_query)
       // Reference: "A Survey of Context Engineering for LLMs" (arXiv:2507.xxxxx)
       // -------------------------------------------------------------------------
@@ -563198,6 +563733,19 @@ ${graphSummary}`,
           }
         } catch {
         }
+        try {
+          const wbCtx = this.injectWorkboardContext();
+          if (wbCtx) {
+            sections.push({
+              label: "c_workboard",
+              content: `
+
+${wbCtx}`,
+              tokenEstimate: Math.ceil(wbCtx.length / 4)
+            });
+          }
+        } catch {
+        }
         const assembled = sections.map((s2) => s2.content).join("");
         const totalTokenEstimate = sections.reduce((sum, s2) => sum + s2.tokenEstimate, 0);
         return {
@@ -564080,6 +564628,18 @@ ${context2 ?? ""}`;
        * a different path (eg. surface to user). max cycles enforced here.
        */
       async _runBackwardPassReview(turn, toolCallLog, proposedSummary = "") {
+        if (this._completionLedger && proposedSummary) {
+          const _newClaims = deriveClaimsFromProposedText({
+            text: proposedSummary,
+            source: "task_complete_summary",
+            existing: this._completionLedger.proposedClaims
+          });
+          if (_newClaims.length > 0) {
+            this._completionLedger = addCompletionClaims(this._completionLedger, _newClaims);
+            this._completionLedger = reconcileClaimsWithEvidence(this._completionLedger);
+            this._saveCompletionLedgerSafe();
+          }
+        }
         const optOverride = this.options.backwardPassReview;
         const raw = (process.env["OMNIUS_BACKWARD_PASS"] || "on").toLowerCase();
         const envDisabled = raw === "off" || raw === "0" || raw === "false";
@@ -564221,6 +564781,13 @@ ${context2 ?? ""}`;
           })),
           modifiedFiles: modifiedFileDigest
         }).prompt;
+        let _ledgerScenarioDecomposition = completionScenarioDecomposition;
+        if (this._completionLedger) {
+          const _packet = buildCriticPacketFromLedger(this._completionLedger);
+          if (_packet) {
+            _ledgerScenarioDecomposition = [completionScenarioDecomposition, _packet].join("\n\n");
+          }
+        }
         const reviewReconciliation = lastCritique ? {
           previousVerdict: lastCritique.verdict,
           previousRationale: lastCritique.rationale,
@@ -564244,9 +564811,16 @@ ${context2 ?? ""}`;
             recentFailures,
             finalSummary: proposedSummary,
             toolEvidence: criticToolEvidence,
-            completionScenarioDecomposition,
+            completionScenarioDecomposition: _ledgerScenarioDecomposition,
             reviewReconciliation,
             openLoops,
+            workboardSynthesisContext: this._workboard ? (() => {
+              try {
+                return buildWorkboardSynthesisContext(this._workboard).excludedUnverifiedCardIds.length > 0 ? `Verified: ${this._workboard.cards.filter((c8) => c8.status === "verified").length}, Unverified remaining: ${this._workboard.cards.filter((c8) => c8.status !== "verified").length}, Blockers: ${this._workboard.cards.filter((c8) => c8.status === "blocked" || c8.status === "needs_changes").length}` : void 0;
+              } catch {
+                return void 0;
+              }
+            })() : void 0,
             callable,
             maxFiles: parseInt(process.env["OMNIUS_BACKWARD_PASS_MAX_FILES"] || "60", 10) || 60,
             maxFilePreviewBytes: parseInt(process.env["OMNIUS_BACKWARD_PASS_MAX_FILE_PREVIEW"] || "8000", 10) || 8e3,
@@ -564289,10 +564863,25 @@ ${context2 ?? ""}`;
         });
         void turn;
         if (result.verdict.verdict === "approve") {
+          if (this._completionLedger) {
+            this._completionLedger = recordCompletionCritique(this._completionLedger, {
+              verdict: "approve",
+              rationale: result.verdict.rationale
+            });
+            this._saveCompletionLedgerSafe();
+          }
           this._lastBackwardPassCritique = null;
           return { proceed: true };
         }
         const feedback = result.feedbackMessage;
+        if (this._completionLedger) {
+          this._completionLedger = recordCompletionCritique(this._completionLedger, {
+            verdict: result.verdict.verdict === "blocked" ? "blocked" : "request_changes",
+            rationale: result.verdict.rationale,
+            feedback
+          });
+          this._saveCompletionLedgerSafe();
+        }
         this._lastBackwardPassCritique = {
           verdict: result.verdict.verdict,
           rationale: result.verdict.rationale,
@@ -566845,6 +567434,7 @@ Respond with your assessment, then take action.`;
         this._completionContract = null;
         this._completionContractSeedText = "";
         this._completionIncompleteVerification = null;
+        this._completionLedger = null;
         this._lastWorldStateTurn = -1;
         this._fileWritesSinceLastWorldState = 0;
         this._resetVisualEvidenceState();
@@ -566984,6 +567574,10 @@ Respond with your assessment, then take action.`;
         });
         this._hookManager.runSessionHook("session_start", this._sessionId);
         this._initializeCompletionContract(task, context2);
+        this._completionLedger = createCompletionLedger({
+          runId: this._sessionId,
+          goal: cleanedTask
+        });
         this._sessionStartMs = Date.now();
         if (process.env["OMNIUS_DISABLE_PREFLIGHT"] !== "1") {
           try {
@@ -567554,6 +568148,12 @@ TASK: ${scrubbedTask}` : scrubbedTask;
                 content: "Task aborted by user",
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
+              this._onTypedEvent?.({
+                type: "run_failed",
+                runId: this._sessionId ?? "unknown",
+                error: "Task aborted by user",
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
               break;
             }
           }
@@ -567563,6 +568163,12 @@ TASK: ${scrubbedTask}` : scrubbedTask;
               content: "Task aborted by user",
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
+            this._onTypedEvent?.({
+              type: "run_failed",
+              runId: this._sessionId ?? "unknown",
+              error: "Task aborted by user",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
             break;
           }
           const REG35_CHECKPOINT_EVERY = 10;
@@ -568772,6 +569378,28 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
             messages2.push(...compacted);
             compacted = messages2;
           }
+          if (turn > 0 && this._toolEvents.length > 0) {
+            try {
+              const _limits = this.contextLimits();
+              const ceCompactInput = {
+                goal: this._taskState.originalGoal || this._taskState.goal || task,
+                surface: this._inferSurface(),
+                messages: compacted.map((m2) => ({
+                  role: m2.role === "tool" ? "tool" : m2.role === "system" ? "system" : m2.role === "assistant" ? "assistant" : "user",
+                  content: typeof m2.content === "string" ? m2.content : JSON.stringify(m2.content)
+                })),
+                toolEvents: this._toolEvents,
+                memoryHints: [],
+                runState: {
+                  runId: this._sessionId,
+                  tokenBudget: _limits.compactionThreshold,
+                  completionContract: this._completionContract ? formatCompletionContract(this._completionContract) : void 0
+                }
+              };
+              await this._contextEngine.compact(ceCompactInput);
+            } catch {
+            }
+          }
           if (turn > 0 && turn % 3 === 0 && this._temporalGraph && this._episodeStore) {
             let shouldRetrieve = true;
             try {
@@ -568878,6 +569506,34 @@ ${memoryLines.join("\n")}`
           this.proactivePrune(compacted, turn);
           this.microcompact(compacted, recentToolResults);
           this._insertContextFrame(compacted, await this._buildTurnContextFrame(turn, compacted, recentToolResults, environmentBlock));
+          {
+            const _limits = this.contextLimits();
+            const ceInput = {
+              goal: this._taskState.originalGoal || this._taskState.goal || task,
+              surface: this._inferSurface(),
+              messages: compacted.map((m2) => ({
+                role: m2.role === "tool" ? "tool" : m2.role === "system" ? "system" : m2.role === "assistant" ? "assistant" : "user",
+                content: typeof m2.content === "string" ? m2.content : JSON.stringify(m2.content)
+              })),
+              toolEvents: this._toolEvents,
+              memoryHints: [],
+              runState: {
+                runId: this._sessionId,
+                tokenBudget: _limits.compactionThreshold,
+                completionContract: this._completionContract ? formatCompletionContract(this._completionContract) : void 0
+              }
+            };
+            try {
+              const ceOutput = await this._contextEngine.build(ceInput);
+              if (ceOutput.diagnostics.evidenceRetained > 0 || ceInput.runState?.completionContract || ceInput.memoryHints?.length) {
+                const engineExtra = ceOutput.systemMessages.filter((m2) => !ceInput.messages.some((im) => im.content === m2.content));
+                if (engineExtra.length > 0) {
+                  compacted.unshift(...engineExtra.map((m2) => ({ role: "system", content: m2.content })));
+                }
+              }
+            } catch {
+            }
+          }
           const { maxOutputTokens: effectiveMaxTokens } = this.contextLimits();
           const chatRequest = {
             messages: compacted,
@@ -568966,15 +569622,28 @@ ${memoryLines.join("\n")}`
                 content: `Backend error: ${reqErr.message}`,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
+              this._onTypedEvent?.({
+                type: "run_failed",
+                runId: this._sessionId ?? "unknown",
+                error: reqErr.message,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
               break;
             }
             if (this.handleMaxTokensError(reqErr, chatRequest)) {
               try {
                 response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
               } catch (retryErr) {
+                const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
                 this.emit({
                   type: "error",
-                  content: `Retry with reduced max_tokens also failed: ${retryErr instanceof Error ? retryErr.message : String(retryErr)}`,
+                  content: `Retry with reduced max_tokens also failed: ${retryMsg}`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                this._onTypedEvent?.({
+                  type: "run_failed",
+                  runId: this._sessionId ?? "unknown",
+                  error: retryMsg,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
                 break;
@@ -568995,6 +569664,12 @@ ${memoryLines.join("\n")}`
                     content: `Model not available. Use /model to select a different model.`,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
+                  this._onTypedEvent?.({
+                    type: "run_failed",
+                    runId: this._sessionId ?? "unknown",
+                    error: `Model not found: ${errMsg}`,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
                   break;
                 }
                 let imageRecovered = false;
@@ -569060,6 +569735,13 @@ ${memoryLines.join("\n")}`
                           if (resolvedParsedTool.name === "task_complete") {
                             completed = true;
                             summary = String(parsed.args?.summary ?? content);
+                            this._onTypedEvent?.({
+                              type: "completion_requested",
+                              runId: this._sessionId ?? "unknown",
+                              summary: summary.slice(0, 500),
+                              sourcePath: this.options.streamEnabled ? "stream" : "batch",
+                              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                            });
                           }
                           toolCallCount++;
                           continue;
@@ -569076,6 +569758,12 @@ ${memoryLines.join("\n")}`
                       content: `Prompt-injected tool mode also failed: ${msg2}`,
                       timestamp: (/* @__PURE__ */ new Date()).toISOString()
                     });
+                    this._onTypedEvent?.({
+                      type: "run_failed",
+                      runId: this._sessionId ?? "unknown",
+                      error: msg2,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
                     break;
                   }
                 }
@@ -569085,6 +569773,12 @@ ${memoryLines.join("\n")}`
                     content: `Backend unavailable — stopping task. Fix the issue and retry.`,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
+                  this._onTypedEvent?.({
+                    type: "run_failed",
+                    runId: this._sessionId ?? "unknown",
+                    error: `Backend unavailable: ${errMsg}`,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
                   break;
                 }
               }
@@ -570696,6 +571390,14 @@ ${criticGuidance}`;
                 currentLogEntry.mutatedFiles = realMutationPaths;
                 currentLogEntry.outputPreview = (result.success ? result.llmContent ?? result.output ?? output : result.error ?? result.output ?? output).toString().slice(0, 500);
               }
+              this._toolEvents.push({
+                name: tc.name,
+                success: result.success,
+                outputPreview: (result.output ?? result.error ?? output ?? "").toString().slice(0, 300),
+                turn
+              });
+              if (this._toolEvents.length > 200)
+                this._toolEvents = this._toolEvents.slice(-200);
               const runtimeEvidenceEvents = this._recordEvidenceEventsFromResult(result, tc.name, tc.arguments ?? {}, turn, _toolLogTailIdx);
               if (runtimeEvidenceEvents.length > 0 && currentLogEntry) {
                 const evidencePreview = runtimeEvidenceEvents.map((event) => `${event.surface}/${event.action}:${event.verification?.status ?? "unknown"}`).join(", ");
@@ -570710,6 +571412,7 @@ Evidence: ${evidencePreview}`.slice(0, 500);
                 turn,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
+              this.recordWorkboardToolCall(tc.name, tc.arguments, result.success, result.output || output);
               this._taskState.toolCallCount++;
               if (realFileMutation) {
                 this._lastFileWriteTurn = turn;
@@ -571021,6 +571724,35 @@ Then use file_read on individual FILES inside it.`);
                   lastFailureHandoffTurn = turn;
                 }
               }
+              if (this._completionLedger && tc.name !== "task_complete") {
+                this._completionLedger = recordToolEvidence(this._completionLedger, {
+                  name: tc.name,
+                  success: result.success,
+                  outputPreview: (result.success ? result.llmContent ?? result.output ?? output : result.error ?? result.output ?? output).toString().slice(0, 500),
+                  argsKey: tc.arguments ? JSON.stringify(tc.arguments).slice(0, 300) : ""
+                });
+                if (realFileMutation && realMutationPaths.length > 0) {
+                  for (const filePath2 of realMutationPaths) {
+                    this._completionLedger = recordCompletionEvidence(this._completionLedger, {
+                      kind: "file_change",
+                      toolName: tc.name,
+                      success: true,
+                      summary: `file change: ${filePath2}`,
+                      rawRef: `file://${filePath2}`
+                    });
+                  }
+                }
+                this._saveCompletionLedgerSafe();
+              }
+              this._onTypedEvent?.({
+                type: "tool_call_finished",
+                runId: this._sessionId ?? "unknown",
+                toolName: tc.name,
+                callId: tc.id,
+                success: result.success === true,
+                outputPreview: (result.output ?? result.error ?? "").toString().slice(0, 500),
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
               return { tc, output, success: result.success };
             };
             const rawToolCalls = msg.toolCalls;
@@ -571104,6 +571836,13 @@ ${sr.result.output}`;
                       }
                       completed = true;
                       summary = extractTaskCompleteSummary(matchTc.arguments);
+                      this._onTypedEvent?.({
+                        type: "completion_requested",
+                        runId: this._sessionId ?? "unknown",
+                        summary: (summary ?? "").slice(0, 500),
+                        sourcePath: this.options.streamEnabled ? "stream" : "batch",
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
                       if (summary && !this._assistantTextEmitted) {
                         this.emit({
                           type: "assistant_text",
@@ -571165,6 +571904,13 @@ ${sr.result.output}`;
                         }
                         completed = true;
                         summary = extractTaskCompleteSummary(r2.tc.arguments);
+                        this._onTypedEvent?.({
+                          type: "completion_requested",
+                          runId: this._sessionId ?? "unknown",
+                          summary: (summary ?? "").slice(0, 500),
+                          sourcePath: this.options.streamEnabled ? "stream" : "batch",
+                          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                        });
                         if (summary && !this._assistantTextEmitted) {
                           this.emit({
                             type: "assistant_text",
@@ -571263,6 +572009,13 @@ ${sr.result.output}`;
                         }
                         completed = true;
                         summary = extractTaskCompleteSummary(r2.tc.arguments);
+                        this._onTypedEvent?.({
+                          type: "completion_requested",
+                          runId: this._sessionId ?? "unknown",
+                          summary: (summary ?? "").slice(0, 500),
+                          sourcePath: this.options.streamEnabled ? "stream" : "batch",
+                          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                        });
                         if (summary && !this._assistantTextEmitted) {
                           this.emit({
                             type: "assistant_text",
@@ -571482,6 +572235,13 @@ Call task_complete(summary="...") NOW with whatever you have.`
               }
               completed = true;
               summary = content;
+              this._onTypedEvent?.({
+                type: "completion_requested",
+                runId: this._sessionId ?? "unknown",
+                summary: content.slice(0, 500),
+                sourcePath: this.options.streamEnabled ? "stream" : "batch",
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
               break;
             }
             if (isThinkOnly) {
@@ -571677,6 +572437,28 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
             messages2.length = 0;
             messages2.push(...compacted);
           }
+          if (this._toolEvents.length > 0) {
+            try {
+              const _limits = this.contextLimits();
+              const _ceInput = {
+                goal: this._taskState.originalGoal || this._taskState.goal || task,
+                surface: this._inferSurface(),
+                messages: messages2.map((m2) => ({
+                  role: m2.role === "tool" ? "tool" : m2.role === "system" ? "system" : m2.role === "assistant" ? "assistant" : "user",
+                  content: typeof m2.content === "string" ? m2.content : JSON.stringify(m2.content)
+                })),
+                toolEvents: this._toolEvents,
+                memoryHints: [],
+                runState: {
+                  runId: this._sessionId,
+                  tokenBudget: _limits.compactionThreshold,
+                  completionContract: this._completionContract ? formatCompletionContract(this._completionContract) : void 0
+                }
+              };
+              const _ceOut = await this._contextEngine.compact(_ceInput);
+            } catch {
+            }
+          }
           const restartTurnCap = this.options.maxTurns && this.options.maxTurns > 0 ? this.options.maxTurns : Number.MAX_SAFE_INTEGER;
           for (let turn = 0; turn < restartTurnCap; turn++) {
             this._maybeApplyThinkGuard();
@@ -571688,6 +572470,12 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                   content: "Task aborted by user",
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
+                this._onTypedEvent?.({
+                  type: "run_failed",
+                  runId: this._sessionId ?? "unknown",
+                  error: "Task aborted by user",
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
                 break;
               }
             }
@@ -571697,6 +572485,12 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 content: "Task aborted by user",
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
+              this._onTypedEvent?.({
+                type: "run_failed",
+                runId: this._sessionId ?? "unknown",
+                error: "Task aborted by user",
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
               break;
             }
             this._runReg61Check(turn, toolCallLog, messages2, `bf-cycle ${bruteForceCycle}`);
@@ -571761,15 +572555,28 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                   content: "Task aborted by user",
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
+                this._onTypedEvent?.({
+                  type: "run_failed",
+                  runId: this._sessionId ?? "unknown",
+                  error: "Task aborted by user",
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
                 break;
               }
               if (this.handleMaxTokensError(reqErr, chatRequest)) {
                 try {
                   response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
                 } catch (retryErr) {
+                  const bfRetryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
                   this.emit({
                     type: "error",
-                    content: `Retry with reduced max_tokens also failed: ${retryErr instanceof Error ? retryErr.message : String(retryErr)}`,
+                    content: `Retry with reduced max_tokens also failed: ${bfRetryMsg}`,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                  this._onTypedEvent?.({
+                    type: "run_failed",
+                    runId: this._sessionId ?? "unknown",
+                    error: bfRetryMsg,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
                   break;
@@ -571789,6 +572596,12 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                     content: `Backend unavailable — stopping task.`,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
+                  this._onTypedEvent?.({
+                    type: "run_failed",
+                    runId: this._sessionId ?? "unknown",
+                    error: errMsg2,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
                   break;
                 }
                 response = recovered;
@@ -572005,6 +572818,14 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
                 this._trackDecomp2(tc, result, turn);
+                if (this._completionLedger && tc.name !== "task_complete") {
+                  this._completionLedger = recordToolEvidence(this._completionLedger, {
+                    name: tc.name,
+                    success: result.success,
+                    outputPreview: output.slice(0, 500),
+                    argsKey: bfArgsKey.slice(0, 300)
+                  });
+                }
                 const enoentTools2 = /* @__PURE__ */ new Set([
                   "file_read",
                   "list_directory",
@@ -572063,6 +572884,13 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                     }
                     completed = true;
                     summary = extractTaskCompleteSummary(tc.arguments);
+                    this._onTypedEvent?.({
+                      type: "completion_requested",
+                      runId: this._sessionId ?? "unknown",
+                      summary: (summary ?? "").slice(0, 500),
+                      sourcePath: this.options.streamEnabled ? "stream" : "batch",
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
                     if (summary && !this._assistantTextEmitted) {
                       this.emit({
                         type: "assistant_text",
@@ -572114,6 +572942,13 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                   }
                   completed = true;
                   summary = content;
+                  this._onTypedEvent?.({
+                    type: "completion_requested",
+                    runId: this._sessionId ?? "unknown",
+                    summary: content.slice(0, 500),
+                    sourcePath: this.options.streamEnabled ? "stream" : "batch",
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
                   break;
                 }
               }
@@ -572162,7 +572997,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
         if (this._completionIncompleteVerification && !summary) {
           summary = this._completionIncompleteVerification.summary;
         }
-        const runStatus = completed ? "completed" : this._completionIncompleteVerification ? "incomplete_verification" : "incomplete";
+        const runStatus = completed ? "completed" : this._completionLedger?.status === "blocked" || this._completionLedger?.status === "request_changes" ? "incomplete_verification" : this._completionIncompleteVerification ? "incomplete_verification" : "incomplete";
         this._emitMASTSummary("run-end");
         this.emit({
           type: "complete",
@@ -572170,6 +573005,13 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
           success: completed,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
+        this._onTypedEvent?.({
+          type: "run_finished",
+          runId: this._sessionId ?? "unknown",
+          status: runStatus,
+          success: completed,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
         if (this._errorPatterns.size > 0) {
           try {
             const fs11 = await import("node:fs");
@@ -572669,7 +573511,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
                 try {
-                  const { mkdirSync: mkdirSync97, readdirSync: readdirSync53, statSync: statSync54, unlinkSync: unlinkSync32, writeFileSync: writeFileSync85 } = __require("node:fs");
+                  const { mkdirSync: mkdirSync97, readdirSync: readdirSync53, statSync: statSync54, unlinkSync: unlinkSync33, writeFileSync: writeFileSync85 } = __require("node:fs");
                   const { join: join165 } = __require("node:path");
                   const contextDir = join165(this._workingDirectory || process.cwd(), ".omnius", "context");
                   mkdirSync97(contextDir, { recursive: true });
@@ -572749,7 +573591,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                       }
                       for (const filePath of toDelete) {
                         try {
-                          unlinkSync32(filePath);
+                          unlinkSync33(filePath);
                         } catch {
                         }
                       }
@@ -572778,6 +573620,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
           } catch {
           }
         }
+        this._saveWorkboard();
         this._hookManager.runSessionHook("session_end", this._sessionId);
         try {
           const fs11 = await import("node:fs");
@@ -575906,7 +576749,7 @@ ${result}`
             let resizedBase64 = null;
             try {
               const { execSync: execSync62 } = await import("node:child_process");
-              const { writeFileSync: writeFileSync85, readFileSync: readFileSync124, unlinkSync: unlinkSync32 } = await import("node:fs");
+              const { writeFileSync: writeFileSync85, readFileSync: readFileSync124, unlinkSync: unlinkSync33 } = await import("node:fs");
               const { join: join165 } = await import("node:path");
               const { tmpdir: tmpdir24 } = await import("node:os");
               const tmpIn = join165(tmpdir24(), `omnius_img_in_${Date.now()}.png`);
@@ -575919,11 +576762,11 @@ ${result}`
               const resizedBuf = readFileSync124(tmpOut);
               resizedBase64 = `data:image/jpeg;base64,${resizedBuf.toString("base64")}`;
               try {
-                unlinkSync32(tmpIn);
+                unlinkSync33(tmpIn);
               } catch {
               }
               try {
-                unlinkSync32(tmpOut);
+                unlinkSync33(tmpOut);
               } catch {
               }
             } catch {
@@ -577278,7 +578121,7 @@ var init_constraint_learner = __esm({
 });
 
 // packages/orchestrator/dist/nexusBackend.js
-import { existsSync as existsSync89, statSync as statSync37, openSync, readSync, closeSync, unlinkSync as unlinkSync16, writeFileSync as writeFileSync42 } from "node:fs";
+import { existsSync as existsSync89, statSync as statSync37, openSync, readSync, closeSync, unlinkSync as unlinkSync17, writeFileSync as writeFileSync43 } from "node:fs";
 import { watch as fsWatch } from "node:fs";
 import { join as join101 } from "node:path";
 import { tmpdir as tmpdir19 } from "node:os";
@@ -577484,7 +578327,7 @@ ${suffix}` } : m2);
        */
       async *chatCompletionStream(request) {
         const streamFile = join101(tmpdir19(), `nexus-stream-${randomBytes20(6).toString("hex")}.jsonl`);
-        writeFileSync42(streamFile, "", "utf8");
+        writeFileSync43(streamFile, "", "utf8");
         const effectiveThink = this.effectiveThink(request);
         const daemonArgs = {
           model: this.model,
@@ -577506,7 +578349,7 @@ ${suffix}` } : m2);
         } catch (sendErr) {
           this.consecutiveFailures++;
           try {
-            unlinkSync16(streamFile);
+            unlinkSync17(streamFile);
           } catch {
           }
           throw sendErr;
@@ -577521,7 +578364,7 @@ ${suffix}` } : m2);
         }
         if (!isStreaming) {
           try {
-            unlinkSync16(streamFile);
+            unlinkSync17(streamFile);
           } catch {
           }
           let parsed;
@@ -577711,7 +578554,7 @@ ${suffix}` } : m2);
           }
         } finally {
           try {
-            unlinkSync16(streamFile);
+            unlinkSync17(streamFile);
           } catch {
           }
         }
@@ -578001,7 +578844,7 @@ var init_cascadeBackend = __esm({
 
 // packages/orchestrator/dist/steeringIntake.js
 import { randomUUID as randomUUID16 } from "node:crypto";
-import { appendFileSync as appendFileSync6, existsSync as existsSync90, mkdirSync as mkdirSync49, readFileSync as readFileSync70 } from "node:fs";
+import { appendFileSync as appendFileSync6, existsSync as existsSync90, mkdirSync as mkdirSync50, readFileSync as readFileSync71 } from "node:fs";
 import { join as join102 } from "node:path";
 import { z as z16 } from "zod";
 function createSteeringIngress(input) {
@@ -578129,7 +578972,7 @@ function extractMidTaskSteeringInput(value2) {
 function appendSteeringLedgerEntry(repoRoot, entry) {
   try {
     const dir = join102(repoRoot, ".omnius", "context");
-    mkdirSync49(dir, { recursive: true });
+    mkdirSync50(dir, { recursive: true });
     appendFileSync6(join102(dir, LEDGER_FILE), `${JSON.stringify(entry)}
 `, "utf-8");
   } catch {
@@ -578268,7 +579111,7 @@ function readRecentSteeringEntries(repoRoot, limit) {
     const file = join102(repoRoot, ".omnius", "context", LEDGER_FILE);
     if (!existsSync90(file))
       return [];
-    const lines = readFileSync70(file, "utf-8").split("\n").filter(Boolean).slice(-100);
+    const lines = readFileSync71(file, "utf-8").split("\n").filter(Boolean).slice(-100);
     const parsedEntries = [];
     for (const line of lines) {
       try {
@@ -578374,283 +579217,6 @@ Constrain your context. Clarify your target. Focus your tools. Flow will follow.
   }
 });
 
-// packages/orchestrator/dist/contextEngine.js
-function estimateTokens3(messages2) {
-  const chars = messages2.reduce((sum, message2) => sum + message2.content.length + message2.role.length + (message2.name?.length ?? 0), 0);
-  return Math.ceil(chars / 4);
-}
-function evidenceMessage(event) {
-  const status = event.success === true ? "ok" : event.success === false ? "failed" : "unknown";
-  const parts = [
-    `tool=${event.name}`,
-    `status=${status}`,
-    typeof event.turn === "number" ? `turn=${event.turn}` : "",
-    event.evidenceId ? `evidence=${event.evidenceId}` : "",
-    event.outputPreview ? `observed=${event.outputPreview}` : ""
-  ].filter(Boolean);
-  return { role: "system", content: `[RUN EVIDENCE] ${parts.join(" ")}` };
-}
-function createDefaultContextEngine() {
-  return new DefaultContextEngine();
-}
-var DefaultContextEngine;
-var init_contextEngine = __esm({
-  "packages/orchestrator/dist/contextEngine.js"() {
-    "use strict";
-    DefaultContextEngine = class {
-      async build(input) {
-        return this.render(input, false);
-      }
-      async compact(input) {
-        return this.render(input, true);
-      }
-      render(input, allowCompaction) {
-        const systemMessages = input.messages.filter((message2) => message2.role === "system");
-        const conversationMessages = input.messages.filter((message2) => message2.role !== "system");
-        const evidence = (input.toolEvents ?? []).map(evidenceMessage);
-        const hints = (input.memoryHints ?? []).filter((hint) => hint.trim().length > 0).slice(-8).map((hint) => ({ role: "system", content: `[MEMORY HINT] ${hint.trim()}` }));
-        const contract = input.runState?.completionContract ? [{ role: "system", content: input.runState.completionContract }] : [];
-        const beforeMessages = [...systemMessages, ...contract, ...hints, ...evidence, ...conversationMessages];
-        const before = estimateTokens3(beforeMessages);
-        const budget = input.runState?.tokenBudget;
-        let compactedConversation = conversationMessages;
-        let compacted = false;
-        let evidenceDropped = 0;
-        if (allowCompaction && budget && before > budget) {
-          const retained = [];
-          let used = estimateTokens3([...systemMessages, ...contract, ...hints, ...evidence]);
-          for (const message2 of [...conversationMessages].reverse()) {
-            const cost = estimateTokens3([message2]);
-            if (used + cost > budget)
-              continue;
-            retained.push(message2);
-            used += cost;
-          }
-          compactedConversation = retained.reverse();
-          compacted = compactedConversation.length !== conversationMessages.length;
-          evidenceDropped = 0;
-        }
-        const renderedSystem = [...systemMessages, ...contract, ...hints, ...evidence];
-        const after = estimateTokens3([...renderedSystem, ...compactedConversation]);
-        return {
-          systemMessages: renderedSystem,
-          conversationMessages: compactedConversation,
-          compacted,
-          diagnostics: {
-            surface: input.surface,
-            tokenEstimateBefore: before,
-            tokenEstimateAfter: after,
-            compacted,
-            compactionStrategy: compacted ? "drop_oldest_non_evidence" : "none",
-            evidenceRetained: evidence.length,
-            evidenceDropped
-          }
-        };
-      }
-    };
-  }
-});
-
-// packages/orchestrator/dist/completionLedger.js
-import { mkdirSync as mkdirSync50, readFileSync as readFileSync71, writeFileSync as writeFileSync43 } from "node:fs";
-import { dirname as dirname31 } from "node:path";
-function nowIso2(now = /* @__PURE__ */ new Date()) {
-  return now instanceof Date ? now.toISOString() : new Date(now).toISOString();
-}
-function cleanText(value2, max = 600) {
-  return String(value2 ?? "").replace(/\s+/g, " ").trim().slice(0, max);
-}
-function nextId2(prefix, count) {
-  return `${prefix}_${String(count + 1).padStart(4, "0")}`;
-}
-function createCompletionLedger(input) {
-  const ts = nowIso2(input.now);
-  return {
-    runId: input.runId,
-    goal: cleanText(input.goal, 2e3),
-    createdAtIso: ts,
-    updatedAtIso: ts,
-    proposedClaims: [],
-    evidence: [],
-    critiques: [],
-    unresolved: [],
-    status: "open"
-  };
-}
-function deriveClaimsFromProposedText(input) {
-  const raw = String(input.text ?? "").trim();
-  if (!raw)
-    return [];
-  const segments = raw.replace(/\b(?:done|completed|verified)\s*:\s*/gi, "").split(/(?:\n+|;\s+|,\s+(?=(?:and\s+)?(?:sent|built|created|updated|published|verified|tested|fixed|added|removed|deployed|wrote)\b)|\.\s+)/i).map((part) => cleanText(part, 300)).filter((part) => part.length > 0);
-  const unique2 = Array.from(new Set(segments.length > 0 ? segments : [cleanText(raw, 300)]));
-  const existingIds = new Set((input.existing ?? []).map((claim) => claim.id));
-  return unique2.map((text2, index) => {
-    const base3 = normalizeCompletionKey(text2, `claim_${index + 1}`).slice(0, 64);
-    let id = base3 || `claim_${index + 1}`;
-    let suffix = 2;
-    while (existingIds.has(id)) {
-      id = `${base3}_${suffix++}`;
-    }
-    existingIds.add(id);
-    return {
-      id,
-      text: text2,
-      source: input.source,
-      materiality: "high",
-      evidenceRequirement: "Observed evidence from this run supports the claim or the final response marks it unverified/blocked.",
-      evidenceIds: [],
-      status: "unverified"
-    };
-  });
-}
-function recordCompletionEvidence(ledger, evidence) {
-  const entry = {
-    id: evidence.id ?? nextId2("ev", ledger.evidence.length),
-    kind: evidence.kind,
-    observedAtIso: evidence.observedAtIso ?? nowIso2(),
-    summary: cleanText(evidence.summary, 1200),
-    toolName: evidence.toolName,
-    success: evidence.success,
-    rawRef: evidence.rawRef
-  };
-  return {
-    ...ledger,
-    evidence: [...ledger.evidence, entry],
-    updatedAtIso: entry.observedAtIso
-  };
-}
-function recordToolEvidence(ledger, input) {
-  const summary = [
-    input.name,
-    input.success === true ? "succeeded" : input.success === false ? "failed" : "observed",
-    input.argsKey ? `args=${cleanText(input.argsKey, 180)}` : "",
-    input.outputPreview ? `output=${cleanText(input.outputPreview, 700)}` : ""
-  ].filter(Boolean).join(" ");
-  return recordCompletionEvidence(ledger, {
-    kind: "tool_result",
-    toolName: input.name,
-    success: input.success,
-    summary,
-    rawRef: input.rawRef
-  });
-}
-function addCompletionClaims(ledger, claims) {
-  const byId = new Map(ledger.proposedClaims.map((claim) => [claim.id, claim]));
-  for (const claim of claims)
-    byId.set(claim.id, claim);
-  return {
-    ...ledger,
-    proposedClaims: Array.from(byId.values()),
-    updatedAtIso: nowIso2()
-  };
-}
-function reconcileClaimsWithEvidence(ledger) {
-  const successfulEvidence = ledger.evidence.filter((entry) => entry.success !== false);
-  const failedEvidence = ledger.evidence.filter((entry) => entry.success === false);
-  const claims = ledger.proposedClaims.map((claim) => {
-    const claimTerms = cleanText(claim.text, 300).toLowerCase().split(/[^a-z0-9]+/).filter((part) => part.length >= 4);
-    const matches = successfulEvidence.filter((entry) => {
-      const haystack = `${entry.toolName ?? ""} ${entry.summary}`.toLowerCase();
-      return claimTerms.some((term) => haystack.includes(term));
-    });
-    const contradictions = failedEvidence.filter((entry) => {
-      const haystack = `${entry.toolName ?? ""} ${entry.summary}`.toLowerCase();
-      return claimTerms.some((term) => haystack.includes(term));
-    });
-    if (contradictions.length > 0 && matches.length === 0) {
-      return { ...claim, evidenceIds: contradictions.map((entry) => entry.id), status: "contradicted" };
-    }
-    if (matches.length > 0) {
-      return { ...claim, evidenceIds: matches.map((entry) => entry.id), status: "supported" };
-    }
-    return { ...claim, evidenceIds: [], status: "unverified" };
-  });
-  return {
-    ...ledger,
-    proposedClaims: claims,
-    updatedAtIso: nowIso2()
-  };
-}
-function recordCompletionCritique(ledger, input) {
-  const critique = {
-    id: input.id ?? nextId2("critique", ledger.critiques.length),
-    verdict: input.verdict,
-    rationale: cleanText(input.rationale, 1200),
-    feedback: input.feedback ? cleanText(input.feedback, 3e3) : void 0,
-    recordedAtIso: input.recordedAtIso ?? nowIso2(),
-    evidenceSequence: ledger.evidence.length
-  };
-  return {
-    ...ledger,
-    critiques: [...ledger.critiques, critique],
-    status: input.verdict === "approve" ? "approved" : input.verdict,
-    updatedAtIso: critique.recordedAtIso
-  };
-}
-function buildCriticPacketFromLedger(ledger) {
-  const latestCritique = ledger.critiques.at(-1);
-  const evidenceSinceCritique = latestCritique ? ledger.evidence.slice(latestCritique.evidenceSequence) : [];
-  const lines = [];
-  lines.push("[COMPLETION LEDGER]");
-  lines.push(`Run: ${ledger.runId}`);
-  lines.push(`Goal: ${ledger.goal || "(not recorded)"}`);
-  lines.push(`Status: ${ledger.status}`);
-  lines.push("");
-  lines.push("Claims:");
-  if (ledger.proposedClaims.length === 0)
-    lines.push("- none recorded");
-  for (const claim of ledger.proposedClaims) {
-    lines.push(`- [${claim.status}] ${claim.id}: ${claim.text}`);
-    lines.push(`  evidence: ${claim.evidenceIds.length > 0 ? claim.evidenceIds.join(", ") : "none"}`);
-    lines.push(`  requirement: ${claim.evidenceRequirement}`);
-  }
-  lines.push("");
-  lines.push("Evidence:");
-  if (ledger.evidence.length === 0)
-    lines.push("- none recorded");
-  for (const evidence of ledger.evidence.slice(-40)) {
-    const status = evidence.success === true ? "ok" : evidence.success === false ? "failed" : "unknown";
-    lines.push(`- ${evidence.id} [${status}] ${evidence.kind}${evidence.toolName ? `/${evidence.toolName}` : ""}: ${evidence.summary}`);
-  }
-  if (latestCritique) {
-    lines.push("");
-    lines.push("Prior critique:");
-    lines.push(`- verdict: ${latestCritique.verdict}`);
-    lines.push(`- rationale: ${latestCritique.rationale}`);
-    if (latestCritique.feedback)
-      lines.push(`- feedback: ${latestCritique.feedback}`);
-    lines.push("");
-    lines.push("Evidence recorded after prior critique:");
-    if (evidenceSinceCritique.length === 0)
-      lines.push("- none recorded");
-    for (const evidence of evidenceSinceCritique) {
-      const status = evidence.success === true ? "ok" : evidence.success === false ? "failed" : "unknown";
-      lines.push(`- ${evidence.id} [${status}] ${evidence.summary}`);
-    }
-  }
-  if (ledger.unresolved.length > 0) {
-    lines.push("");
-    lines.push("Unresolved:");
-    for (const item of ledger.unresolved.slice(-20))
-      lines.push(`- ${item.text}`);
-  }
-  return lines.join("\n");
-}
-function saveCompletionLedger(filePath, ledger) {
-  mkdirSync50(dirname31(filePath), { recursive: true });
-  writeFileSync43(filePath, `${JSON.stringify(ledger, null, 2)}
-`, "utf8");
-}
-function loadCompletionLedger(filePath) {
-  return JSON.parse(readFileSync71(filePath, "utf8"));
-}
-var init_completionLedger = __esm({
-  "packages/orchestrator/dist/completionLedger.js"() {
-    "use strict";
-    init_completionContract();
-  }
-});
-
 // packages/orchestrator/dist/runEvents.js
 function text(value2, max = 500) {
   const out = String(value2 ?? "").replace(/\s+/g, " ").trim();
@@ -580649,7 +581215,7 @@ var init_agent_task = __esm({
 });
 
 // packages/orchestrator/dist/task-recovery.js
-import { existsSync as existsSync93, readFileSync as readFileSync74, writeFileSync as writeFileSync45, mkdirSync as mkdirSync53, readdirSync as readdirSync28, renameSync as renameSync7, unlinkSync as unlinkSync17 } from "node:fs";
+import { existsSync as existsSync93, readFileSync as readFileSync74, writeFileSync as writeFileSync45, mkdirSync as mkdirSync53, readdirSync as readdirSync28, renameSync as renameSync7, unlinkSync as unlinkSync18 } from "node:fs";
 import { join as join106 } from "node:path";
 import { homedir as homedir31 } from "node:os";
 function sidecarDir() {
@@ -580675,7 +581241,7 @@ function deleteAgentTaskSidecar(taskId) {
     const p2 = sidecarPath(taskId);
     if (!existsSync93(p2))
       return false;
-    unlinkSync17(p2);
+    unlinkSync18(p2);
     return true;
   } catch {
     return false;
@@ -580747,7 +581313,7 @@ function purgeOldSidecars(maxAgeHours = 24) {
         const task = JSON.parse(readFileSync74(p2, "utf-8"));
         const stamp = task.completedAt ?? task.createdAt ?? 0;
         if (isTerminalTaskStatus(task.status) && stamp > 0 && stamp < cutoff) {
-          unlinkSync17(p2);
+          unlinkSync18(p2);
           purged++;
         }
       } catch {
@@ -593606,7 +594172,7 @@ import { EventEmitter as EventEmitter8 } from "node:events";
 import { randomBytes as randomBytes21, timingSafeEqual } from "node:crypto";
 import { URL as URL2 } from "node:url";
 import { loadavg, cpus as cpus2, totalmem as totalmem5, freemem as freemem4 } from "node:os";
-import { existsSync as existsSync100, readFileSync as readFileSync81, writeFileSync as writeFileSync52, unlinkSync as unlinkSync18, mkdirSync as mkdirSync60, readdirSync as readdirSync32, statSync as statSync38, statfsSync as statfsSync4 } from "node:fs";
+import { existsSync as existsSync100, readFileSync as readFileSync81, writeFileSync as writeFileSync52, unlinkSync as unlinkSync19, mkdirSync as mkdirSync60, readdirSync as readdirSync32, statSync as statSync38, statfsSync as statfsSync4 } from "node:fs";
 import { join as join115 } from "node:path";
 function cleanForwardHeaders(raw, targetHost) {
   const out = {};
@@ -593819,7 +594385,7 @@ function writeExposeState(stateDir, state) {
 }
 function removeExposeState(stateDir) {
   try {
-    unlinkSync18(join115(stateDir, STATE_FILE_NAME));
+    unlinkSync19(join115(stateDir, STATE_FILE_NAME));
   } catch {
   }
 }
@@ -593957,7 +594523,7 @@ function writeP2PExposeState(stateDir, state) {
 }
 function removeP2PExposeState(stateDir) {
   try {
-    unlinkSync18(join115(stateDir, P2P_STATE_FILE_NAME));
+    unlinkSync19(join115(stateDir, P2P_STATE_FILE_NAME));
   } catch {
   }
 }
@@ -597092,7 +597658,7 @@ ${activitySummary}
 });
 
 // packages/cli/src/api/profiles.ts
-import { existsSync as existsSync102, readFileSync as readFileSync83, writeFileSync as writeFileSync54, mkdirSync as mkdirSync62, readdirSync as readdirSync33, unlinkSync as unlinkSync19 } from "node:fs";
+import { existsSync as existsSync102, readFileSync as readFileSync83, writeFileSync as writeFileSync54, mkdirSync as mkdirSync62, readdirSync as readdirSync33, unlinkSync as unlinkSync20 } from "node:fs";
 import { join as join117 } from "node:path";
 import { homedir as homedir34 } from "node:os";
 import { createCipheriv as createCipheriv4, createDecipheriv as createDecipheriv4, randomBytes as randomBytes24, scryptSync as scryptSync3 } from "node:crypto";
@@ -597196,7 +597762,7 @@ function deleteProfile(name10, scope = "global", projectDir2) {
   const dir = scope === "project" ? projectProfileDir(projectDir2) : globalProfileDir();
   const filePath = join117(dir, `${sanitized}.json`);
   if (existsSync102(filePath)) {
-    unlinkSync19(filePath);
+    unlinkSync20(filePath);
     return true;
   }
   return false;
@@ -598090,7 +598656,7 @@ __export(omnius_directory_exports, {
   writeIndexMeta: () => writeIndexMeta,
   writeTaskHandoff: () => writeTaskHandoff2
 });
-import { appendFileSync as appendFileSync9, cpSync as cpSync2, existsSync as existsSync106, mkdirSync as mkdirSync64, readFileSync as readFileSync87, writeFileSync as writeFileSync56, readdirSync as readdirSync34, statSync as statSync40, unlinkSync as unlinkSync21, openSync as openSync2, closeSync as closeSync2, renameSync as renameSync8, watch as fsWatch2 } from "node:fs";
+import { appendFileSync as appendFileSync9, cpSync as cpSync2, existsSync as existsSync106, mkdirSync as mkdirSync64, readFileSync as readFileSync87, writeFileSync as writeFileSync56, readdirSync as readdirSync34, statSync as statSync40, unlinkSync as unlinkSync22, openSync as openSync2, closeSync as closeSync2, renameSync as renameSync8, watch as fsWatch2 } from "node:fs";
 import { join as join121, relative as relative11, basename as basename23, dirname as dirname38, resolve as resolve49 } from "node:path";
 import { homedir as homedir36 } from "node:os";
 import { createHash as createHash34 } from "node:crypto";
@@ -598453,7 +599019,7 @@ function loadPendingTask(repoRoot) {
     if (!existsSync106(filePath)) return null;
     const data = JSON.parse(readFileSync87(filePath, "utf-8"));
     try {
-      unlinkSync21(filePath);
+      unlinkSync22(filePath);
     } catch {
     }
     return data;
@@ -598472,7 +599038,7 @@ function writeTaskHandoff2(repoRoot, handoff) {
   } catch {
     writeFileSync56(filePath, JSON.stringify(handoff, null, 2) + "\n", "utf-8");
     try {
-      unlinkSync21(tempPath);
+      unlinkSync22(tempPath);
     } catch {
     }
   }
@@ -598498,7 +599064,7 @@ function clearTaskHandoff(repoRoot) {
   const filePath = join121(repoRoot, OMNIUS_DIR, "context", HANDOFF_FILE);
   try {
     if (existsSync106(filePath)) {
-      unlinkSync21(filePath);
+      unlinkSync22(filePath);
     }
   } catch {
   }
@@ -598572,13 +599138,13 @@ function acquireLock(lockPath) {
           const lockAge = Date.now() - lock.acquiredAt;
           if (lockAge > LOCK_TIMEOUT_MS) {
             try {
-              unlinkSync21(lockPath);
+              unlinkSync22(lockPath);
             } catch {
             }
           }
         } catch {
           try {
-            unlinkSync21(lockPath);
+            unlinkSync22(lockPath);
           } catch {
           }
         }
@@ -598596,7 +599162,7 @@ function releaseLock(lockPath) {
       const lockContent = readFileSync87(lockPath, "utf-8");
       const lock = JSON.parse(lockContent);
       if (lock.pid === process.pid) {
-        unlinkSync21(lockPath);
+        unlinkSync22(lockPath);
       }
     }
   } catch {
@@ -598782,7 +599348,7 @@ function saveSessionContext(repoRoot, entry) {
     } catch {
       writeFileSync56(filePath, JSON.stringify(ctx3, null, 2) + "\n", "utf-8");
       try {
-        unlinkSync21(tempFilePath);
+        unlinkSync22(tempFilePath);
       } catch {
       }
     }
@@ -598995,7 +599561,7 @@ function saveSessionHistory(repoRoot, sessionId, contentLines, meta) {
   if (index.length > 50) {
     const removed = index.shift();
     try {
-      unlinkSync21(join121(sessDir, `${removed.id}.jsonl`));
+      unlinkSync22(join121(sessDir, `${removed.id}.jsonl`));
     } catch {
     }
   }
@@ -599025,7 +599591,7 @@ function deleteSession(repoRoot, sessionId) {
   const indexPath = join121(sessDir, SESSIONS_INDEX);
   try {
     const contentPath = join121(sessDir, `${sessionId}.jsonl`);
-    if (existsSync106(contentPath)) unlinkSync21(contentPath);
+    if (existsSync106(contentPath)) unlinkSync22(contentPath);
     if (existsSync106(indexPath)) {
       let index = JSON.parse(readFileSync87(indexPath, "utf-8"));
       index = index.filter((s2) => s2.id !== sessionId);
@@ -612814,7 +613380,7 @@ var init_audio_waveform = __esm({
 });
 
 // packages/cli/src/tui/neovim-mode.ts
-import { existsSync as existsSync114, unlinkSync as unlinkSync22 } from "node:fs";
+import { existsSync as existsSync114, unlinkSync as unlinkSync23 } from "node:fs";
 import { tmpdir as tmpdir20 } from "node:os";
 import { join as join127 } from "node:path";
 import { execSync as execSync53 } from "node:child_process";
@@ -612864,7 +613430,7 @@ async function startNeovimMode(opts) {
   }
   const socketPath = join127(tmpdir20(), `omnius-nvim-${process.pid}-${Date.now()}.sock`);
   try {
-    if (existsSync114(socketPath)) unlinkSync22(socketPath);
+    if (existsSync114(socketPath)) unlinkSync23(socketPath);
   } catch {
   }
   const ptyCols = opts.cols;
@@ -613253,7 +613819,7 @@ function doCleanup(state) {
     state.pty = null;
   }
   try {
-    if (existsSync114(state.socketPath)) unlinkSync22(state.socketPath);
+    if (existsSync114(state.socketPath)) unlinkSync23(state.socketPath);
   } catch {
   }
   if (state.stdinHandler) {
@@ -613324,7 +613890,7 @@ __export(daemon_exports, {
   stopDaemon: () => stopDaemon
 });
 import { spawn as spawn29 } from "node:child_process";
-import { existsSync as existsSync115, readFileSync as readFileSync94, writeFileSync as writeFileSync59, mkdirSync as mkdirSync67, unlinkSync as unlinkSync23, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
+import { existsSync as existsSync115, readFileSync as readFileSync94, writeFileSync as writeFileSync59, mkdirSync as mkdirSync67, unlinkSync as unlinkSync24, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
 import { join as join128 } from "node:path";
 import { homedir as homedir41 } from "node:os";
 import { fileURLToPath as fileURLToPath16 } from "node:url";
@@ -613358,7 +613924,7 @@ function getDaemonPid() {
     return pid;
   } catch {
     try {
-      unlinkSync23(PID_FILE2);
+      unlinkSync24(PID_FILE2);
     } catch {
     }
     return null;
@@ -613474,13 +614040,13 @@ function stopDaemon() {
     }
     process.kill(pid, "SIGTERM");
     try {
-      unlinkSync23(PID_FILE2);
+      unlinkSync24(PID_FILE2);
     } catch {
     }
     return true;
   } catch {
     try {
-      unlinkSync23(PID_FILE2);
+      unlinkSync24(PID_FILE2);
     } catch {
     }
     return false;
@@ -613511,7 +614077,7 @@ async function forceKillDaemon(port) {
     } catch {
     }
     try {
-      unlinkSync23(PID_FILE2);
+      unlinkSync24(PID_FILE2);
     } catch {
     }
   }
@@ -613552,7 +614118,7 @@ async function ensureDaemon() {
     } catch {
     }
     try {
-      unlinkSync23(PID_FILE2);
+      unlinkSync24(PID_FILE2);
     } catch {
     }
   }
@@ -613569,7 +614135,7 @@ async function ensureDaemon() {
   } catch {
   }
   try {
-    unlinkSync23(PID_FILE2);
+    unlinkSync24(PID_FILE2);
   } catch {
   }
   return false;
@@ -615357,7 +615923,7 @@ import {
   mkdirSync as mkdirSync69,
   writeFileSync as writeFileSync61,
   readFileSync as readFileSync97,
-  unlinkSync as unlinkSync24,
+  unlinkSync as unlinkSync25,
   readdirSync as readdirSync37,
   statSync as statSync44
 } from "node:fs";
@@ -616795,7 +617361,7 @@ except Exception as exc:
         const p2 = join130(luxttsCloneRefsDir(), filename);
         if (!existsSync118(p2)) return false;
         try {
-          unlinkSync24(p2);
+          unlinkSync25(p2);
           const meta = this.loadCloneMeta();
           delete meta[filename];
           this.saveCloneMeta(meta);
@@ -617149,7 +617715,7 @@ except Exception as exc:
         }
         if (prefetchedWav) {
           try {
-            unlinkSync24(prefetchedWav.path);
+            unlinkSync25(prefetchedWav.path);
           } catch {
           }
         }
@@ -617243,7 +617809,7 @@ except Exception as exc:
         this.writeStereoWav(stereo.left, stereo.right, sampleRate, wavPath);
         await this.playWav(wavPath);
         try {
-          unlinkSync24(wavPath);
+          unlinkSync25(wavPath);
         } catch {
         }
       }
@@ -617744,7 +618310,7 @@ except Exception as exc:
         if (!wavPath) return null;
         try {
           const data = readFileSync97(wavPath);
-          unlinkSync24(wavPath);
+          unlinkSync25(wavPath);
           return data;
         } catch {
           return null;
@@ -617950,7 +618516,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`
         }
         await this.playWav(wavPath);
         try {
-          unlinkSync24(wavPath);
+          unlinkSync25(wavPath);
         } catch {
         }
       }
@@ -617994,7 +618560,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`
         if (!existsSync118(wavPath)) return null;
         try {
           const data = readFileSync97(wavPath);
-          unlinkSync24(wavPath);
+          unlinkSync25(wavPath);
           return data;
         } catch {
           return null;
@@ -618778,7 +619344,7 @@ if __name__ == '__main__':
         await this.playWav(wavPath);
         await this.sleep(150);
         try {
-          unlinkSync24(wavPath);
+          unlinkSync25(wavPath);
         } catch {
         }
       }
@@ -618818,7 +619384,7 @@ if __name__ == '__main__':
         if (!existsSync118(wavPath)) return null;
         try {
           const data = readFileSync97(wavPath);
-          unlinkSync24(wavPath);
+          unlinkSync25(wavPath);
           return data;
         } catch {
           return null;
@@ -639615,7 +640181,7 @@ var init_bless_engine = __esm({
 });
 
 // packages/cli/src/tui/dmn-engine.ts
-import { existsSync as existsSync128, readFileSync as readFileSync106, writeFileSync as writeFileSync68, mkdirSync as mkdirSync78, readdirSync as readdirSync44, unlinkSync as unlinkSync25 } from "node:fs";
+import { existsSync as existsSync128, readFileSync as readFileSync106, writeFileSync as writeFileSync68, mkdirSync as mkdirSync78, readdirSync as readdirSync44, unlinkSync as unlinkSync26 } from "node:fs";
 import { join as join141, basename as basename33 } from "node:path";
 function buildDMNGatherPrompt(recentTaskSummaries, dueReminders, attentionItems, memoryTopics, capabilities, competence, reflectionBuffer) {
   const competenceReport = competence.length > 0 ? competence.map((c8) => {
@@ -640425,7 +640991,7 @@ OUTPUT: Call task_complete with JSON:
         for (const file of files) {
           if (!keep.has(file)) {
             try {
-              unlinkSync25(join141(this.historyDir, file));
+              unlinkSync26(join141(this.historyDir, file));
             } catch {
             }
           }
@@ -642066,7 +642632,7 @@ import {
   mkdirSync as mkdirSync79,
   readFileSync as readFileSync107,
   statSync as statSync46,
-  unlinkSync as unlinkSync26,
+  unlinkSync as unlinkSync27,
   writeFileSync as writeFileSync69
 } from "node:fs";
 import { mkdir as mkdir20 } from "node:fs/promises";
@@ -642279,7 +642845,7 @@ function scopedTool(base3, root, mode) {
         }
       } else if (restoredEditPath) {
         try {
-          unlinkSync26(restoredEditPath);
+          unlinkSync27(restoredEditPath);
         } catch {
         }
       }
@@ -642398,7 +642964,7 @@ function rememberCreated(root, absPath) {
       const previousPath = resolve55(root, previous.storedRel);
       if (isInside(resolve55(root), previousPath) && existsSync129(previousPath)) {
         try {
-          unlinkSync26(previousPath);
+          unlinkSync27(previousPath);
         } catch {
         }
       }
@@ -642415,7 +642981,7 @@ function rememberCreated(root, absPath) {
     const storedAbs = join142(root, storedRel);
     writeFileSync69(storedAbs, Buffer.concat([prefix, encrypted]));
     try {
-      unlinkSync26(guarded.path.abs);
+      unlinkSync27(guarded.path.abs);
     } catch {
     }
     manifest.objects = manifest.objects || {};
@@ -642480,7 +643046,7 @@ function materializeTelegramCreativeArtifactForSend(root, rawPath) {
       path: staged,
       cleanup: () => {
         try {
-          unlinkSync26(staged);
+          unlinkSync27(staged);
         } catch {
         }
       }
@@ -645287,6 +645853,60 @@ var init_telegram_social_state = __esm({
   }
 });
 
+// packages/cli/src/tui/telegram-vision-router.ts
+function deriveVisualEvidencePlan(request) {
+  const prompt = request.prompt.toLowerCase();
+  const detail = request.requestedDetail ?? "auto";
+  const needsText = /\b(text|read|ocr|extract|label|word|number|what does it say|transcript|character|letter|digit|spell|transcribe|copy|quote|type|what is written)\b/i.test(prompt);
+  const needsScene = /\b(what|who|where|describe|scene|object|person|identify|tell me about|explain|see|show|happening|look like|recogniz)\b/i.test(prompt) && !needsText;
+  const needsUI = /\b(ui|button|menu|dialog|window|interface|screen|dashboard|form|field|input|select|option|dropdown)\b/i.test(prompt);
+  switch (detail) {
+    case "low":
+      return { stages: [{ kind: "low_fidelity_observation", required: true }], reason: "low detail requested" };
+    case "text":
+      return { stages: [{ kind: "low_fidelity_observation", required: false }, { kind: "ocr", required: true }, { kind: "auxiliary_vision", required: false }], reason: "text extraction requested" };
+    case "full":
+      return { stages: [{ kind: "low_fidelity_observation", required: false }, { kind: "ocr", required: needsText || needsUI }, { kind: "auxiliary_vision", required: true }], reason: "full detail requested" };
+    default:
+      const stages = [{ kind: "low_fidelity_observation", required: false }];
+      if (needsText || needsUI) stages.push({ kind: "ocr", required: true });
+      if (needsScene || needsUI) stages.push({ kind: "auxiliary_vision", required: !needsText && !needsUI });
+      return { stages, reason: needsText ? "text evidence needed" : needsScene ? "scene analysis needed" : needsUI ? "UI/document analysis needed" : "auto" };
+  }
+}
+async function executeVisualEvidencePlan(resolution, plan, executor) {
+  const stages = [];
+  for (const stage of plan.stages) {
+    const start2 = Date.now();
+    try {
+      const result = await executor(stage.kind, resolution.path, "auto");
+      stages.push({ ...stage, completed: true, output: result.output, durationMs: result.durationMs });
+    } catch (err) {
+      stages.push({
+        ...stage,
+        completed: false,
+        error: err instanceof Error ? err.message : String(err),
+        durationMs: Date.now() - start2
+      });
+      if (stage.required) break;
+    }
+  }
+  const succeeded = stages.filter((s2) => s2.completed);
+  const finalSummary = succeeded.map((s2) => `${s2.kind}: ${(s2.output ?? "").slice(0, 200)}`).join("\n") || "No evidence extracted";
+  return {
+    resolution,
+    stages,
+    finalSummary,
+    confidence: succeeded.length >= plan.stages.length ? "high" : succeeded.length > 0 ? "medium" : "low",
+    unresolvedGaps: stages.filter((s2) => !s2.completed).map((s2) => `${s2.kind} stage failed: ${s2.error || "unknown"}`)
+  };
+}
+var init_telegram_vision_router = __esm({
+  "packages/cli/src/tui/telegram-vision-router.ts"() {
+    "use strict";
+  }
+});
+
 // packages/cli/src/tui/vision-ingress.ts
 var vision_ingress_exports = {};
 __export(vision_ingress_exports, {
@@ -645298,7 +645918,7 @@ __export(vision_ingress_exports, {
   runVisionIngress: () => runVisionIngress
 });
 import { execFileSync as execFileSync9 } from "node:child_process";
-import { existsSync as existsSync131, readFileSync as readFileSync109, unlinkSync as unlinkSync27 } from "node:fs";
+import { existsSync as existsSync131, readFileSync as readFileSync109, unlinkSync as unlinkSync28 } from "node:fs";
 import { join as join144 } from "node:path";
 function isTesseractAvailable() {
   try {
@@ -645356,7 +645976,7 @@ function advancedOcr(imagePath) {
         const text2 = readFileSync109(txtFile, "utf-8").trim();
         if (text2.length > 0) results.push(text2);
         try {
-          unlinkSync27(txtFile);
+          unlinkSync28(txtFile);
         } catch {
         }
       }
@@ -645474,7 +646094,7 @@ var init_vision_ingress = __esm({
 });
 
 // packages/cli/src/tui/telegram-bridge.ts
-import { mkdirSync as mkdirSync81, existsSync as existsSync132, unlinkSync as unlinkSync28, readdirSync as readdirSync46, statSync as statSync47, statfsSync as statfsSync5, readFileSync as readFileSync110, writeFileSync as writeFileSync72, appendFileSync as appendFileSync13 } from "node:fs";
+import { mkdirSync as mkdirSync81, existsSync as existsSync132, unlinkSync as unlinkSync29, readdirSync as readdirSync46, statSync as statSync47, statfsSync as statfsSync5, readFileSync as readFileSync110, writeFileSync as writeFileSync72, appendFileSync as appendFileSync13 } from "node:fs";
 import { join as join145, resolve as resolve56, basename as basename35, relative as relative15, isAbsolute as isAbsolute10, extname as extname19 } from "node:path";
 import { homedir as homedir45 } from "node:os";
 import { writeFile as writeFileAsync } from "node:fs/promises";
@@ -647569,6 +648189,7 @@ var init_telegram_bridge = __esm({
     init_telegram_reflection_extraction();
     init_telegram_social_state();
     init_dist();
+    init_telegram_vision_router();
     TELEGRAM_TOOL_ACTION_GROUPS = [
       "read",
       "message",
@@ -651666,6 +652287,19 @@ ${mediaContext}` : ""
           error: `Path is outside this Telegram chat's media/workspace scope or does not exist: ${raw || "(empty)"}`
         };
       }
+      resolveVisualMedia(rawValue, chatId, currentMsg, kind = "media") {
+        const result = this.resolveTelegramScopedMediaPath(rawValue, chatId, currentMsg, kind);
+        if (!result.ok) return { ok: false, error: result.error };
+        const mediaEntries = this.recentTelegramMediaEntries(chatId, 60).filter((entry) => this.telegramMediaEntryMatchesKind(entry, kind));
+        const matchingEntry = mediaEntries.find((entry) => resolve56(entry.localPath) === resolve56(result.path));
+        const sourceMessageId = matchingEntry?.messageId ?? currentMsg?.replyToMessageId;
+        const chatKey = chatId !== void 0 ? `chat:${chatId}` : "unknown";
+        const mediaKind = kind === "media" ? matchingEntry && telegramCachedMediaIsImage(matchingEntry) ? "image" : matchingEntry && telegramCachedMediaIsPdf(matchingEntry) ? "pdf" : matchingEntry && telegramCachedMediaIsAudio(matchingEntry) ? "audio" : matchingEntry && telegramCachedMediaIsVideo(matchingEntry) ? "video" : "media" : kind;
+        return {
+          ok: true,
+          resolution: { path: result.path, sourceMessageId, chatKey, mediaKind, safeAlias: basename35(result.path) }
+        };
+      }
       telegramIdentityMediaKind(args) {
         const action = String(args["action"] || "").toLowerCase();
         const relation = String(args["relation"] || "").toLowerCase();
@@ -654861,7 +655495,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
             if (prior.pid !== process.pid) return;
           } catch {
           }
-          unlinkSync28(lockFile);
+          unlinkSync29(lockFile);
         } catch {
         }
       }
@@ -656366,88 +657000,106 @@ ${conversationStream}`
       }
       async runTelegramChatCompletion(msg, toolContext, mediaContext, onToken) {
         const config = this.agentConfig;
-        const backend = new OllamaAgenticBackend(
-          config.backendUrl,
-          config.model,
-          config.apiKey
-        );
-        const request = telegramThinkSuppressedRequest({
-          messages: this.buildTelegramChatMessages(msg, toolContext, mediaContext),
-          tools: [],
-          temperature: 0.4,
-          maxTokens: 1500,
-          timeoutMs: Math.max(config.timeoutMs ?? 3e5, 12e4),
-          responseFormat: TELEGRAM_CHAT_REPLY_RESPONSE_FORMAT
-        });
-        let accumulated = "";
-        let streamError;
-        const sessionKey = this.sessionKeyForMessage(msg);
-        const inferenceId = this.registerTelegramInference("chat-fast-path", sessionKey, config.model);
-        const streamable = backend;
-        const stream = typeof streamable.chatCompletionStream === "function" ? streamable.chatCompletionStream(request) : null;
-        try {
-          if (stream && typeof stream[Symbol.asyncIterator] === "function") {
-            try {
-              let lastTokenEmitMs = 0;
-              for await (const chunk of stream) {
-                if (chunk.type !== "content") continue;
-                const piece = chunk.content;
-                if (!piece) continue;
-                if (chunk.thinking) {
-                  this.bumpTelegramInferenceTokens(inferenceId, 0, 1);
-                  if (this.telegramThinkingVisible) {
-                    const preview = piece.slice(0, 120);
-                    this.tuiWrite(() => renderTelegramSubAgentEvent(
-                      msg.username,
-                      `chat-fast-path thinking: ${JSON.stringify(preview)}`
-                    ));
-                  }
-                } else {
-                  this.bumpTelegramInferenceTokens(inferenceId, 1, 0);
-                  accumulated += piece;
-                  const now = Date.now();
-                  if (now - lastTokenEmitMs > 120) {
-                    lastTokenEmitMs = now;
-                    const partial = extractPartialTelegramReplyJson(accumulated);
-                    if (partial !== null) void onToken(partial);
+        return runWithOmniusContext({
+          runId: `chat-${msg.messageId}`,
+          surface: "telegram",
+          projectRoot: this.repoRoot,
+          ownerKind: "chat",
+          ownerId: String(msg.chatId),
+          telegram: {
+            chatId: msg.chatId,
+            chatType: msg.chatType,
+            messageId: msg.messageId,
+            threadId: msg.messageThreadId,
+            userId: msg.fromUserId,
+            username: msg.username || msg.firstName,
+            sessionKey: this.sessionKeyForMessage(msg),
+            toolContext
+          }
+        }, async () => {
+          const backend = new OllamaAgenticBackend(
+            config.backendUrl,
+            config.model,
+            config.apiKey
+          );
+          const request = telegramThinkSuppressedRequest({
+            messages: this.buildTelegramChatMessages(msg, toolContext, mediaContext),
+            tools: [],
+            temperature: 0.4,
+            maxTokens: 1500,
+            timeoutMs: Math.max(config.timeoutMs ?? 3e5, 12e4),
+            responseFormat: TELEGRAM_CHAT_REPLY_RESPONSE_FORMAT
+          });
+          let accumulated = "";
+          let streamError;
+          const sessionKey = this.sessionKeyForMessage(msg);
+          const inferenceId = this.registerTelegramInference("chat-fast-path", sessionKey, config.model);
+          const streamable = backend;
+          const stream = typeof streamable.chatCompletionStream === "function" ? streamable.chatCompletionStream(request) : null;
+          try {
+            if (stream && typeof stream[Symbol.asyncIterator] === "function") {
+              try {
+                let lastTokenEmitMs = 0;
+                for await (const chunk of stream) {
+                  if (chunk.type !== "content") continue;
+                  const piece = chunk.content;
+                  if (!piece) continue;
+                  if (chunk.thinking) {
+                    this.bumpTelegramInferenceTokens(inferenceId, 0, 1);
+                    if (this.telegramThinkingVisible) {
+                      const preview = piece.slice(0, 120);
+                      this.tuiWrite(() => renderTelegramSubAgentEvent(
+                        msg.username,
+                        `chat-fast-path thinking: ${JSON.stringify(preview)}`
+                      ));
+                    }
+                  } else {
+                    this.bumpTelegramInferenceTokens(inferenceId, 1, 0);
+                    accumulated += piece;
+                    const now = Date.now();
+                    if (now - lastTokenEmitMs > 120) {
+                      lastTokenEmitMs = now;
+                      const partial = extractPartialTelegramReplyJson(accumulated);
+                      if (partial !== null) void onToken(partial);
+                    }
                   }
                 }
-              }
-              const finalPartial = extractPartialTelegramReplyJson(accumulated);
-              if (finalPartial !== null) {
-                try {
-                  await onToken(finalPartial);
-                } catch {
+                const finalPartial = extractPartialTelegramReplyJson(accumulated);
+                if (finalPartial !== null) {
+                  try {
+                    await onToken(finalPartial);
+                  } catch {
+                  }
                 }
+              } catch (err) {
+                streamError = err;
+                accumulated = "";
               }
-            } catch (err) {
-              streamError = err;
-              accumulated = "";
             }
-          }
-          if (!accumulated.trim()) {
-            let result;
-            try {
-              result = await backend.chatCompletion(request);
-            } catch (err) {
-              if (streamError) {
-                const streamMsg = streamError instanceof Error ? streamError.message : String(streamError);
-                const retryMsg = err instanceof Error ? err.message : String(err);
-                throw new Error(`streaming failed (${streamMsg}); non-stream retry failed (${retryMsg})`);
+            if (!accumulated.trim()) {
+              let result;
+              try {
+                result = await backend.chatCompletion(request);
+              } catch (err) {
+                if (streamError) {
+                  const streamMsg = streamError instanceof Error ? streamError.message : String(streamError);
+                  const retryMsg = err instanceof Error ? err.message : String(err);
+                  throw new Error(`streaming failed (${streamMsg}); non-stream retry failed (${retryMsg})`);
+                }
+                throw err;
               }
-              throw err;
+              this.updateTelegramInferenceFinal(inferenceId, result);
+              accumulated = result.choices[0]?.message?.content ?? "";
+              const fullExtracted = extractPartialTelegramReplyJson(accumulated);
+              if (fullExtracted) await onToken(fullExtracted);
             }
-            this.updateTelegramInferenceFinal(inferenceId, result);
-            accumulated = result.choices[0]?.message?.content ?? "";
-            const fullExtracted = extractPartialTelegramReplyJson(accumulated);
-            if (fullExtracted) await onToken(fullExtracted);
+          } finally {
+            this.deregisterTelegramInference(inferenceId);
           }
-        } finally {
-          this.deregisterTelegramInference(inferenceId);
-        }
-        const extracted = extractFinalTelegramReplyJson(accumulated);
-        if (extracted) return extracted;
-        return stripTelegramHiddenThinking(accumulated).trim();
+          const extracted = extractFinalTelegramReplyJson(accumulated);
+          if (extracted) return extracted;
+          return stripTelegramHiddenThinking(accumulated).trim();
+        });
       }
       retainTelegramVisibleReplyDraft(subAgent, draft, streamToolNames = subAgent.currentStreamToolNames) {
         if (subAgent.visibleReplyText) return;
@@ -656530,7 +657182,21 @@ ${conversationStream}`
           // approval on, persistence via unlimited maxTurns above. Both keep
           // brute-force re-engagement and Adversary turn-extension OFF, which is
           // how Telegram avoids the 60+ turn self-talk loops.
-          ...isAdminDM ? TELEGRAM_ADMIN_EVIDENCE_OPTIONS : TELEGRAM_PUBLIC_FAST_OPTIONS
+          ...isAdminDM ? TELEGRAM_ADMIN_EVIDENCE_OPTIONS : TELEGRAM_PUBLIC_FAST_OPTIONS,
+          // ── WO #03 (Typed Gateway Event Stream): structured event feed ──
+          onTypedEvent: (event) => {
+            if (event.type === "run_finished") {
+              subAgent.runnerCompleted = event.success;
+              subAgent.runnerStatus = event.status;
+              subAgent.completionBoundarySeen = event.status === "completed";
+            }
+            if (event.type === "completion_incomplete_verification") {
+              subAgent.completionBoundarySeen = false;
+            }
+            if (event.type === "completion_accepted") {
+              subAgent.completionBoundarySeen = true;
+            }
+          }
         });
         runner.setWorkingDirectory(repoRoot);
         subAgent.runner = runner;
@@ -656760,7 +657426,23 @@ ${creativeWorkspace}` : ""}`;
           mediaContext,
           additionalContext
         };
-        const result = await runner.run(userPrompt, systemCtx);
+        const result = await runWithOmniusContext({
+          runId: subAgent.viewId,
+          surface: "telegram",
+          projectRoot: repoRoot,
+          ownerKind: "chat",
+          ownerId: String(msg.chatId),
+          telegram: {
+            chatId: msg.chatId,
+            chatType: msg.chatType,
+            messageId: msg.messageId,
+            threadId: msg.messageThreadId,
+            userId: msg.fromUserId,
+            username: msg.username || msg.firstName,
+            sessionKey: sessionContext.sessionKey,
+            toolContext: ctx3
+          }
+        }, () => runner.run(userPrompt, systemCtx));
         subAgent.runnerCompleted = result.completed;
         subAgent.runnerStatus = result.status;
         subAgent.runnerTurns = result.turns;
@@ -658993,15 +659675,23 @@ Scoped workspace: ${scopedRoot}`,
           },
           async execute(args) {
             const start2 = performance.now();
-            const resolved = bridge.resolveTelegramScopedMediaPath(args["image"], chatId, currentMsg, "image");
-            if (!resolved.ok) {
-              return { success: false, output: "", error: resolved.error, durationMs: performance.now() - start2 };
-            }
-            const detail = normalizeTelegramImageAnalyzeDetail(args["detail"]);
             const question = String(args["question"] ?? args["prompt"] ?? currentMsg?.text ?? "").trim();
+            const detail = normalizeTelegramImageAnalyzeDetail(args["detail"]);
+            const request = {
+              prompt: question,
+              mediaRef: args["image"],
+              surface: "telegram",
+              requestedDetail: detail
+            };
+            const plan = deriveVisualEvidencePlan(request);
+            const mediaResult = bridge.resolveVisualMedia(args["image"], chatId, currentMsg, "image");
+            if (!mediaResult.ok) {
+              return { success: false, output: "", error: mediaResult.error, durationMs: performance.now() - start2 };
+            }
+            const resolution = mediaResult.resolution;
             const stageLines = [
-              `Telegram image analysis: media=${basename35(resolved.path)} detail=${detail}`,
-              "Stage ladder: low_fidelity_image_read -> basic OCR probe -> advanced OCR when text density/under-extraction warrants it -> Moondream vision when visual QA/captioning is warranted."
+              `Telegram image analysis: media=${resolution.safeAlias} detail=${detail}`,
+              `Evidence plan: ${plan.reason}`
             ];
             const llmParts = [];
             const runStage = async (name10, reason, fn) => {
@@ -659017,75 +659707,75 @@ ${result.llmContent ?? result.output ?? ""}${result.success ? "" : `
 ERROR: ${result.error || "stage failed"}`}`);
               return result;
             };
-            const imageRead = await runStage(
-              "low_fidelity_image_read",
-              "Always start with scoped image metadata and a multimodal image payload for the model.",
-              () => new ImageReadTool(repoRoot).execute({
-                path: resolved.path,
-                ocr: false,
-                max_size_kb: typeof args["max_size_kb"] === "number" ? args["max_size_kb"] : 10240
-              })
-            );
-            const textRequested = detail === "text" || detail === "full";
-            const visualRequested = detail === "visual" || detail === "full";
-            const shouldRunTextProbe = detail !== "visual";
-            let textStage = null;
-            let textSignal = telegramTextExtractionSignal("");
-            if (shouldRunTextProbe) {
-              textStage = await runStage(
-                "ocr",
-                "After low-fidelity intake, basic OCR measures whether text extraction is sufficient before any heavier escalation.",
-                () => new OCRTool(repoRoot).execute({
-                  path: resolved.path,
-                  language: typeof args["language"] === "string" ? args["language"] : "eng"
-                })
-              );
-              textSignal = telegramTextExtractionSignal(textStage.output ?? "");
-              stageLines.push(
-                `
+            const executor = async (kind, path12, _execDetail) => {
+              switch (kind) {
+                case "low_fidelity_observation": {
+                  const result = await runStage(
+                    "low_fidelity_observation",
+                    "Always start with scoped image metadata and a multimodal image payload for the model.",
+                    () => new ImageReadTool(repoRoot).execute({
+                      path: path12,
+                      ocr: false,
+                      max_size_kb: typeof args["max_size_kb"] === "number" ? args["max_size_kb"] : 10240
+                    })
+                  );
+                  return { output: result.output ?? "", durationMs: result.durationMs };
+                }
+                case "ocr": {
+                  const textRequested = detail === "text" || detail === "full";
+                  const ocrResult = await runStage(
+                    "ocr",
+                    "After low-fidelity intake, basic OCR measures whether text extraction is sufficient before any heavier escalation.",
+                    () => new OCRTool(repoRoot).execute({
+                      path: path12,
+                      language: typeof args["language"] === "string" ? args["language"] : "eng"
+                    })
+                  );
+                  let textSignal = telegramTextExtractionSignal(ocrResult.output ?? "");
+                  stageLines.push(
+                    `
 Text extraction signal: chars=${textSignal.chars}, lines=${textSignal.lines}, longest_line=${textSignal.longestLine}, dense=${textSignal.dense ? "yes" : "no"}.`
-              );
-              llmParts.push(`Text extraction signal: ${JSON.stringify(textSignal)}`);
-              const shouldUseAdvancedOcr = detail === "full" || textSignal.dense || textRequested && !textSignal.present;
-              if (shouldUseAdvancedOcr) {
-                textStage = await runStage(
-                  "ocr_image_advanced",
-                  textSignal.dense ? "Basic OCR observed dense text, so multi-pass OCR is warranted." : "The request emphasized text extraction and basic intake did not provide enough text.",
-                  () => new OcrImageAdvancedTool(repoRoot).execute({
-                    image: resolved.path,
-                    language: typeof args["language"] === "string" ? args["language"] : "eng"
-                  })
-                );
-                const advancedSignal = telegramTextExtractionSignal(textStage.output ?? "");
-                stageLines.push(
-                  `
+                  );
+                  llmParts.push(`Text extraction signal: ${JSON.stringify(textSignal)}`);
+                  const shouldUseAdvancedOcr = detail === "full" || textSignal.dense || textRequested && !textSignal.present;
+                  if (shouldUseAdvancedOcr) {
+                    const advancedResult = await runStage(
+                      "ocr_image_advanced",
+                      textSignal.dense ? "Basic OCR observed dense text, so multi-pass OCR is warranted." : "The request emphasized text extraction and basic intake did not provide enough text.",
+                      () => new OcrImageAdvancedTool(repoRoot).execute({
+                        image: path12,
+                        language: typeof args["language"] === "string" ? args["language"] : "eng"
+                      })
+                    );
+                    const advancedSignal = telegramTextExtractionSignal(advancedResult.output ?? "");
+                    stageLines.push(
+                      `
 Advanced text extraction signal: chars=${advancedSignal.chars}, lines=${advancedSignal.lines}, longest_line=${advancedSignal.longestLine}, dense=${advancedSignal.dense ? "yes" : "no"}.`
-                );
-                llmParts.push(`Advanced text extraction signal: ${JSON.stringify(advancedSignal)}`);
-                if (advancedSignal.present || !textSignal.present) textSignal = advancedSignal;
+                    );
+                    llmParts.push(`Advanced text extraction signal: ${JSON.stringify(advancedSignal)}`);
+                    return { output: advancedResult.output ?? ocrResult.output ?? "", durationMs: ocrResult.durationMs + advancedResult.durationMs };
+                  }
+                  return { output: ocrResult.output ?? "", durationMs: ocrResult.durationMs };
+                }
+                case "auxiliary_vision": {
+                  const result = await runStage(
+                    "auxiliary_vision",
+                    question ? "A visual question is present, so Moondream visual QA is warranted after lower-cost intake." : "Text extraction did not provide enough content or visual detail was requested, so Moondream captioning is warranted.",
+                    () => new VisionTool(repoRoot).execute({
+                      image: path12,
+                      action: question ? "query" : "caption",
+                      ...question ? { prompt: question } : {},
+                      length: "normal"
+                    })
+                  );
+                  return { output: result.output ?? "", durationMs: result.durationMs };
+                }
+                default:
+                  throw new Error(`Unknown evidence stage kind: ${kind}`);
               }
-            } else {
-              stageLines.push("\n## OCR skipped\nReason: Visual detail was explicitly requested and text extraction was not needed.");
-              llmParts.push("## OCR skipped\nReason: Visual detail was explicitly requested and text extraction was not needed.");
-            }
-            const shouldRunVision = visualRequested || Boolean(question && detail !== "text") || !textSignal.present && detail !== "text";
-            let visionStage = null;
-            if (shouldRunVision) {
-              visionStage = await runStage(
-                "vision_moondream",
-                question ? "A visual question is present, so Moondream visual QA is warranted after lower-cost intake." : "Text extraction did not provide enough content or visual detail was requested, so Moondream captioning is warranted.",
-                () => new VisionTool(repoRoot).execute({
-                  image: resolved.path,
-                  action: question ? "query" : "caption",
-                  ...question ? { prompt: question } : {},
-                  length: "normal"
-                })
-              );
-            } else {
-              stageLines.push("\n## vision_moondream skipped\nReason: OCR/text extraction produced sufficient evidence for the requested detail.");
-              llmParts.push("## vision_moondream skipped\nReason: OCR/text extraction produced sufficient evidence for the requested detail.");
-            }
-            const anySuccess = imageRead.success || Boolean(textStage?.success) || Boolean(visionStage?.success);
+            };
+            const packet = await executeVisualEvidencePlan(resolution, plan, executor);
+            const anySuccess = packet.stages.some((s2) => s2.completed);
             const output = stageLines.join("\n");
             return {
               success: anySuccess,
@@ -659606,7 +660296,7 @@ ${text2}`.trim());
         for (const [key, entry] of this.mediaCache) {
           if (now - entry.cachedAt > MEDIA_CACHE_TTL_MS) {
             try {
-              unlinkSync28(entry.localPath);
+              unlinkSync29(entry.localPath);
             } catch {
             }
             this.mediaCache.delete(key);
@@ -660656,7 +661346,7 @@ import {
   writeFileSync as writeFileSync73,
   renameSync as renameSync10,
   mkdirSync as mkdirSync82,
-  unlinkSync as unlinkSync29,
+  unlinkSync as unlinkSync30,
   appendFileSync as appendFileSync14
 } from "node:fs";
 import { join as join146 } from "node:path";
@@ -660695,7 +661385,7 @@ function persistInFlight(j) {
 function deleteInFlightFile(id) {
   try {
     const p2 = inFlightPath(id);
-    if (existsSync133(p2)) unlinkSync29(p2);
+    if (existsSync133(p2)) unlinkSync30(p2);
   } catch {
   }
 }
@@ -660915,7 +661605,7 @@ function drainCheckins(sessionId) {
   try {
     const raw = readFileSync111(fp, "utf-8");
     try {
-      unlinkSync29(fp);
+      unlinkSync30(fp);
     } catch {
     }
     if (!raw.trim()) return [];
@@ -660953,7 +661643,7 @@ function listSessions2() {
 function deleteSession2(id) {
   try {
     const p2 = sessionPath(id);
-    if (existsSync133(p2)) unlinkSync29(p2);
+    if (existsSync133(p2)) unlinkSync30(p2);
   } catch {
   }
   deleteInFlightFile(id);
@@ -662294,7 +662984,7 @@ var init_access_policy = __esm({
 
 // packages/cli/src/api/project-preferences.ts
 import { createHash as createHash40 } from "node:crypto";
-import { existsSync as existsSync135, mkdirSync as mkdirSync84, readFileSync as readFileSync113, renameSync as renameSync12, writeFileSync as writeFileSync75, unlinkSync as unlinkSync30 } from "node:fs";
+import { existsSync as existsSync135, mkdirSync as mkdirSync84, readFileSync as readFileSync113, renameSync as renameSync12, writeFileSync as writeFileSync75, unlinkSync as unlinkSync31 } from "node:fs";
 import { homedir as homedir48 } from "node:os";
 import { join as join148, resolve as resolve58 } from "node:path";
 import { randomUUID as randomUUID19 } from "node:crypto";
@@ -662355,7 +663045,7 @@ function writeProjectPreferences(root, partial) {
     } catch {
     }
     try {
-      unlinkSync30(tmp);
+      unlinkSync31(tmp);
     } catch {
     }
     throw err;
@@ -662366,7 +663056,7 @@ function deleteProjectPreferences(root) {
   try {
     const file = prefsPath(root);
     if (!existsSync135(file)) return false;
-    unlinkSync30(file);
+    unlinkSync31(file);
     return true;
   } catch {
     return false;
@@ -678308,7 +678998,7 @@ import { fileURLToPath as fileURLToPath19 } from "node:url";
 import { dirname as dirname48, join as join158, resolve as resolve60 } from "node:path";
 import { homedir as homedir54 } from "node:os";
 import { spawn as spawn32, execSync as execSync59 } from "node:child_process";
-import { mkdirSync as mkdirSync92, writeFileSync as writeFileSync80, readFileSync as readFileSync120, readdirSync as readdirSync50, existsSync as existsSync145, watch as fsWatch4, renameSync as renameSync13, unlinkSync as unlinkSync31, statSync as statSync52, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "node:fs";
+import { mkdirSync as mkdirSync92, writeFileSync as writeFileSync80, readFileSync as readFileSync120, readdirSync as readdirSync50, existsSync as existsSync145, watch as fsWatch4, renameSync as renameSync13, unlinkSync as unlinkSync32, statSync as statSync52, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "node:fs";
 import { randomBytes as randomBytes28, randomUUID as randomUUID20 } from "node:crypto";
 import { createHash as createHash42 } from "node:crypto";
 function memoryDbPaths3(baseDir = process.cwd()) {
@@ -679333,13 +680023,13 @@ function pruneOldJobs() {
       const ts = ageRef ? Date.parse(ageRef) : NaN;
       if (Number.isFinite(ts) && ts < cutoffMs) {
         try {
-          unlinkSync31(path12);
+          unlinkSync32(path12);
         } catch {
         }
         const outFile = path12.replace(/\.json$/, ".output");
         if (existsSync145(outFile)) {
           try {
-            unlinkSync31(outFile);
+            unlinkSync32(outFile);
           } catch {
           }
         }
@@ -679349,7 +680039,7 @@ function pruneOldJobs() {
       }
     } catch {
       try {
-        unlinkSync31(path12);
+        unlinkSync32(path12);
         pruned++;
       } catch {
       }
@@ -679641,7 +680331,7 @@ function atomicJobWrite(dir, id, job) {
     } catch {
     }
     try {
-      unlinkSync31(tmpPath);
+      unlinkSync32(tmpPath);
     } catch {
     }
   }
@@ -681600,12 +682290,13 @@ async function handleV1Run(req3, res) {
   const _rca1EffectiveTimeoutS = timeout2 && timeout2 > 0 ? timeout2 : activeProfile?.limits?.timeout_s && activeProfile.limits.timeout_s > 0 ? activeProfile.limits.timeout_s : 1800;
   const _rca1DeadlineAtMs = Date.now() + (_rca1EffectiveTimeoutS + 60) * 1e3;
   if (job.pid > 0) {
+    const runCtx = getOmniusRunContext();
     registerProcessLease({
       leaseId: runLeaseId,
       pid: job.pid,
       pgid: process.platform === "win32" ? void 0 : job.pid,
-      ownerKind: "api_run",
-      ownerId: id,
+      ownerKind: runCtx?.ownerKind ?? "api_run",
+      ownerId: runCtx?.ownerId ?? id,
       projectRoot: cwd4,
       lifecycle: "run",
       persistent: false,
@@ -682985,7 +683676,7 @@ async function handleRequest(req3, res, ollamaUrl, verbose, runtimeDefaults = {}
           return;
         }
         const { tmpdir: tmpdir24 } = await import("node:os");
-        const { writeFileSync: writeFileSync85, unlinkSync: unlinkSync32 } = await import("node:fs");
+        const { writeFileSync: writeFileSync85, unlinkSync: unlinkSync33 } = await import("node:fs");
         const { join: pjoin } = await import("node:path");
         const tmpPath = pjoin(tmpdir24(), `omnius-clone-upload-${Date.now()}-${safeName3}`);
         writeFileSync85(tmpPath, buf);
@@ -683000,7 +683691,7 @@ async function handleRequest(req3, res, ollamaUrl, verbose, runtimeDefaults = {}
           });
         } finally {
           try {
-            unlinkSync32(tmpPath);
+            unlinkSync33(tmpPath);
           } catch {
           }
         }
@@ -683899,12 +684590,13 @@ ${historyLines}
         detached: true
       });
       if (child.pid) {
+        const chatCtx = getOmniusRunContext();
         registerProcessLease({
           leaseId: chatLeaseId,
           pid: child.pid,
           pgid: process.platform === "win32" ? void 0 : child.pid,
-          ownerKind: "chat_run",
-          ownerId: inFlightRunId,
+          ownerKind: chatCtx?.ownerKind ?? "chat_run",
+          ownerId: chatCtx?.ownerId ?? inFlightRunId,
           projectRoot: cwdPath,
           lifecycle: "run",
           persistent: false,
@@ -685431,8 +686123,8 @@ function startApiServer(options2 = {}) {
             const job = JSON.parse(readFileSync120(jobPath, "utf-8"));
             const jobTime = new Date(job.startedAt ?? job.completedAt ?? 0).getTime();
             if (jobTime > 0 && jobTime < cutoff && job.status !== "running") {
-              const { unlinkSync: unlinkSync32 } = require4("node:fs");
-              unlinkSync32(jobPath);
+              const { unlinkSync: unlinkSync33 } = require4("node:fs");
+              unlinkSync33(jobPath);
             }
           } catch {
           }
@@ -689586,7 +690278,14 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
     }
   }
   resetSessionLock();
-  const promise = runner.run(effectiveTask, systemContext).then((result) => {
+  const promise = Promise.resolve(runWithOmniusContext({
+    runId: sessionId,
+    surface: "tui",
+    projectRoot: repoRoot,
+    ownerKind: "tui",
+    ownerId: `session:${sessionId}`
+  }, async () => {
+    const result = await runner.run(effectiveTask, systemContext);
     const tokens = {
       total: result.totalTokens,
       estimated: result.estimatedTokens
@@ -689969,7 +690668,7 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
       }
       _checkinPoller = null;
     }
-  });
+  }));
   return {
     runner,
     promise,
@@ -691150,12 +691849,18 @@ Respond to the scoped Telegram target when complete.`);
       runner.setWorkingDirectory(repoRoot);
       runner.registerTools(buildSubAgentTools(repoRoot, currentConfig).map(adaptTool6));
       runner.registerTool(createTaskCompleteTool(modelTier, repoRoot));
-      const result = await runner.run(
+      const result = await runWithOmniusContext({
+        runId: `bg-${Date.now()}`,
+        surface: "background",
+        projectRoot: repoRoot,
+        ownerKind: "tui",
+        ownerId: `session:${process.env["OMNIUS_SESSION_ID"] || "terminal"}`
+      }, () => runner.run(
         prompt,
         `Working directory: ${repoRoot}
 
 This is an independent background session started from /background.`
-      );
+      ));
       return [
         result.completed ? "completed" : "incomplete",
         `${result.turns} turns, ${result.toolCalls} tool calls`,
@@ -696998,6 +697703,7 @@ import { dirname as dirname50, join as join164 } from "node:path";
 
 // packages/cli/src/cli.ts
 init_typed_node_events();
+init_dist5();
 init_dist8();
 import { createInterface } from "node:readline";
 function createCli(options2) {
@@ -697049,7 +697755,13 @@ function createCli(options2) {
           return;
         }
         try {
-          const result = await runner.run(input);
+          const result = await runWithOmniusContext({
+            runId: `cli-${Date.now()}`,
+            surface: "tui",
+            projectRoot: options2.projectRoot,
+            ownerKind: "cli",
+            ownerId: `cli:${process.pid}`
+          }, () => runner.run(input));
           console.log("");
           console.log(`[agent] Task completed: ${result.completed ? "success" : "incomplete"}`);
           if (result.summary) {