omnius 1.0.272 → 1.0.274

package/dist/index.js

@@ -551999,22 +551999,48 @@ var init_VllmBackend = __esm({
       // -------------------------------------------------------------------------
       // LLMBackend — healthCheck
       // -------------------------------------------------------------------------
+      /**
+       * Health check with retry + circuit breaker.
+       * Retries up to 3 times with exponential backoff (1s, 2s, 4s).
+       * After 3 consecutive failures, enters "degraded" state for 30s before retrying.
+       */
+      consecutiveFailures = 0;
+      degradedUntil = 0;
       async healthCheck() {
+        if (this.consecutiveFailures >= 3 && Date.now() < this.degradedUntil) {
+          return false;
+        }
+        if (this.consecutiveFailures >= 3 && Date.now() >= this.degradedUntil) {
+          this.consecutiveFailures = 0;
+        }
         const url = `${this.baseUrl}/health`;
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), 5e3);
-        try {
-          const response = await fetch(url, {
-            method: "GET",
-            signal: controller.signal,
-            headers: this.authHeaders()
-          });
-          return response.ok;
-        } catch {
-          return false;
-        } finally {
-          clearTimeout(timer);
+        const maxRetries = 3;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          if (attempt > 0) {
+            const backoff = Math.min(1e3 * Math.pow(2, attempt - 1), 4e3);
+            await new Promise((r2) => setTimeout(r2, backoff));
+          }
+          try {
+            const response = await fetch(url, {
+              method: "GET",
+              signal: controller.signal,
+              headers: this.authHeaders()
+            });
+            if (response.ok) {
+              this.consecutiveFailures = 0;
+              return true;
+            }
+          } catch {
+          }
         }
+        clearTimeout(timer);
+        this.consecutiveFailures++;
+        if (this.consecutiveFailures >= 3) {
+          this.degradedUntil = Date.now() + 3e4;
+        }
+        return false;
       }
       // -------------------------------------------------------------------------
       // LLMBackend — complete
@@ -552186,21 +552212,47 @@ var init_OllamaBackend = __esm({
       // -------------------------------------------------------------------------
       // LLMBackend — healthCheck
       // -------------------------------------------------------------------------
+      /**
+       * Health check with retry + circuit breaker.
+       * Retries up to 3 times with exponential backoff (1s, 2s, 4s).
+       * After 3 consecutive failures, enters "degraded" state for 30s before retrying.
+       */
+      consecutiveFailures = 0;
+      degradedUntil = 0;
       async healthCheck() {
+        if (this.consecutiveFailures >= 3 && Date.now() < this.degradedUntil) {
+          return false;
+        }
+        if (this.consecutiveFailures >= 3 && Date.now() >= this.degradedUntil) {
+          this.consecutiveFailures = 0;
+        }
         const url = `${this.baseUrl}/api/tags`;
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), 5e3);
-        try {
-          const response = await fetch(url, {
-            method: "GET",
-            signal: controller.signal
-          });
-          return response.ok;
-        } catch {
-          return false;
-        } finally {
-          clearTimeout(timer);
+        const maxRetries = 3;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          if (attempt > 0) {
+            const backoff = Math.min(1e3 * Math.pow(2, attempt - 1), 4e3);
+            await new Promise((r2) => setTimeout(r2, backoff));
+          }
+          try {
+            const response = await fetch(url, {
+              method: "GET",
+              signal: controller.signal
+            });
+            if (response.ok) {
+              this.consecutiveFailures = 0;
+              return true;
+            }
+          } catch {
+          }
         }
+        clearTimeout(timer);
+        this.consecutiveFailures++;
+        if (this.consecutiveFailures >= 3) {
+          this.degradedUntil = Date.now() + 3e4;
+        }
+        return false;
       }
       // -------------------------------------------------------------------------
       // LLMBackend — complete
@@ -555379,210 +555431,531 @@ var init_permissionRuleset = __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) {
+// packages/orchestrator/dist/steeringIntake.js
+import { randomUUID as randomUUID16 } from "node:crypto";
+import { appendFileSync as appendFileSync4, existsSync as existsSync79, mkdirSync as mkdirSync45, readFileSync as readFileSync60 } from "node:fs";
+import { join as join91 } from "node:path";
+import { z as z16 } from "zod";
+function createSteeringIngress(input) {
   return {
-    key: normalizeCompletionKey(key),
-    label,
-    fieldType: "json",
-    elevation: "required",
-    sourceMode: "derived",
-    description,
-    acceptanceCriteria
+    id: randomUUID16(),
+    rawText: input.rawText.trim(),
+    sourceSurface: input.sourceSurface,
+    authority: "user",
+    isReplacement: input.isReplacement ?? false,
+    currentTaskGoal: input.currentTaskGoal || "(unknown current task)",
+    recentActivity: input.recentActivity,
+    filesTouched: (input.filesTouched ?? []).filter(Boolean).slice(0, 12),
+    toolCallCount: input.toolCallCount ?? 0,
+    taskId: input.taskId,
+    sessionId: input.sessionId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-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."
+async function interpretSteeringIngress(backend, ingress, timeoutMs = 8e3) {
+  const first2 = await backend.chatCompletion({
+    messages: [
+      {
+        role: "system",
+        content: [
+          "You interpret human feedback for a running coding agent.",
+          "Return strict JSON only.",
+          "Use only the supplied task trajectory and ingress.",
+          "The JSON fields describe task impact and next-action guidance."
+        ].join("\n")
+      },
+      { role: "user", content: buildInterpretationPrompt(ingress) }
+    ],
+    tools: [],
+    temperature: 0.2,
+    maxTokens: 512,
+    timeoutMs,
+    think: false,
+    responseFormat: steeringInterpretationResponseFormat()
+  });
+  const raw = first2.choices[0]?.message?.content ?? "";
+  const parsed = parseSteeringInterpretation(raw);
+  if (parsed)
+    return parsed;
+  const repaired = await backend.chatCompletion({
+    messages: [
+      {
+        role: "system",
+        content: "Repair the supplied text into strict JSON matching the requested schema. Return JSON only."
+      },
+      {
+        role: "user",
+        content: [
+          "Schema keys: inference, runnerInstruction, conflicts, alternatives, memoryNote.",
+          "Required keys: inference, runnerInstruction.",
+          "",
+          "Original task state and ingress:",
+          buildInterpretationPrompt(ingress),
+          "",
+          "Malformed model output:",
+          raw
+        ].join("\n")
       }
-    }
-  ];
-  return {
-    goalSummary,
-    surfaces: [],
-    fields,
-    requirements: [],
-    phases,
-    acceptanceCriteria: [
-      "The final response distinguishes completed work from verified evidence and unverified or blocked claims."
-    ]
-  };
+    ],
+    tools: [],
+    temperature: 0,
+    maxTokens: 512,
+    timeoutMs,
+    think: false,
+    responseFormat: steeringInterpretationResponseFormat()
+  });
+  return parseSteeringInterpretation(repaired.choices[0]?.message?.content ?? "");
 }
-function inferCompletionContractFromTexts(texts, fallbackSummary = "") {
-  const combined = texts.map((text2) => String(text2 ?? "").trim()).filter(Boolean).join("\n\n");
-  return inferCompletionContract(combined || fallbackSummary);
+function buildSteeringPacket(ingress, interpretation) {
+  const lines = [
+    STEERING_START,
+    `id: ${ingress.id}`,
+    `sourceSurface: ${ingress.sourceSurface}`,
+    `feedbackKind: external_human`,
+    `authority: ${ingress.authority}`,
+    `replacement: ${ingress.isReplacement ? "true" : "false"}`,
+    `toolCallsSoFar: ${ingress.toolCallCount}`,
+    `timestamp: ${ingress.timestamp}`,
+    "",
+    "Instruction hierarchy:",
+    "- Treat this as user-level steering, below system/developer/tool safety and above older user assumptions when they conflict.",
+    "",
+    "Current task goal:",
+    truncateBlock(ingress.currentTaskGoal || "(unknown current task)", 1200),
+    "",
+    "Recent activity:",
+    truncateBlock(ingress.recentActivity || "(no recent activity recorded)", 1200),
+    "",
+    ingress.filesTouched.length > 0 ? `Files touched so far: ${ingress.filesTouched.join(", ")}` : "Files touched so far: none recorded",
+    "",
+    RAW_START,
+    ingress.rawText,
+    RAW_END,
+    ""
+  ];
+  if (interpretation) {
+    lines.push("Model-derived steering interpretation:", `inference: ${interpretation.inference}`, `runnerInstruction: ${interpretation.runnerInstruction}`);
+    if (interpretation.conflicts?.length) {
+      lines.push("conflicts:", ...interpretation.conflicts.map((item) => `- ${item}`));
+    }
+    if (interpretation.alternatives?.length) {
+      lines.push("alternative interpretations:", ...interpretation.alternatives.map((item) => `- ${item}`));
+    }
+    if (interpretation.memoryNote) {
+      lines.push(`memoryNote: ${interpretation.memoryNote}`);
+    }
+    lines.push("");
+  } else {
+    lines.push("Model-derived steering interpretation: unavailable", "");
+  }
+  lines.push("Interleave contract:", "- Consume this before the next assistant/tool decision.", "- Do not treat it as passive transcript context.", "- Either act on the steering directly, or explicitly reconcile why it does not alter the current plan.", STEERING_END);
+  return lines.join("\n");
 }
-function clip2(value2, max = 500) {
-  return normalizeText(value2, max);
+function extractMidTaskSteeringInput(value2) {
+  const start2 = value2.indexOf(RAW_START);
+  const end = value2.indexOf(RAW_END);
+  if (start2 < 0 || end <= start2)
+    return null;
+  return value2.slice(start2 + RAW_START.length, end).trim();
 }
-function listLines(items, empty2 = "- none observed") {
-  return items.length > 0 ? items.map((item) => `- ${item}`) : [empty2];
+function appendSteeringLedgerEntry(repoRoot, entry) {
+  try {
+    const dir = join91(repoRoot, ".omnius", "context");
+    mkdirSync45(dir, { recursive: true });
+    appendFileSync4(join91(dir, LEDGER_FILE), `${JSON.stringify(entry)}
+`, "utf-8");
+  } catch {
+  }
 }
-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 appendSteeringOutcome(repoRoot, packetIds, outcome, summary) {
+  for (const packetId of packetIds) {
+    appendSteeringLedgerEntry(repoRoot, {
+      type: "outcome",
+      packetId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      outcome,
+      summary: summary.slice(0, 1200)
+    });
+  }
 }
-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})` : ""}`;
+function buildRecentSteeringContext(repoRoot, limit = 3) {
+  const entries = readRecentSteeringEntries(repoRoot, limit);
+  if (entries.length === 0)
+    return "";
+  const lines = entries.map((entry, idx) => {
+    const interpretation = entry.interpretation;
+    const inference = interpretation?.inference || "(raw steering only)";
+    const note = interpretation?.memoryNote ? ` Memory note: ${interpretation.memoryNote}` : "";
+    const outcome = entry.outcome ? ` Outcome: ${entry.outcome}.` : "";
+    return `${idx + 1}. ${inference}${note}${outcome}`;
   });
-  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
-  };
+  return [
+    "<recent-user-steering>",
+    "Recent user steering reflections from this workspace. Use only when relevant to the current task.",
+    ...lines,
+    "</recent-user-steering>"
+  ].join("\n");
 }
-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);
+function buildInterpretationPrompt(ingress) {
+  return [
+    "Infer how this human feedback changes, constrains, or clarifies the active task.",
+    "If there are multiple plausible readings, include them in alternatives.",
+    "If the feedback conflicts with prior task assumptions, list the conflict.",
+    "If this should persist beyond the current turn, include memoryNote.",
+    "",
+    "Return JSON:",
+    "{",
+    '  "inference": "concise user-facing task-impact inference",',
+    '  "runnerInstruction": "specific instruction for the next agent decision",',
+    '  "conflicts": ["optional conflict"],',
+    '  "alternatives": ["optional alternate reading"],',
+    '  "memoryNote": "optional durable lesson"',
+    "}",
+    "",
+    `replacement: ${ingress.isReplacement ? "true" : "false"}`,
+    `toolCallsSoFar: ${ingress.toolCallCount}`,
+    "",
+    "Current task goal:",
+    truncateBlock(ingress.currentTaskGoal || "(unknown current task)", 1200),
+    "",
+    "Recent activity:",
+    truncateBlock(ingress.recentActivity || "(no recent activity recorded)", 1200),
+    "",
+    ingress.filesTouched.length > 0 ? `Files touched so far: ${ingress.filesTouched.join(", ")}` : "Files touched so far: none recorded",
+    "",
+    RAW_START,
+    ingress.rawText,
+    RAW_END
+  ].join("\n");
+}
+function parseSteeringInterpretation(raw) {
+  const candidate = extractJsonObject(raw);
+  if (!candidate)
+    return null;
+  try {
+    const parsed = SteeringInterpretationSchema.parse(JSON.parse(candidate));
+    return {
+      inference: parsed.inference,
+      runnerInstruction: parsed.runnerInstruction,
+      conflicts: parsed.conflicts,
+      alternatives: parsed.alternatives,
+      memoryNote: parsed.memoryNote
+    };
+  } catch {
+    return null;
   }
-  return lines.join("\n");
 }
-var init_completionContract = __esm({
-  "packages/orchestrator/dist/completionContract.js"() {
-    "use strict";
+function extractJsonObject(raw) {
+  const text2 = raw.trim();
+  if (!text2)
+    return null;
+  try {
+    JSON.parse(text2);
+    return text2;
+  } catch {
   }
-});
-
-// packages/orchestrator/dist/completionLedger.js
-import { mkdirSync as mkdirSync45, readFileSync as readFileSync60, writeFileSync as writeFileSync38 } from "node:fs";
-import { dirname as dirname27 } from "node:path";
-function nowIso2(now2 = /* @__PURE__ */ new Date()) {
-  return now2 instanceof Date ? now2.toISOString() : new Date(now2).toISOString();
+  let start2 = -1;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i2 = 0; i2 < text2.length; i2++) {
+    const ch = text2[i2];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") {
+      if (depth === 0)
+        start2 = i2;
+      depth++;
+      continue;
+    }
+    if (ch === "}") {
+      depth--;
+      if (depth === 0 && start2 >= 0)
+        return text2.slice(start2, i2 + 1);
+      if (depth < 0) {
+        start2 = -1;
+        depth = 0;
+      }
+    }
+  }
+  return null;
 }
-function cleanText(value2, max = 600) {
-  return String(value2 ?? "").replace(/\s+/g, " ").trim().slice(0, max);
+function steeringInterpretationResponseFormat() {
+  return { type: "json_object" };
 }
-function nextId2(prefix, count) {
-  return `${prefix}_${String(count + 1).padStart(4, "0")}`;
+function readRecentSteeringEntries(repoRoot, limit) {
+  try {
+    const file = join91(repoRoot, ".omnius", "context", LEDGER_FILE);
+    if (!existsSync79(file))
+      return [];
+    const lines = readFileSync60(file, "utf-8").split("\n").filter(Boolean).slice(-100);
+    const parsedEntries = [];
+    for (const line of lines) {
+      try {
+        parsedEntries.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    const latestOutcomes = /* @__PURE__ */ new Map();
+    for (const entry of parsedEntries) {
+      if (entry.type === "outcome")
+        latestOutcomes.set(entry.packetId, entry);
+    }
+    const out = [];
+    for (let i2 = parsedEntries.length - 1; i2 >= 0 && out.length < limit; i2--) {
+      const parsed = parsedEntries[i2];
+      if (parsed.type === "ingress") {
+        const outcome = latestOutcomes.get(parsed.packetId);
+        out.push(outcome ? { ...parsed, outcome: outcome.outcome, summary: outcome.summary } : parsed);
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
 }
-function createCompletionLedger(input) {
-  const ts = nowIso2(input.now);
-  return {
-    runId: input.runId,
-    goal: cleanText(input.goal, 2e3),
-    createdAtIso: ts,
-    updatedAtIso: ts,
+function truncateBlock(value2, max) {
+  const trimmed = value2.trim();
+  if (trimmed.length <= max)
+    return trimmed;
+  return `${trimmed.slice(0, max).trimEnd()}
+...(truncated)`;
+}
+var STEERING_START, STEERING_END, RAW_START, RAW_END, LEDGER_FILE, SteeringInterpretationSchema;
+var init_steeringIntake = __esm({
+  "packages/orchestrator/dist/steeringIntake.js"() {
+    "use strict";
+    STEERING_START = "[MID_TASK_STEERING_INTAKE v2]";
+    STEERING_END = "[/MID_TASK_STEERING_INTAKE]";
+    RAW_START = "<<<USER_ADDED_CONTEXT>>>";
+    RAW_END = "<<<END_USER_ADDED_CONTEXT>>>";
+    LEDGER_FILE = "steering-ledger.jsonl";
+    SteeringInterpretationSchema = z16.object({
+      inference: z16.string().trim().min(1),
+      runnerInstruction: z16.string().trim().min(1),
+      conflicts: z16.array(z16.string().trim().min(1)).optional().default([]),
+      alternatives: z16.array(z16.string().trim().min(1)).optional().default([]),
+      memoryNote: z16.string().trim().min(1).optional()
+    });
+  }
+});
+
+// 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 mkdirSync46, readFileSync as readFileSync61, writeFileSync as writeFileSync38 } from "node:fs";
+import { dirname as dirname27 } from "node:path";
+function nowIso2(now2 = /* @__PURE__ */ new Date()) {
+  return now2 instanceof Date ? now2.toISOString() : new Date(now2).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: [],
@@ -555750,12 +556123,12 @@ function buildCriticPacketFromLedger(ledger) {
   return lines.join("\n");
 }
 function saveCompletionLedger(filePath, ledger) {
-  mkdirSync45(dirname27(filePath), { recursive: true });
+  mkdirSync46(dirname27(filePath), { recursive: true });
   writeFileSync38(filePath, `${JSON.stringify(ledger, null, 2)}
 `, "utf8");
 }
 function loadCompletionLedger(filePath) {
-  return JSON.parse(readFileSync60(filePath, "utf8"));
+  return JSON.parse(readFileSync61(filePath, "utf8"));
 }
 var init_completionLedger = __esm({
   "packages/orchestrator/dist/completionLedger.js"() {
@@ -556423,9 +556796,9 @@ var init_ollama_pool_cleanup = __esm({
 
 // packages/orchestrator/dist/ollama-pool.js
 import { spawn as spawn24, exec as exec2 } from "node:child_process";
-import { existsSync as existsSync79, readFileSync as readFileSync61, readdirSync as readdirSync24, statfsSync as statfsSync3, statSync as statSync29 } from "node:fs";
+import { existsSync as existsSync80, readFileSync as readFileSync62, readdirSync as readdirSync24, statfsSync as statfsSync3, statSync as statSync29 } from "node:fs";
 import { homedir as homedir30 } from "node:os";
-import { join as join91 } from "node:path";
+import { join as join92 } from "node:path";
 import { createServer as createServer3 } from "node:net";
 import { EventEmitter as EventEmitter5 } from "node:events";
 function discoverSystemOllamaModelStore() {
@@ -556438,7 +556811,7 @@ function discoverSystemOllamaModelStore() {
   const candidates = [
     "/usr/share/ollama/.ollama/models",
     "/var/lib/ollama/.ollama/models",
-    join91(homedir30(), ".ollama", "models")
+    join92(homedir30(), ".ollama", "models")
   ];
   for (const p2 of candidates) {
     if (isDirectory(p2))
@@ -556448,7 +556821,7 @@ function discoverSystemOllamaModelStore() {
 }
 function isDirectory(path12) {
   try {
-    return existsSync79(path12) && statSync29(path12).isDirectory();
+    return existsSync80(path12) && statSync29(path12).isDirectory();
   } catch {
     return false;
   }
@@ -556462,7 +556835,7 @@ function discoverOllamaModelStoreFromProc() {
       return envStore;
     const home = inferHomeFromProcUid(pid);
     if (home) {
-      const inferred = join91(home, ".ollama", "models");
+      const inferred = join92(home, ".ollama", "models");
       if (isDirectory(inferred))
         return inferred;
     }
@@ -556473,7 +556846,7 @@ function listOllamaPids() {
   try {
     return readdirSync24("/proc", { withFileTypes: true }).filter((d2) => d2.isDirectory() && /^\d+$/.test(d2.name)).map((d2) => d2.name).filter((pid) => {
       try {
-        const comm = readFileSync61(`/proc/${pid}/comm`, "utf8").trim();
+        const comm = readFileSync62(`/proc/${pid}/comm`, "utf8").trim();
         return comm === "ollama";
       } catch {
         return false;
@@ -556485,7 +556858,7 @@ function listOllamaPids() {
 }
 function readProcEnvValue(pid, key) {
   try {
-    const raw = readFileSync61(`/proc/${pid}/environ`, "utf8");
+    const raw = readFileSync62(`/proc/${pid}/environ`, "utf8");
     for (const entry of raw.split("\0")) {
       const idx = entry.indexOf("=");
       if (idx <= 0)
@@ -556501,11 +556874,11 @@ function readProcEnvValue(pid, key) {
 }
 function inferHomeFromProcUid(pid) {
   try {
-    const status = readFileSync61(`/proc/${pid}/status`, "utf8");
+    const status = readFileSync62(`/proc/${pid}/status`, "utf8");
     const uid = status.match(/^Uid:\s+(\d+)/m)?.[1];
     if (!uid)
       return null;
-    const passwd = readFileSync61("/etc/passwd", "utf8");
+    const passwd = readFileSync62("/etc/passwd", "utf8");
     for (const line of passwd.split("\n")) {
       const parts = line.split(":");
       if (parts.length >= 7 && parts[2] === uid)
@@ -556531,7 +556904,7 @@ function detectPeerOmniusOllamaPool() {
     if (e2.name === selfPid || e2.name === selfPpid)
       continue;
     try {
-      const cmdline = readFileSync61(`/proc/${e2.name}/cmdline`, "utf8");
+      const cmdline = readFileSync62(`/proc/${e2.name}/cmdline`, "utf8");
       if (!cmdline.includes("node"))
         continue;
       if (!/[/\\]omnius[/\\]dist[/\\]index\.js|[/\\]omnius[/\\]/i.test(cmdline))
@@ -556544,12 +556917,12 @@ function detectPeerOmniusOllamaPool() {
     return false;
   for (const e2 of entries) {
     try {
-      const cmd = readFileSync61(`/proc/${e2.name}/cmdline`, "utf8");
+      const cmd = readFileSync62(`/proc/${e2.name}/cmdline`, "utf8");
       if (!cmd.includes("ollama"))
         continue;
       if (!cmd.split("\0").includes("serve"))
         continue;
-      const status = readFileSync61(`/proc/${e2.name}/status`, "utf8");
+      const status = readFileSync62(`/proc/${e2.name}/status`, "utf8");
       const ppid = status.match(/^PPid:\s+(\d+)/m)?.[1];
       if (ppid && peerNodePids.has(ppid))
         return true;
@@ -556680,7 +557053,7 @@ function snapshotDisk(path12) {
 }
 function snapshotNetwork() {
   try {
-    const raw = readFileSync61("/proc/net/dev", "utf8");
+    const raw = readFileSync62("/proc/net/dev", "utf8");
     let rxBytes = 0;
     let txBytes = 0;
     for (const line of raw.split("\n")) {
@@ -558163,7 +558536,7 @@ var init_mast_tagger = __esm({
 });
 
 // packages/orchestrator/dist/artifact-inspector.js
-import { existsSync as existsSync80, statSync as statSync30 } from "node:fs";
+import { existsSync as existsSync81, statSync as statSync30 } from "node:fs";
 import { isAbsolute as isAbsolute5, resolve as resolve47 } from "node:path";
 function extractCandidatePaths(content) {
   const out = /* @__PURE__ */ new Set();
@@ -558189,7 +558562,7 @@ function inspectClaimedArtifacts(input) {
   const stale = [];
   for (const p2 of candidates) {
     const resolved = resolveAgainstWorkingDir(input.workingDir, p2);
-    if (!existsSync80(resolved)) {
+    if (!existsSync81(resolved)) {
       missing.push(p2);
       continue;
     }
@@ -558259,8 +558632,8 @@ var init_artifact_inspector = __esm({
 });
 
 // packages/orchestrator/dist/lesson-bank.js
-import { existsSync as existsSync81, mkdirSync as mkdirSync46, appendFileSync as appendFileSync4, readFileSync as readFileSync62 } from "node:fs";
-import { join as join92, dirname as dirname28 } from "node:path";
+import { existsSync as existsSync82, mkdirSync as mkdirSync47, appendFileSync as appendFileSync5, readFileSync as readFileSync63 } from "node:fs";
+import { join as join93, dirname as dirname28 } from "node:path";
 import { createHash as createHash25 } from "node:crypto";
 function tokenize4(text2) {
   if (!text2)
@@ -558292,20 +558665,20 @@ function solicit(args) {
   };
 }
 function lessonBankPath(workingDir) {
-  const base3 = workingDir ? join92(workingDir, ".omnius", "lessons") : join92(process.env["HOME"] || ".", ".omnius", "lessons");
-  return join92(base3, "lessons.jsonl");
+  const base3 = workingDir ? join93(workingDir, ".omnius", "lessons") : join93(process.env["HOME"] || ".", ".omnius", "lessons");
+  return join93(base3, "lessons.jsonl");
 }
 function bank(lesson, workingDir) {
   const path12 = lessonBankPath(workingDir);
-  mkdirSync46(dirname28(path12), { recursive: true });
-  appendFileSync4(path12, JSON.stringify(lesson) + "\n", "utf-8");
+  mkdirSync47(dirname28(path12), { recursive: true });
+  appendFileSync5(path12, JSON.stringify(lesson) + "\n", "utf-8");
 }
 function readAll(workingDir) {
   const path12 = lessonBankPath(workingDir);
-  if (!existsSync81(path12))
+  if (!existsSync82(path12))
     return [];
   try {
-    const raw = readFileSync62(path12, "utf-8");
+    const raw = readFileSync63(path12, "utf-8");
     const out = [];
     for (const line of raw.split(/\r?\n/)) {
       const trimmed = line.trim();
@@ -558362,13 +558735,13 @@ var init_lesson_bank = __esm({
 });
 
 // packages/orchestrator/dist/intervention-replay.js
-import { existsSync as existsSync82, mkdirSync as mkdirSync47, readFileSync as readFileSync63, writeFileSync as writeFileSync39, readdirSync as readdirSync25 } from "node:fs";
-import { join as join93, dirname as dirname29 } from "node:path";
+import { existsSync as existsSync83, mkdirSync as mkdirSync48, readFileSync as readFileSync64, writeFileSync as writeFileSync39, readdirSync as readdirSync25 } from "node:fs";
+import { join as join94, dirname as dirname29 } from "node:path";
 function checkpointDir2(workingDir) {
-  return workingDir ? join93(workingDir, ".omnius", "checkpoints") : join93(process.env["HOME"] || ".", ".omnius", "checkpoints");
+  return workingDir ? join94(workingDir, ".omnius", "checkpoints") : join94(process.env["HOME"] || ".", ".omnius", "checkpoints");
 }
 function checkpointPath(workingDir, turn) {
-  return join93(checkpointDir2(workingDir), `turn-${String(turn).padStart(4, "0")}.json`);
+  return join94(checkpointDir2(workingDir), `turn-${String(turn).padStart(4, "0")}.json`);
 }
 function writeCheckpoint(args) {
   try {
@@ -558380,7 +558753,7 @@ function writeCheckpoint(args) {
       notes: args.notes
     };
     const path12 = checkpointPath(args.workingDir, args.turn);
-    mkdirSync47(dirname29(path12), { recursive: true });
+    mkdirSync48(dirname29(path12), { recursive: true });
     writeFileSync39(path12, JSON.stringify(snap), "utf-8");
   } catch {
   }
@@ -558388,7 +558761,7 @@ function writeCheckpoint(args) {
 function listCheckpoints(workingDir) {
   try {
     const dir = checkpointDir2(workingDir);
-    if (!existsSync82(dir))
+    if (!existsSync83(dir))
       return [];
     return readdirSync25(dir).map((f2) => f2.match(/^turn-(\d+)\.json$/)).filter((m2) => m2 !== null).map((m2) => parseInt(m2[1], 10)).filter((n2) => !Number.isNaN(n2)).sort((a2, b) => a2 - b);
   } catch {
@@ -558404,7 +558777,7 @@ function pruneOldCheckpoints(args) {
   for (const t2 of toRemove) {
     try {
       const path12 = checkpointPath(args.workingDir, t2);
-      if (existsSync82(path12)) {
+      if (existsSync83(path12)) {
         const fs11 = __require("node:fs");
         fs11.unlinkSync(path12);
         removed++;
@@ -558421,13 +558794,13 @@ var init_intervention_replay = __esm({
 });
 
 // packages/orchestrator/dist/world-state-disk-scan.js
-import { existsSync as existsSync83, readFileSync as readFileSync64, readdirSync as readdirSync26, statSync as statSync31 } from "node:fs";
-import { join as join94, relative as relative8, basename as basename20 } from "node:path";
+import { existsSync as existsSync84, readFileSync as readFileSync65, readdirSync as readdirSync26, statSync as statSync31 } from "node:fs";
+import { join as join95, relative as relative8, basename as basename20 } from "node:path";
 function loadIgnoreFile(path12) {
-  if (!existsSync83(path12))
+  if (!existsSync84(path12))
     return [];
   try {
-    const lines = readFileSync64(path12, "utf-8").split(/\r?\n/);
+    const lines = readFileSync65(path12, "utf-8").split(/\r?\n/);
     const out = [];
     for (const raw of lines) {
       const line = raw.trim();
@@ -558469,7 +558842,7 @@ function scanWorkspace(opts) {
   if (!noDefaults)
     patterns.push(...UNIVERSAL_DEFAULTS);
   if (!noGitignore)
-    patterns.push(...loadIgnoreFile(join94(root, ".gitignore")));
+    patterns.push(...loadIgnoreFile(join95(root, ".gitignore")));
   if (opts.extraIgnore)
     patterns.push(...opts.extraIgnore);
   const files = [];
@@ -558500,7 +558873,7 @@ function scanWorkspace(opts) {
         truncated = true;
         break;
       }
-      const abs = join94(dir, entry);
+      const abs = join95(dir, entry);
       const rel = relative8(root, abs);
       const base3 = basename20(abs);
       if (shouldIgnore(rel, base3, patterns))
@@ -558588,8 +558961,8 @@ var init_world_state_disk_scan = __esm({
 });
 
 // packages/orchestrator/dist/world-state-plan-reconciler.js
-import { existsSync as existsSync84, statSync as statSync32 } from "node:fs";
-import { isAbsolute as isAbsolute6, join as join95 } from "node:path";
+import { existsSync as existsSync85, statSync as statSync32 } from "node:fs";
+import { isAbsolute as isAbsolute6, join as join96 } from "node:path";
 function tokenize5(content) {
   const STOP2 = /* @__PURE__ */ new Set([
     "the",
@@ -558671,7 +559044,7 @@ function reconcileTodo(todo, files, opts) {
     let anyMissing = false;
     let anyEmpty = false;
     for (const p2 of declared) {
-      const abs = isAbsolute6(p2) ? p2 : join95(opts.workingDir, p2);
+      const abs = isAbsolute6(p2) ? p2 : join96(opts.workingDir, p2);
       let st = null;
       try {
         st = statSync32(abs);
@@ -558679,7 +559052,7 @@ function reconcileTodo(todo, files, opts) {
         st = null;
       }
       if (!st) {
-        if (!existsSync84(abs)) {
+        if (!existsSync85(abs)) {
           checks.push({ path: p2, ok: false, reason: "missing" });
           anyMissing = true;
           allOk = false;
@@ -558777,8 +559150,8 @@ var init_world_state_plan_reconciler = __esm({
 });
 
 // packages/orchestrator/dist/world-state-drift-detector.js
-import { existsSync as existsSync85, readFileSync as readFileSync65, statSync as statSync33 } from "node:fs";
-import { dirname as dirname30, isAbsolute as isAbsolute7, join as join96, resolve as pathResolve } from "node:path";
+import { existsSync as existsSync86, readFileSync as readFileSync66, statSync as statSync33 } from "node:fs";
+import { dirname as dirname30, isAbsolute as isAbsolute7, join as join97, resolve as pathResolve } from "node:path";
 function parseImports(source) {
   const out = [];
   const lines = source.split(/\r?\n/);
@@ -558931,11 +559304,11 @@ function loadProjectAliases(workingDir) {
   const configCandidates = ["tsconfig.json", "jsconfig.json"];
   const aliases = {};
   for (const name10 of configCandidates) {
-    const path12 = join96(workingDir, name10);
-    if (!existsSync85(path12))
+    const path12 = join97(workingDir, name10);
+    if (!existsSync86(path12))
       continue;
     try {
-      const raw = readFileSync65(path12, "utf-8");
+      const raw = readFileSync66(path12, "utf-8");
       const parsed = JSON.parse(stripJsonComments(raw));
       const co = parsed?.compilerOptions;
       const paths = co?.paths;
@@ -558982,11 +559355,11 @@ function resolveImportPath2(importingFile, source, workingDir, aliases) {
   for (const ext of FILE_EXTENSIONS)
     candidates.push(base3 + ext);
   for (const ext of FILE_EXTENSIONS)
-    candidates.push(join96(base3, "index" + ext));
+    candidates.push(join97(base3, "index" + ext));
   candidates.push(base3);
   for (const c8 of candidates) {
     try {
-      if (existsSync85(c8) && statSync33(c8).isFile())
+      if (existsSync86(c8) && statSync33(c8).isFile())
         return c8;
     } catch {
     }
@@ -559024,7 +559397,7 @@ function detectDrift(files, opts) {
   const exportsCache = /* @__PURE__ */ new Map();
   const readSource = (path12) => {
     try {
-      const buf = readFileSync65(path12);
+      const buf = readFileSync66(path12);
       if (buf.length > maxBytes)
         return buf.slice(0, maxBytes).toString("utf-8");
       return buf.toString("utf-8");
@@ -559639,16 +560012,16 @@ var init_backward_pass_critic = __esm({
 });
 
 // packages/orchestrator/dist/backward-pass-runner.js
-import { existsSync as existsSync86, readFileSync as readFileSync66, statSync as statSync34 } from "node:fs";
+import { existsSync as existsSync87, readFileSync as readFileSync67, statSync as statSync34 } from "node:fs";
 import { execSync as execSync45 } from "node:child_process";
-import { isAbsolute as isAbsolute8, join as join97, relative as relative9 } from "node:path";
+import { isAbsolute as isAbsolute8, join as join98, relative as relative9 } from "node:path";
 function collectDiff(opts) {
   const cap = Math.max(1, opts.maxFiles);
   if (opts.explicitFiles && opts.explicitFiles.length > 0) {
     const files = [];
     for (const p2 of opts.explicitFiles.slice(0, cap)) {
-      const abs = isAbsolute8(p2) ? p2 : join97(opts.workingDir, p2);
-      if (!existsSync86(abs))
+      const abs = isAbsolute8(p2) ? p2 : join98(opts.workingDir, p2);
+      if (!existsSync87(abs))
         continue;
       let bytes = 0;
       try {
@@ -559659,7 +560032,7 @@ function collectDiff(opts) {
     }
     return { files, strategy: "explicit" };
   }
-  if (existsSync86(join97(opts.workingDir, ".git"))) {
+  if (existsSync87(join98(opts.workingDir, ".git"))) {
     try {
       const out = execSync45("git diff --name-status HEAD 2>/dev/null; git ls-files --others --exclude-standard 2>/dev/null", { cwd: opts.workingDir, encoding: "utf-8", maxBuffer: 4 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] });
       const files = [];
@@ -559676,9 +560049,9 @@ function collectDiff(opts) {
           status = "added";
           path12 = line.trim();
         }
-        const abs = join97(opts.workingDir, path12);
+        const abs = join98(opts.workingDir, path12);
         let bytes = 0;
-        if (existsSync86(abs)) {
+        if (existsSync87(abs)) {
           try {
             bytes = statSync34(abs).size;
           } catch {
@@ -559699,7 +560072,7 @@ function collectDiff(opts) {
 }
 function readPreview(absPath, maxBytes) {
   try {
-    const buf = readFileSync66(absPath);
+    const buf = readFileSync67(absPath);
     if (buf.length === 0)
       return "";
     const sniff = buf.slice(0, Math.min(8192, buf.length));
@@ -559726,7 +560099,7 @@ async function runBackwardPass(opts) {
     explicitFiles: opts.explicitFiles
   });
   const diff = collected.files.map((f2) => {
-    const abs = isAbsolute8(f2.path) ? f2.path : join97(opts.workingDir, f2.path);
+    const abs = isAbsolute8(f2.path) ? f2.path : join98(opts.workingDir, f2.path);
     const preview = f2.status === "deleted" ? "(file deleted)" : readPreview(abs, maxFilePreviewBytes);
     return { ...f2, preview };
   });
@@ -562196,13 +562569,13 @@ var init_hooks2 = __esm({
 });
 
 // packages/orchestrator/dist/todo-context-chunker.js
-import { mkdirSync as mkdirSync50, writeFileSync as writeFileSync42, readFileSync as readFileSync69, existsSync as existsSync89, readdirSync as readdirSync27 } from "node:fs";
-import { join as join100 } from "node:path";
+import { mkdirSync as mkdirSync51, writeFileSync as writeFileSync42, readFileSync as readFileSync70, existsSync as existsSync90, readdirSync as readdirSync27 } from "node:fs";
+import { join as join101 } from "node:path";
 function chunkDir(workingDir) {
-  return join100(workingDir, ".omnius", "todo-chunks");
+  return join101(workingDir, ".omnius", "todo-chunks");
 }
 function chunkPath(workingDir, todoId) {
-  return join100(chunkDir(workingDir), `${sanitizeId(todoId)}.json`);
+  return join101(chunkDir(workingDir), `${sanitizeId(todoId)}.json`);
 }
 function sanitizeId(id) {
   return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
@@ -562411,17 +562784,17 @@ async function runTodoChunker(opts) {
 }
 function persistTodoChunk(workingDir, chunk) {
   const dir = chunkDir(workingDir);
-  if (!existsSync89(dir)) {
-    mkdirSync50(dir, { recursive: true });
+  if (!existsSync90(dir)) {
+    mkdirSync51(dir, { recursive: true });
   }
   writeFileSync42(chunkPath(workingDir, chunk.todoId), JSON.stringify(chunk, null, 2), "utf-8");
 }
 function loadTodoChunk(workingDir, todoId) {
   const p2 = chunkPath(workingDir, todoId);
-  if (!existsSync89(p2))
+  if (!existsSync90(p2))
     return null;
   try {
-    return JSON.parse(readFileSync69(p2, "utf-8"));
+    return JSON.parse(readFileSync70(p2, "utf-8"));
   } catch {
     return null;
   }
@@ -563442,10 +563815,26 @@ function signalFromBlock(kind, source, content, options2 = {}) {
     metadata: options2.metadata
   };
 }
-var KIND_ORDER, KIND_LABELS, DEFAULT_KIND_CHAR_BUDGET, URL_RE2, CONTEXT_FABRIC_TRUNCATION_SUFFIX, ContextLedger, ContextFrameBuilder;
+var PRIORITY, KIND_ORDER, KIND_LABELS, DEFAULT_KIND_CHAR_BUDGET, URL_RE2, CONTEXT_FABRIC_TRUNCATION_SUFFIX, ContextLedger, ContextFrameBuilder;
 var init_context_fabric = __esm({
   "packages/orchestrator/dist/context-fabric.js"() {
     "use strict";
+    PRIORITY = {
+      GOAL: 100,
+      USER_STEERING: 95,
+      TASK_STATE: 80,
+      KNOWN_FILES: 70,
+      RECENT_FAILURE: 65,
+      TOOL_CACHE: 60,
+      SKILL_MANIFEST: 55,
+      MEMORY: 50,
+      SEMANTIC_CHUNK: 45,
+      SESSION_HISTORY: 40,
+      ANCHOR: 35,
+      HANDOFF: 30,
+      ENVIRONMENT: 25,
+      COMPACTION_SUMMARY: 20
+    };
     KIND_ORDER = [
       "goal",
       "user_steering",
@@ -563625,7 +564014,7 @@ var init_context_fabric = __esm({
           const label = KIND_LABELS[kind];
           sectionLines.push(`## ${label}`);
           sectionLines.push(body.join("\n"));
-          sectionDiagnostics.push({ kind, label, signals: used, chars });
+          sectionDiagnostics.push({ kind, label, signals: used, chars, dropped: dropped.length });
         }
         const header = [
           "[ACTIVE CONTEXT FRAME]",
@@ -563833,21 +564222,21 @@ __export(preflightSnapshot_exports, {
   formatPreflightStatus: () => formatPreflightStatus,
   freeDiskBytes: () => freeDiskBytes
 });
-import { existsSync as existsSync90, readFileSync as readFileSync70, statSync as statSync35 } from "node:fs";
+import { existsSync as existsSync91, readFileSync as readFileSync71, statSync as statSync35 } from "node:fs";
 import { execSync as execSync47 } from "node:child_process";
 import { homedir as homedir31, platform as platform3, arch as arch2, totalmem as totalmem3, freemem as freemem3, hostname as hostname3 } from "node:os";
-import { join as join101 } from "node:path";
+import { join as join102 } from "node:path";
 import { createHash as createHash26 } from "node:crypto";
 function capturePreflightSnapshot(workingDir) {
   const warnings = [];
   const configFingerprints = {};
   for (const det of CONFIG_DETECTORS) {
     const expanded = expandPath(det.path);
-    if (!existsSync90(expanded))
+    if (!existsSync91(expanded))
       continue;
     let raw;
     try {
-      raw = readFileSync70(expanded, "utf8");
+      raw = readFileSync71(expanded, "utf8");
     } catch {
       continue;
     }
@@ -563860,12 +564249,12 @@ function capturePreflightSnapshot(workingDir) {
     for (const det of CONFIG_DETECTORS) {
       if (det.path.startsWith("~/")) {
         const localName = det.path.replace(/^~\//, "");
-        const projectPath = join101(workingDir, localName);
-        if (!existsSync90(projectPath))
+        const projectPath = join102(workingDir, localName);
+        if (!existsSync91(projectPath))
           continue;
         let raw;
         try {
-          raw = readFileSync70(projectPath, "utf8");
+          raw = readFileSync71(projectPath, "utf8");
         } catch {
           continue;
         }
@@ -564004,7 +564393,7 @@ function captureToolchainVersions() {
 }
 function expandPath(p2) {
   if (p2.startsWith("~/"))
-    return join101(homedir31(), p2.slice(2));
+    return join102(homedir31(), p2.slice(2));
   return p2;
 }
 function sha2564(s2) {
@@ -564075,8 +564464,8 @@ __export(postActionVerifier_exports, {
   classifyShellIntent: () => classifyShellIntent,
   verifyShellOutcome: () => verifyShellOutcome
 });
-import { existsSync as existsSync91, readFileSync as readFileSync71, readdirSync as readdirSync28, statSync as statSync36 } from "node:fs";
-import { join as join102 } from "node:path";
+import { existsSync as existsSync92, readFileSync as readFileSync72, readdirSync as readdirSync28, statSync as statSync36 } from "node:fs";
+import { join as join103 } from "node:path";
 function classifyShellIntent(cmd) {
   const stripped = cmd.replace(/^cd\s+\S+\s*&&\s*/, "").trim();
   const tokens = stripped.split(/\s+/).filter(Boolean);
@@ -564124,7 +564513,7 @@ function checkMutateMtimeDelta(intent, cwd4, ctx3, _result) {
   if (intent.klass !== "mutate") {
     return { trustworthy: true, intentBucket: bucket, outcomeClass: "unknown" };
   }
-  if (!existsSync91(cwd4)) {
+  if (!existsSync92(cwd4)) {
     return {
       trustworthy: false,
       syntheticError: `Command claimed success but the working directory ${cwd4} does not exist.`,
@@ -564163,19 +564552,19 @@ function checkMutateMtimeDelta(intent, cwd4, ctx3, _result) {
 }
 function checkManifestInvariant(cwd4, fallbackBucket) {
   for (const pattern of MANIFEST_PATTERNS) {
-    const manifestPath2 = join102(cwd4, pattern.manifest);
-    if (!existsSync91(manifestPath2))
+    const manifestPath2 = join103(cwd4, pattern.manifest);
+    if (!existsSync92(manifestPath2))
       continue;
     let declared;
     try {
-      declared = pattern.parseDeps(readFileSync71(manifestPath2, "utf8"));
+      declared = pattern.parseDeps(readFileSync72(manifestPath2, "utf8"));
     } catch {
       continue;
     }
     if (declared.length === 0)
       continue;
-    const installRootAbs = join102(cwd4, pattern.installRoot);
-    if (!existsSync91(installRootAbs)) {
+    const installRootAbs = join103(cwd4, pattern.installRoot);
+    if (!existsSync92(installRootAbs)) {
       continue;
     }
     const installed = pattern.listInstalled ? pattern.listInstalled(installRootAbs) : defaultListDirNames(installRootAbs);
@@ -564276,7 +564665,7 @@ function listNpmInstalled(installRootAbs) {
     for (const name10 of readdirSync28(installRootAbs)) {
       if (name10.startsWith("."))
         continue;
-      const sub2 = join102(installRootAbs, name10);
+      const sub2 = join103(installRootAbs, name10);
       try {
         if (!statSync36(sub2).isDirectory())
           continue;
@@ -564293,7 +564682,7 @@ function listNpmInstalled(installRootAbs) {
         }
         continue;
       }
-      if (existsSync91(join102(sub2, "package.json")))
+      if (existsSync92(join103(sub2, "package.json")))
         out.add(name10);
     }
   } catch {
@@ -564304,11 +564693,11 @@ function listPipInstalled(installRootAbs) {
   const out = /* @__PURE__ */ new Set();
   const candidates = [];
   try {
-    const lib = join102(installRootAbs, "lib");
-    if (existsSync91(lib)) {
+    const lib = join103(installRootAbs, "lib");
+    if (existsSync92(lib)) {
       for (const py of readdirSync28(lib)) {
-        const sp = join102(lib, py, "site-packages");
-        if (existsSync91(sp))
+        const sp = join103(lib, py, "site-packages");
+        if (existsSync92(sp))
           candidates.push(sp);
       }
     }
@@ -564347,7 +564736,7 @@ function mostRecentFileMtimeMs(root, maxDepth) {
     for (const name10 of entries) {
       if (MTIME_EXCLUDES.has(name10))
         continue;
-      const full = join102(dir, name10);
+      const full = join103(dir, name10);
       let st;
       try {
         st = statSync36(full);
@@ -564368,8 +564757,8 @@ function mostRecentFileMtimeMs(root, maxDepth) {
 function listExistingChildren(cwd4, candidates) {
   const out = [];
   for (const c8 of candidates) {
-    const p2 = join102(cwd4, c8);
-    if (existsSync91(p2))
+    const p2 = join103(cwd4, c8);
+    if (existsSync92(p2))
       out.push(p2);
   }
   return out;
@@ -564886,7 +565275,7 @@ import { createHash as _createHash } from "node:crypto";
 import { join as _pathJoin, resolve as _pathResolve } from "node:path";
 import { tmpdir as _osTmpdir } from "node:os";
 import { homedir as _osHomedir } from "node:os";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 function textFromMessageContent(content) {
   if (typeof content === "string")
     return content;
@@ -565366,6 +565755,7 @@ var init_agenticRunner = __esm({
     "use strict";
     init_textSanitize();
     init_permissionRuleset();
+    init_steeringIntake();
     init_completionLedger();
     init_dist6();
     init_ollama_pool();
@@ -569357,6 +569747,16 @@ ${this._lastPprMemoryLines.slice(0, 5).join("\n")}` : null;
             priority: 35,
             createdTurn: turn,
             ttlTurns: 1
+          }),
+          signalFromBlock("user_steering", "turn.recentSteering", buildRecentSteeringContext(this._workingDirectory || process.cwd()), {
+            id: "recentSteering",
+            dedupeKey: "turn.recentSteering",
+            // PRIORITY.USER_STEERING (95) keeps steering above all non-goal
+            // signals so mid-turn user feedback is never buried under budget
+            // pressure. See context-fabric.ts PRIORITY tier map.
+            priority: PRIORITY.USER_STEERING,
+            createdTurn: turn,
+            ttlTurns: 1
           })
         ];
         this._contextLedger.upsertMany(signals.filter(Boolean));
@@ -581221,9 +581621,9 @@ var init_constraint_learner = __esm({
 });
 
 // packages/orchestrator/dist/nexusBackend.js
-import { existsSync as existsSync92, statSync as statSync37, openSync, readSync, closeSync, unlinkSync as unlinkSync17, writeFileSync as writeFileSync43 } from "node:fs";
+import { existsSync as existsSync93, 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 join103 } from "node:path";
+import { join as join104 } from "node:path";
 import { tmpdir as tmpdir19 } from "node:os";
 import { randomBytes as randomBytes20 } from "node:crypto";
 var NexusAgenticBackend;
@@ -581426,7 +581826,7 @@ ${suffix}` } : m2);
        * Falls back to unary + word-split if streaming setup fails.
        */
       async *chatCompletionStream(request) {
-        const streamFile = join103(tmpdir19(), `nexus-stream-${randomBytes20(6).toString("hex")}.jsonl`);
+        const streamFile = join104(tmpdir19(), `nexus-stream-${randomBytes20(6).toString("hex")}.jsonl`);
         writeFileSync43(streamFile, "", "utf8");
         const effectiveThink = this.effectiveThink(request);
         const daemonArgs = {
@@ -581951,327 +582351,6 @@ var init_cascadeBackend = __esm({
   }
 });
 
-// packages/orchestrator/dist/steeringIntake.js
-import { randomUUID as randomUUID16 } from "node:crypto";
-import { appendFileSync as appendFileSync6, existsSync as existsSync93, mkdirSync as mkdirSync51, readFileSync as readFileSync72 } from "node:fs";
-import { join as join104 } from "node:path";
-import { z as z17 } from "zod";
-function createSteeringIngress(input) {
-  return {
-    id: randomUUID16(),
-    rawText: input.rawText.trim(),
-    sourceSurface: input.sourceSurface,
-    authority: "user",
-    isReplacement: input.isReplacement ?? false,
-    currentTaskGoal: input.currentTaskGoal || "(unknown current task)",
-    recentActivity: input.recentActivity,
-    filesTouched: (input.filesTouched ?? []).filter(Boolean).slice(0, 12),
-    toolCallCount: input.toolCallCount ?? 0,
-    taskId: input.taskId,
-    sessionId: input.sessionId,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-async function interpretSteeringIngress(backend, ingress, timeoutMs = 8e3) {
-  const first2 = await backend.chatCompletion({
-    messages: [
-      {
-        role: "system",
-        content: [
-          "You interpret human feedback for a running coding agent.",
-          "Return strict JSON only.",
-          "Use only the supplied task trajectory and ingress.",
-          "The JSON fields describe task impact and next-action guidance."
-        ].join("\n")
-      },
-      { role: "user", content: buildInterpretationPrompt(ingress) }
-    ],
-    tools: [],
-    temperature: 0.2,
-    maxTokens: 512,
-    timeoutMs,
-    think: false,
-    responseFormat: steeringInterpretationResponseFormat()
-  });
-  const raw = first2.choices[0]?.message?.content ?? "";
-  const parsed = parseSteeringInterpretation(raw);
-  if (parsed)
-    return parsed;
-  const repaired = await backend.chatCompletion({
-    messages: [
-      {
-        role: "system",
-        content: "Repair the supplied text into strict JSON matching the requested schema. Return JSON only."
-      },
-      {
-        role: "user",
-        content: [
-          "Schema keys: inference, runnerInstruction, conflicts, alternatives, memoryNote.",
-          "Required keys: inference, runnerInstruction.",
-          "",
-          "Original task state and ingress:",
-          buildInterpretationPrompt(ingress),
-          "",
-          "Malformed model output:",
-          raw
-        ].join("\n")
-      }
-    ],
-    tools: [],
-    temperature: 0,
-    maxTokens: 512,
-    timeoutMs,
-    think: false,
-    responseFormat: steeringInterpretationResponseFormat()
-  });
-  return parseSteeringInterpretation(repaired.choices[0]?.message?.content ?? "");
-}
-function buildSteeringPacket(ingress, interpretation) {
-  const lines = [
-    STEERING_START,
-    `id: ${ingress.id}`,
-    `sourceSurface: ${ingress.sourceSurface}`,
-    `feedbackKind: external_human`,
-    `authority: ${ingress.authority}`,
-    `replacement: ${ingress.isReplacement ? "true" : "false"}`,
-    `toolCallsSoFar: ${ingress.toolCallCount}`,
-    `timestamp: ${ingress.timestamp}`,
-    "",
-    "Instruction hierarchy:",
-    "- Treat this as user-level steering, below system/developer/tool safety and above older user assumptions when they conflict.",
-    "",
-    "Current task goal:",
-    truncateBlock(ingress.currentTaskGoal || "(unknown current task)", 1200),
-    "",
-    "Recent activity:",
-    truncateBlock(ingress.recentActivity || "(no recent activity recorded)", 1200),
-    "",
-    ingress.filesTouched.length > 0 ? `Files touched so far: ${ingress.filesTouched.join(", ")}` : "Files touched so far: none recorded",
-    "",
-    RAW_START,
-    ingress.rawText,
-    RAW_END,
-    ""
-  ];
-  if (interpretation) {
-    lines.push("Model-derived steering interpretation:", `inference: ${interpretation.inference}`, `runnerInstruction: ${interpretation.runnerInstruction}`);
-    if (interpretation.conflicts?.length) {
-      lines.push("conflicts:", ...interpretation.conflicts.map((item) => `- ${item}`));
-    }
-    if (interpretation.alternatives?.length) {
-      lines.push("alternative interpretations:", ...interpretation.alternatives.map((item) => `- ${item}`));
-    }
-    if (interpretation.memoryNote) {
-      lines.push(`memoryNote: ${interpretation.memoryNote}`);
-    }
-    lines.push("");
-  } else {
-    lines.push("Model-derived steering interpretation: unavailable", "");
-  }
-  lines.push("Interleave contract:", "- Consume this before the next assistant/tool decision.", "- Do not treat it as passive transcript context.", "- Either act on the steering directly, or explicitly reconcile why it does not alter the current plan.", STEERING_END);
-  return lines.join("\n");
-}
-function extractMidTaskSteeringInput(value2) {
-  const start2 = value2.indexOf(RAW_START);
-  const end = value2.indexOf(RAW_END);
-  if (start2 < 0 || end <= start2)
-    return null;
-  return value2.slice(start2 + RAW_START.length, end).trim();
-}
-function appendSteeringLedgerEntry(repoRoot, entry) {
-  try {
-    const dir = join104(repoRoot, ".omnius", "context");
-    mkdirSync51(dir, { recursive: true });
-    appendFileSync6(join104(dir, LEDGER_FILE), `${JSON.stringify(entry)}
-`, "utf-8");
-  } catch {
-  }
-}
-function appendSteeringOutcome(repoRoot, packetIds, outcome, summary) {
-  for (const packetId of packetIds) {
-    appendSteeringLedgerEntry(repoRoot, {
-      type: "outcome",
-      packetId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      outcome,
-      summary: summary.slice(0, 1200)
-    });
-  }
-}
-function buildRecentSteeringContext(repoRoot, limit = 3) {
-  const entries = readRecentSteeringEntries(repoRoot, limit);
-  if (entries.length === 0)
-    return "";
-  const lines = entries.map((entry, idx) => {
-    const interpretation = entry.interpretation;
-    const inference = interpretation?.inference || "(raw steering only)";
-    const note = interpretation?.memoryNote ? ` Memory note: ${interpretation.memoryNote}` : "";
-    const outcome = entry.outcome ? ` Outcome: ${entry.outcome}.` : "";
-    return `${idx + 1}. ${inference}${note}${outcome}`;
-  });
-  return [
-    "<recent-user-steering>",
-    "Recent user steering reflections from this workspace. Use only when relevant to the current task.",
-    ...lines,
-    "</recent-user-steering>"
-  ].join("\n");
-}
-function buildInterpretationPrompt(ingress) {
-  return [
-    "Infer how this human feedback changes, constrains, or clarifies the active task.",
-    "If there are multiple plausible readings, include them in alternatives.",
-    "If the feedback conflicts with prior task assumptions, list the conflict.",
-    "If this should persist beyond the current turn, include memoryNote.",
-    "",
-    "Return JSON:",
-    "{",
-    '  "inference": "concise user-facing task-impact inference",',
-    '  "runnerInstruction": "specific instruction for the next agent decision",',
-    '  "conflicts": ["optional conflict"],',
-    '  "alternatives": ["optional alternate reading"],',
-    '  "memoryNote": "optional durable lesson"',
-    "}",
-    "",
-    `replacement: ${ingress.isReplacement ? "true" : "false"}`,
-    `toolCallsSoFar: ${ingress.toolCallCount}`,
-    "",
-    "Current task goal:",
-    truncateBlock(ingress.currentTaskGoal || "(unknown current task)", 1200),
-    "",
-    "Recent activity:",
-    truncateBlock(ingress.recentActivity || "(no recent activity recorded)", 1200),
-    "",
-    ingress.filesTouched.length > 0 ? `Files touched so far: ${ingress.filesTouched.join(", ")}` : "Files touched so far: none recorded",
-    "",
-    RAW_START,
-    ingress.rawText,
-    RAW_END
-  ].join("\n");
-}
-function parseSteeringInterpretation(raw) {
-  const candidate = extractJsonObject(raw);
-  if (!candidate)
-    return null;
-  try {
-    const parsed = SteeringInterpretationSchema.parse(JSON.parse(candidate));
-    return {
-      inference: parsed.inference,
-      runnerInstruction: parsed.runnerInstruction,
-      conflicts: parsed.conflicts,
-      alternatives: parsed.alternatives,
-      memoryNote: parsed.memoryNote
-    };
-  } catch {
-    return null;
-  }
-}
-function extractJsonObject(raw) {
-  const text2 = raw.trim();
-  if (!text2)
-    return null;
-  try {
-    JSON.parse(text2);
-    return text2;
-  } catch {
-  }
-  let start2 = -1;
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  for (let i2 = 0; i2 < text2.length; i2++) {
-    const ch = text2[i2];
-    if (inString) {
-      if (escaped) {
-        escaped = false;
-      } else if (ch === "\\") {
-        escaped = true;
-      } else if (ch === '"') {
-        inString = false;
-      }
-      continue;
-    }
-    if (ch === '"') {
-      inString = true;
-      continue;
-    }
-    if (ch === "{") {
-      if (depth === 0)
-        start2 = i2;
-      depth++;
-      continue;
-    }
-    if (ch === "}") {
-      depth--;
-      if (depth === 0 && start2 >= 0)
-        return text2.slice(start2, i2 + 1);
-      if (depth < 0) {
-        start2 = -1;
-        depth = 0;
-      }
-    }
-  }
-  return null;
-}
-function steeringInterpretationResponseFormat() {
-  return { type: "json_object" };
-}
-function readRecentSteeringEntries(repoRoot, limit) {
-  try {
-    const file = join104(repoRoot, ".omnius", "context", LEDGER_FILE);
-    if (!existsSync93(file))
-      return [];
-    const lines = readFileSync72(file, "utf-8").split("\n").filter(Boolean).slice(-100);
-    const parsedEntries = [];
-    for (const line of lines) {
-      try {
-        parsedEntries.push(JSON.parse(line));
-      } catch {
-      }
-    }
-    const latestOutcomes = /* @__PURE__ */ new Map();
-    for (const entry of parsedEntries) {
-      if (entry.type === "outcome")
-        latestOutcomes.set(entry.packetId, entry);
-    }
-    const out = [];
-    for (let i2 = parsedEntries.length - 1; i2 >= 0 && out.length < limit; i2--) {
-      const parsed = parsedEntries[i2];
-      if (parsed.type === "ingress") {
-        const outcome = latestOutcomes.get(parsed.packetId);
-        out.push(outcome ? { ...parsed, outcome: outcome.outcome, summary: outcome.summary } : parsed);
-      }
-    }
-    return out;
-  } catch {
-    return [];
-  }
-}
-function truncateBlock(value2, max) {
-  const trimmed = value2.trim();
-  if (trimmed.length <= max)
-    return trimmed;
-  return `${trimmed.slice(0, max).trimEnd()}
-...(truncated)`;
-}
-var STEERING_START, STEERING_END, RAW_START, RAW_END, LEDGER_FILE, SteeringInterpretationSchema;
-var init_steeringIntake = __esm({
-  "packages/orchestrator/dist/steeringIntake.js"() {
-    "use strict";
-    STEERING_START = "[MID_TASK_STEERING_INTAKE v2]";
-    STEERING_END = "[/MID_TASK_STEERING_INTAKE]";
-    RAW_START = "<<<USER_ADDED_CONTEXT>>>";
-    RAW_END = "<<<END_USER_ADDED_CONTEXT>>>";
-    LEDGER_FILE = "steering-ledger.jsonl";
-    SteeringInterpretationSchema = z17.object({
-      inference: z17.string().trim().min(1),
-      runnerInstruction: z17.string().trim().min(1),
-      conflicts: z17.array(z17.string().trim().min(1)).optional().default([]),
-      alternatives: z17.array(z17.string().trim().min(1)).optional().default([]),
-      memoryNote: z17.string().trim().min(1).optional()
-    });
-  }
-});
-
 // packages/orchestrator/dist/flowstatePrompt.js
 var FLOWSTATE_PROMPT;
 var init_flowstatePrompt = __esm({