omnius 1.0.238 → 1.0.240

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 });
@@ -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");
@@ -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");
@@ -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 unlinkSync17, 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,
@@ -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();
@@ -590910,18 +591476,35 @@ function buildToolResultBody(toolName, success, output, verbose) {
     return diffBodyLines(output, verbose);
   }
   if (toolName === "file_write") {
-    const summary = extractFirstLine(output, Number.MAX_SAFE_INTEGER);
-    return [{
-      text: summary,
+    if (!success) {
+      return [{ text: extractFirstLine(output, Number.MAX_SAFE_INTEGER), mode: "wrap", kind: "error" }];
+    }
+    const writeLines = output.split("\n").filter((l2) => l2.trim());
+    if (writeLines.length === 0) {
+      return [{ text: "Done", mode: "wrap", kind: "success" }];
+    }
+    const maxLines2 = resolveToolOutputMaxLines(verbose);
+    return writeLines.slice(0, maxLines2).map((line) => ({
+      text: line,
       mode: "wrap",
-      kind: success ? "dim" : "error"
-    }];
+      kind: "dim"
+    }));
   }
   if (toolName === "file_read") {
     if (!success) {
       return [{ text: extractFirstLine(output, Number.MAX_SAFE_INTEGER), mode: "wrap", kind: "error" }];
     }
-    return codePreviewLines(output, resolveToolOutputMaxLines(verbose));
+    const body = codePreviewLines(output, resolveToolOutputMaxLines(verbose));
+    const headerMatch = output.match(/^\[FILE CONTEXT \| (.+?) \| (.+?) \| sha256=(.+?)\]/);
+    if (headerMatch) {
+      const [, filePath, scope, hash] = headerMatch;
+      body.unshift({
+        text: c3.dim(`Read ${scope} from ${filePath} · sha256 ${hash.slice(0, 12)}…`),
+        mode: "wrap",
+        kind: "plain"
+      });
+    }
+    return body;
   }
   if (toolName === "task_complete") {
     const summary = output && output.trim() ? output : "Done";
@@ -590984,6 +591567,7 @@ function codePreviewLines(output, maxLines) {
   const lines = output.split("\n");
   let start2 = 0;
   while (start2 < lines.length && !lines[start2].trim()) start2++;
+  if (start2 < lines.length && /^\[FILE CONTEXT \|/.test(lines[start2])) start2++;
   const shown = lines.slice(start2, start2 + maxLines);
   if (shown.length === 0) return [{ text: "(empty file)", mode: "wrap", kind: "dim" }];
   const body = shown.map((line) => ({
@@ -645287,6 +645871,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, {
@@ -647569,6 +648207,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 +652305,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();
@@ -656366,88 +657018,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 +657200,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 +657444,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 +659693,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 +659725,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,
@@ -681600,12 +682308,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,
@@ -683899,12 +684608,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,
@@ -687857,8 +688567,19 @@ function createDMNEventHandler(verbose, writeContent) {
         break;
       case "model_response":
         if (verbose && event.content) {
-          const preview = event.content.length > 200 ? event.content.slice(0, 200) + "..." : event.content;
-          writeContent(() => renderVerbose(`DMN thinking: ${preview}`));
+          const lines = event.content.split("\n");
+          const maxPreviewLines = 15;
+          if (lines.length > maxPreviewLines) {
+            const preview = lines.slice(0, maxPreviewLines).join("\n");
+            writeContent(
+              () => renderVerbose(`DMN thinking (${lines.length} lines, showing first ${maxPreviewLines}):
+${preview}
+... ${lines.length - maxPreviewLines} more lines`)
+            );
+          } else {
+            writeContent(() => renderVerbose(`DMN thinking (${lines.length} lines):
+${event.content}`));
+          }
         }
         break;
       case "token_usage":
@@ -687894,6 +688615,22 @@ function formatDMNToolArgs(toolName, args) {
       return "";
   }
 }
+function truncateByLines(text2, maxLines, maxChars = 600) {
+  const lines = text2.split("\n");
+  if (lines.length <= maxLines && text2.length <= maxChars) return text2;
+  if (lines.length > maxLines) {
+    const shown = lines.slice(0, maxLines);
+    const rest = lines.length - maxLines;
+    const joined = shown.join("\n");
+    if (joined.length > maxChars) {
+      return joined.slice(0, maxChars - 20) + `
+… (${rest} more lines, ${text2.length - joined.length} chars omitted)`;
+    }
+    return joined + `
+… ${rest} more lines`;
+  }
+  return text2.length > maxChars ? text2.slice(0, maxChars - 3) + "…" : text2;
+}
 async function renderAsciiPreviewForImage(imagePath, displayPath, title, writer) {
   try {
     const {
@@ -689231,7 +689968,7 @@ ${entry.fullContent}`
           ts: Date.now(),
           source: "main",
           sourceId: "main",
-          summary: String(event.content ?? "").slice(0, 120),
+          summary: truncateByLines(String(event.content ?? ""), 3, 240),
           toolName: event.toolName ?? "unknown",
           success: event.success ?? false
         });
@@ -689258,7 +689995,7 @@ ${entry.fullContent}`
         } else if (isNeovimActive()) {
           const ok3 = event.success ?? false;
           const prefix = ok3 ? "\x1B[32m✓\x1B[0m" : "\x1B[31m✗\x1B[0m";
-          const preview = displayContent.slice(0, 120).replace(/\n/g, " ");
+          const preview = truncateByLines(displayContent, 3, 240).replace(/\n/g, " ");
           writeToNeovimOutput(`  ${prefix} ${preview}\r
 `);
         } else {
@@ -689586,7 +690323,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 +690713,7 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
       }
       _checkinPoller = null;
     }
-  });
+  }));
   return {
     runner,
     promise,
@@ -691150,12 +691894,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 +697748,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 +697800,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) {