omnius 1.0.891 → 1.0.893

package/dist/library.js

@@ -3505,6 +3505,9 @@ var init_jetson_monitor = __esm({
 function currentHostEnvironment() {
   return globalThis.process?.env ?? {};
 }
+function cpuOffloadAllowedFromEnv(env = currentHostEnvironment()) {
+  return env[OMNIUS_CPU_OFFLOAD_ALLOWED_ENV] === "1";
+}
 function normalizeGpuUuidList(value) {
   if (value === void 0)
     return void 0;
@@ -3541,12 +3544,13 @@ function isGpuUuidEnabled(uuid, enabledUuids = enabledGpuUuidsFromEnv()) {
     return true;
   return Boolean(uuid && enabledUuids.includes(uuid));
 }
-var OMNIUS_GPU_ENABLED_UUIDS_ENV, OMNIUS_GPU_PREFERRED_UUID_ENV;
+var OMNIUS_GPU_ENABLED_UUIDS_ENV, OMNIUS_GPU_PREFERRED_UUID_ENV, OMNIUS_CPU_OFFLOAD_ALLOWED_ENV;
 var init_gpu_selection = __esm({
   "packages/schemas/dist/gpu-selection.js"() {
     "use strict";
     OMNIUS_GPU_ENABLED_UUIDS_ENV = "OMNIUS_GPU_ENABLED_UUIDS";
     OMNIUS_GPU_PREFERRED_UUID_ENV = "OMNIUS_GPU_PREFERRED_UUID";
+    OMNIUS_CPU_OFFLOAD_ALLOWED_ENV = "OMNIUS_CPU_OFFLOAD_ALLOWED";
   }
 });
 
@@ -82933,6 +82937,25 @@ function findBundledSkillsRoot(repoRoot) {
   }
   return null;
 }
+function findBundledReaSkills(repoRoot) {
+  const hasSkills = (root) => existsSync17(join20(root, "omnius-rea", "SKILL.md")) && existsSync17(join20(root, "reverse-engineer-anything", "SKILL.md"));
+  const explicit = process.env["OMNIUS_REA_SKILLS_ROOT"];
+  if (explicit)
+    return hasSkills(explicit) ? explicit : null;
+  const candidates = [
+    join20(repoRoot, "packages", "cli", "assets", "rea", "skills"),
+    join20(repoRoot, "assets", "rea", "skills")
+  ];
+  let current2 = dirname9(fileURLToPath3(import.meta.url));
+  for (let depth = 0; depth < 10; depth++) {
+    candidates.push(join20(current2, "assets", "rea", "skills"), join20(current2, "packages", "cli", "assets", "rea", "skills"));
+    const parent = dirname9(current2);
+    if (parent === current2)
+      break;
+    current2 = parent;
+  }
+  return candidates.find(hasSkills) ?? null;
+}
 function discoverSkills(repoRoot) {
   const skills = /* @__PURE__ */ new Map();
   const { frameworksDir, addonsDir, pluginsDir } = getAiwgPaths();
@@ -82985,6 +83008,9 @@ function discoverSkills(repoRoot) {
       loadComponent(join20(bundledAddons, addon), `bundled-addon:${addon}`);
     }
   }
+  const reaSkills = findBundledReaSkills(repoRoot);
+  if (reaSkills)
+    loadSkillsFromDir(reaSkills, "bundled-rea", skills);
   const projectAiwg = join20(repoRoot, ".aiwg");
   loadSkillsFromDir(join20(projectAiwg, "skills"), "project", skills);
   loadCommandsFromDir(join20(projectAiwg, "commands"), "project", skills);
@@ -338743,7 +338769,7 @@ var init_ollama_pool = __esm({
             continue;
           }
           const PROBE_GRACE_MS = 3e4;
-          if (inst.state.inflight === 0 && Date.now() - inst.state.spawnedAtMs > PROBE_GRACE_MS && await this.isPartialVramSpilled(inst)) {
+          if (!cpuOffloadAllowedFromEnv() && inst.state.inflight === 0 && Date.now() - inst.state.spawnedAtMs > PROBE_GRACE_MS && await this.isPartialVramSpilled(inst)) {
             const reapedAtMs = Date.now();
             await inst.terminate();
             this.dropAffinityFor(inst.state.id);
@@ -352526,6 +352552,328 @@ var NativeOllamaToolCalls = class {
   }
 };
 
+// packages/orchestrator/dist/tool-argument-repair.js
+function shape2(parameters) {
+  const properties = parameters["properties"];
+  return {
+    properties: new Set(properties && typeof properties === "object" && !Array.isArray(properties) ? Object.keys(properties) : []),
+    required: Array.isArray(parameters["required"]) ? parameters["required"].filter((key) => typeof key === "string") : []
+  };
+}
+function findBetterToolSchemaMatches(input) {
+  const keys4 = [...new Set(input.providedKeys.filter((key) => !key.startsWith("_")))];
+  if (!keys4.length)
+    return [];
+  const provided = new Set(keys4), requested = shape2(input.requestedParameters);
+  const requestedMissing = requested.required.filter((key) => !provided.has(key)).length;
+  const requestedUnknown = keys4.filter((key) => !requested.properties.has(key)).length;
+  if (!requestedMissing && !requestedUnknown)
+    return [];
+  const matches = /* @__PURE__ */ new Map();
+  for (const candidate of input.candidates) {
+    if (candidate.name === input.requestedToolName)
+      continue;
+    const target2 = shape2(candidate.parameters ?? {});
+    if (!target2.properties.size || target2.required.some((key) => !provided.has(key)) || keys4.some((key) => !target2.properties.has(key)))
+      continue;
+    matches.set(candidate.name, keys4.length * 2 + target2.required.length * 3);
+  }
+  return [...matches].sort(([left, leftScore], [right, rightScore]) => rightScore - leftScore || left.localeCompare(right)).slice(0, 3).map(([name]) => name);
+}
+
+// packages/orchestrator/dist/forced-update-requirement-recovery.js
+function reconcileForcedUpdateReadOnlyOperations(ledger, interruption) {
+  if (!ledger.workPlan || ledger.runId !== interruption.runId || ledger.taskEpoch !== interruption.taskEpoch)
+    return ledger;
+  const retired = new Set(interruption.pendingAcknowledgements.filter((ack) => ack.status === "timed_out" && ack.effect === "read_only" && ack.generation < interruption.owner.generation).map((ack) => ack.id));
+  if (!ledger.workPlan.units.some((unit) => unit.pendingOperationRef && retired.has(unit.pendingOperationRef)))
+    return ledger;
+  const next = structuredClone(ledger);
+  for (const unit of next.workPlan.units)
+    if (unit.pendingOperationRef && retired.has(unit.pendingOperationRef)) {
+      delete unit.pendingOperationRef;
+      if (unit.attemptState === "running")
+        unit.attemptState = "selected";
+    }
+  next.workPlan.revision++;
+  return next;
+}
+function applyForcedUpdateRequirementRecovery(recovery, receipt) {
+  return reduceRecovery(recovery, receipt, true, 0);
+}
+function projectForcedUpdateRequirementRecoveryPrefix(recovery, receipt) {
+  return reduceRecovery(recovery, receipt, false, 0);
+}
+function reduceRecovery(recovery, receipt, complete, depth) {
+  const reject = () => {
+    throw new Error("forced_update_requirement_recovery_receipt_invalid");
+  };
+  if (depth > 32 || !receipt || receipt.schema !== "omnius.forced-update-requirement-recovery-receipt.v1" || ["checkpointSha256", "runId", "sessionId", "taskEpoch", "ownerGeneration"].some((key) => receipt[key] !== recovery[key]) || !Array.isArray(receipt.resolutions))
+    reject();
+  const expected = new Map(recovery.requirementHolds.map((hold2) => [hold2.inputId, hold2.nativeInputSha256]));
+  for (const authority of recovery.requirementAmendments) {
+    if (expected.has(authority.inputId) && expected.get(authority.inputId) !== authority.scope.nativeInputSha256)
+      reject();
+    expected.set(authority.inputId, authority.scope.nativeInputSha256);
+  }
+  let completionLedger = restoreCompletionLedgerSnapshot(recovery.completionLedger);
+  let nativeScope = structuredClone(recovery.nativeScope), expectedOutcome = structuredClone(recovery.expectedOutcome);
+  let recoveredSteering = structuredClone(recovery.steering);
+  const resolvedInputIds = [], replacementInputs = [], responseInputs = [];
+  if (receipt.predecessor) {
+    const prior = receipt.predecessor.recovery;
+    const base = (ledger) => {
+      const { updatedAtIso: _clock, ...facts } = restoreCompletionLedgerSnapshot(ledger);
+      return taskExecutionDigest(facts);
+    };
+    if (!prior || prior.runId !== recovery.runId || prior.sessionId !== recovery.sessionId || prior.taskEpoch !== recovery.taskEpoch || prior.ownerGeneration >= recovery.ownerGeneration || base(prior.completionLedger) !== base(recovery.completionLedger) || taskExecutionDigest(prior.nativeScope) !== taskExecutionDigest(recovery.nativeScope) || taskExecutionDigest(prior.expectedOutcome) !== taskExecutionDigest(recovery.expectedOutcome) || prior.steering.some((input) => !recovery.steering.some((current2) => taskExecutionDigest(current2) === taskExecutionDigest(input))))
+      reject();
+    const projected = reduceRecovery(prior, receipt.predecessor.receipt, true, depth + 1);
+    const priorHashes = new Map([
+      ...prior.requirementHolds.map((hold2) => [hold2.inputId, hold2.nativeInputSha256]),
+      ...prior.requirementAmendments.map((authority) => [authority.inputId, authority.scope.nativeInputSha256])
+    ]);
+    for (const inputId of projected.resolvedInputIds) {
+      if (!expected.has(inputId) || expected.get(inputId) !== priorHashes.get(inputId))
+        reject();
+      expected.delete(inputId);
+      resolvedInputIds.push(inputId);
+    }
+    completionLedger = projected.completionLedger;
+    nativeScope = projected.nativeScope;
+    expectedOutcome = projected.expectedOutcome;
+    recoveredSteering = projected.recoveredSteering;
+    for (const input of recovery.steering)
+      if (!recoveredSteering.some((current2) => current2.inputId === input.inputId))
+        recoveredSteering.push(structuredClone(input));
+    replacementInputs.push(...projected.replacementInputs);
+    responseInputs.push(...projected.responseInputs);
+  }
+  if ((complete ? receipt.resolutions.length !== expected.size : receipt.resolutions.length > expected.size) || new Set(receipt.resolutions.map((result) => result?.inputId)).size !== receipt.resolutions.length)
+    reject();
+  for (const result of receipt.resolutions) {
+    if (!result || !expected.has(result.inputId) || expected.get(result.inputId) !== result.nativeInputSha256)
+      reject();
+    let steering = recoveredSteering.find((input) => input.inputId === result.inputId && input.source === "telegram" && input.taskEpoch === recovery.taskEpoch);
+    if (!steering && result.steering) {
+      const supplied = result.steering;
+      if (supplied.inputId !== result.inputId || supplied.source !== "telegram" || supplied.taskEpoch !== recovery.taskEpoch || !["queued", "acknowledged"].includes(supplied.state) || typeof supplied.content !== "string" || !supplied.content.trim() || !["append", "clarify", "context_only", "constraint", "priority_change", ...result.disposition === "replacement" ? ["replace", "redirect"] : []].includes(supplied.intent) || typeof supplied.receivedAt !== "string" || !Number.isFinite(Date.parse(supplied.receivedAt)))
+        reject();
+      steering = structuredClone(supplied);
+      recoveredSteering.push(steering);
+    }
+    if (!steering)
+      reject();
+    if (result.disposition === "amendment") {
+      if (!result.authority || result.authority.inputId !== result.inputId || result.authority.scope.nativeInputSha256 !== result.nativeInputSha256)
+        reject();
+      const authority = structuredClone(result.authority), plan = completionLedger.workPlan;
+      if (plan) {
+        authority.nextWorkPlan.revision = plan.revision + 1;
+        for (const unit of authority.nextWorkPlan.units) {
+          const prior = plan.units.find((current2) => current2.id === unit.id);
+          if (!prior)
+            continue;
+          unit.outcomeEvidenceIds = [.../* @__PURE__ */ new Set([...unit.outcomeEvidenceIds, ...prior.outcomeEvidenceIds])];
+          if (prior.pendingOperationRef)
+            unit.pendingOperationRef = prior.pendingOperationRef;
+          else
+            delete unit.pendingOperationRef;
+        }
+      }
+      completionLedger = applyNativeTaskRequirementAmendmentV1({
+        ledger: completionLedger,
+        priorExpectedOutcome: expectedOutcome,
+        priorScope: nativeScope,
+        amendment: authority,
+        steering
+      });
+      nativeScope = authority.scope;
+      expectedOutcome = authority.nextExpectedOutcome;
+    } else {
+      const proof = result.review;
+      if (!["unchanged", "context", "no_action", "cancelled", "replacement", "response"].includes(result.disposition) || !proof || !/^[a-f0-9]{64}$/.test(proof.requestSha256) || !/^[a-f0-9]{64}$/.test(proof.resultSha256) || typeof proof.model !== "string" || !proof.model.trim() || typeof proof.providerProtocol !== "string" || !proof.providerProtocol.trim())
+        reject();
+      if (result.disposition === "cancelled")
+        steering.state = "cancelled";
+      else if (result.disposition === "context" || result.disposition === "no_action")
+        steering.state = "consumed";
+      else if (result.disposition === "replacement" || result.disposition === "response") {
+        if (result.disposition === "replacement" && steering.allowTaskReplacement === false || !result.decisionPayload || typeof result.decisionPayload !== "object" || Array.isArray(result.decisionPayload) || taskExecutionDigest(result.decisionPayload) !== result.decisionPayloadSha256)
+          reject();
+        if (result.disposition === "replacement") {
+          steering.state = "cancelled";
+          replacementInputs.push(structuredClone(result));
+        } else {
+          steering.state = "consumed";
+          responseInputs.push(structuredClone(result));
+        }
+      }
+    }
+    expected.delete(result.inputId);
+    resolvedInputIds.push(result.inputId);
+  }
+  return { completionLedger, nativeScope, expectedOutcome, recoveredSteering, resolvedInputIds, replacementInputs, responseInputs };
+}
+
+// packages/orchestrator/dist/adjudication.js
+import { z as z18 } from "zod";
+var ADJUDICATION_TOOL_NAME = "adjudicate";
+var ADJUDICATION_ID_PATTERN = "^[A-Za-z0-9][A-Za-z0-9._:-]*$";
+function adjudicationArgumentRepairContract(error, argsHash) {
+  let issues = [];
+  try {
+    const parsed = JSON.parse(error);
+    if (Array.isArray(parsed))
+      issues = parsed.filter((issue3) => issue3 && typeof issue3 === "object");
+  } catch {
+  }
+  const parameters = adjudicationToolParameters();
+  const fields2 = issues.slice(0, 8).map((issue3) => {
+    const parts = Array.isArray(issue3.path) ? issue3.path : [];
+    let schema = parameters;
+    for (const part of parts) {
+      const next = typeof part === "number" ? schema?.items : schema?.properties?.[part];
+      schema = next && typeof next === "object" && !Array.isArray(next) ? next : void 0;
+    }
+    const constraints = schema && Object.fromEntries(Object.entries(schema).filter(([key]) => ["type", "minLength", "maxLength", "pattern", "enum", "minimum", "maximum", "minItems", "maxItems", "required"].includes(key)));
+    return {
+      path: parts.map((part) => typeof part === "number" ? `[${part}]` : part).join(".").replace(/\.\[/g, "[") || "arguments",
+      message: String(issue3.message ?? "invalid value"),
+      ...constraints ? { schema: constraints } : {}
+    };
+  });
+  return {
+    reason_code: "invalid_tool_arguments",
+    tool: ADJUDICATION_TOOL_NAME,
+    retryable: false,
+    ...argsHash ? { args_sha256: argsHash } : {},
+    fields: fields2.length ? fields2 : [{ path: "arguments", message: error.slice(0, 1400) }]
+  };
+}
+function formatAdjudicationArgumentRepair(error, argsHash) {
+  const contract = adjudicationArgumentRepairContract(error, argsHash);
+  return [
+    "[ADJUDICATION_ARGUMENT_REPAIR]",
+    JSON.stringify(contract),
+    ...contract.fields.map((field) => `${field.path}: ${field.message}`),
+    "Required keys for adjudicate: question, allowedOutcomes, evidence",
+    `IDs must be 1–96 characters matching ${ADJUDICATION_ID_PATTERN}; no whitespace or sentence-valued IDs.`,
+    'Format-only example: allowedOutcomes=["option_a","option_b"], context="option_a means the first described outcome; option_b means the second described outcome".',
+    "Keep the user's actual outcome descriptions in context/evidence. Choose explicit stable IDs yourself; do not drop or silently rewrite evidence, manufacture an outcome, or substitute another tool for a field-format error.",
+    "This exact argument instance cannot be retried unchanged. Correct the named values and retry immediately, or continue other substantive work. No panel ran for this rejected call."
+  ].join("\n");
+}
+var IdSchema = z18.string().trim().min(1).max(96).regex(new RegExp(ADJUDICATION_ID_PATTERN), "use a stable identifier without whitespace").describe("Stable identifier: 1–96 characters matching ^[A-Za-z0-9][A-Za-z0-9._:-]*$. Put prose descriptions in context/evidence, not IDs.");
+var AdjudicationEvidenceSchema = z18.object({
+  id: IdSchema,
+  content: z18.string().trim().min(1).max(32e3),
+  source: z18.string().trim().min(1).max(500),
+  kind: z18.enum([
+    "fact",
+    "observation",
+    "artifact",
+    "test_result",
+    "testimony",
+    "constraint",
+    "precedent"
+  ]).default("observation"),
+  observedAt: z18.string().trim().max(80).optional(),
+  sha256: z18.string().trim().regex(/^[a-fA-F0-9]{64}$/).optional(),
+  reliability: z18.number().min(0).max(1).optional()
+});
+var AdjudicationArgumentSchema = z18.object({
+  id: IdSchema,
+  position: z18.string().trim().min(1).max(160),
+  claim: z18.string().trim().min(1).max(4e3),
+  citedEvidenceIds: z18.array(IdSchema).min(1).max(64),
+  submittedBy: z18.string().trim().max(160).optional()
+});
+var AdjudicationConstituentInputSchema = z18.object({
+  id: IdSchema.optional(),
+  label: z18.string().trim().min(1).max(120),
+  question: z18.string().trim().min(1).max(2e3),
+  instructions: z18.string().trim().max(2e3).optional(),
+  evidenceIds: z18.array(IdSchema).min(1).max(128).optional(),
+  argumentIds: z18.array(IdSchema).max(64).optional(),
+  decisionRuleIds: z18.array(IdSchema).max(32).optional()
+});
+var AdjudicationInputSchema = z18.object({
+  caseId: IdSchema.optional(),
+  question: z18.string().trim().min(1).max(4e3).describe("The exact decision question. Ask one decision only."),
+  context: z18.string().trim().max(8e3).optional().describe("Neutral context needed to interpret the record, including each stable outcome ID's prose meaning."),
+  exclusions: z18.array(z18.string().trim().min(1).max(2e3)).max(32).default([]).describe("Explicitly excluded material or considerations that the panel must not admit."),
+  allowedOutcomes: z18.array(IdSchema).min(2).max(12).describe("Closed set of stable verdict IDs, for example option_a and option_b; preserve their prose meanings in context. insufficient_evidence is reserved by the tool."),
+  decisionRules: z18.array(z18.string().trim().min(1).max(2e3)).max(24).default([]).describe("Rules the judge must apply."),
+  burdenOfProof: z18.enum([
+    "best_supported",
+    "preponderance",
+    "clear_and_convincing",
+    "beyond_reasonable_doubt",
+    "risk_averse"
+  ]).default("best_supported"),
+  evidence: z18.array(AdjudicationEvidenceSchema).min(1).max(128),
+  arguments: z18.array(AdjudicationArgumentSchema).max(64).default([]),
+  constituents: z18.array(AdjudicationConstituentInputSchema).min(2).max(6).optional().describe("Optional independent focus assignments. Omit to let the case framer derive them."),
+  panelSize: z18.number().int().min(2).max(6).default(3),
+  maxConcurrency: z18.number().int().min(1).max(6).default(3),
+  quorum: z18.number().int().min(2).max(6).optional(),
+  constituentExecution: z18.enum(["auto", "full_sub_agent", "direct"]).default("auto").describe("auto uses the dedicated full_sub_agent profile when available, otherwise the direct bounded fallback."),
+  timeoutMs: z18.number().int().min(5e3).max(6e5).default(12e4),
+  maxTokensPerConstituent: z18.number().int().min(512).max(8192).default(2048),
+  maxJudgeTokens: z18.number().int().min(768).max(12288).default(3072)
+});
+function adjudicationToolParameters() {
+  const { $schema: _dialect, ...parameters } = z18.toJSONSchema(AdjudicationInputSchema, { target: "draft-7", io: "input" });
+  return parameters;
+}
+var PlannerResponseSchema = z18.object({
+  schemaVersion: z18.literal(1),
+  caseId: IdSchema,
+  assignments: z18.array(z18.object({
+    id: IdSchema,
+    label: z18.string().trim().min(1).max(120),
+    question: z18.string().trim().min(1).max(2e3),
+    instructions: z18.string().trim().max(2e3).default(""),
+    evidenceIds: z18.array(IdSchema).min(1).max(128),
+    argumentIds: z18.array(IdSchema).max(64).default([]),
+    decisionRuleIds: z18.array(IdSchema).min(1).max(32)
+  })).min(2).max(6)
+});
+var ConstituentResponseSchema = z18.object({
+  schemaVersion: z18.literal(1),
+  caseId: IdSchema,
+  constituentId: IdSchema,
+  assessment: z18.string().trim().min(20).max(8e3),
+  recommendation: IdSchema,
+  confidence: z18.number().min(0).max(1),
+  citedEvidenceIds: z18.array(IdSchema).min(1).max(128),
+  claims: z18.array(z18.object({
+    claim: z18.string().trim().min(1).max(2e3),
+    evidenceIds: z18.array(IdSchema).min(1).max(64)
+  })).min(1).max(24),
+  counterarguments: z18.array(z18.string().trim().min(1).max(2e3)).max(16).default([]),
+  uncertainties: z18.array(z18.string().trim().min(1).max(2e3)).max(16).default([])
+});
+var JudgeResponseSchema = z18.object({
+  schemaVersion: z18.literal(1),
+  caseId: IdSchema,
+  verdict: IdSchema,
+  confidence: z18.number().min(0).max(1),
+  rationale: z18.string().trim().min(30).max(12e3),
+  citedEvidenceIds: z18.array(IdSchema).min(1).max(128),
+  consideredConstituentIds: z18.array(IdSchema).min(2).max(6),
+  acceptedFindingIds: z18.array(IdSchema).max(144),
+  rejectedFindingIds: z18.array(IdSchema).max(144),
+  dissent: z18.array(z18.object({
+    constituentId: IdSchema,
+    recommendation: IdSchema,
+    summary: z18.string().trim().min(1).max(2e3)
+  })).max(6).default([]),
+  unresolvedQuestions: z18.array(z18.string().trim().min(1).max(2e3)).max(24).default([]),
+  nextAction: z18.string().trim().min(1).max(4e3)
+});
+
 // packages/orchestrator/dist/openai-chat-stream-parser.js
 var object10 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var MAX_PACKET_BYTES = 8388608;
@@ -355125,15 +355473,15 @@ var SelfImprovementArchive = class {
 import { createHash as createHash69, randomUUID as randomUUID41 } from "node:crypto";
 import { closeSync as closeSync12, existsSync as existsSync30, fsyncSync as fsyncSync6, mkdirSync as mkdirSync24, openSync as openSync12, readFileSync as readFileSync34, renameSync as renameSync12, unlinkSync as unlinkSync12, writeFileSync as writeFileSync22 } from "node:fs";
 import { dirname as dirname23, join as join40 } from "node:path";
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // packages/orchestrator/dist/commandEvidenceReceipt.js
-import { z as z18 } from "zod";
-var token2 = z18.string().refine((value) => value.trim().length > 0 && !value.includes("\0"));
-var timestamp2 = z18.string().datetime({ offset: true });
-var integer3 = z18.number().int().safe();
-var CommandEvidenceReceiptSchema = z18.object({
-  schema: z18.literal("omnius.command-evidence-receipt.v1"),
+import { z as z19 } from "zod";
+var token2 = z19.string().refine((value) => value.trim().length > 0 && !value.includes("\0"));
+var timestamp2 = z19.string().datetime({ offset: true });
+var integer3 = z19.number().int().safe();
+var CommandEvidenceReceiptSchema = z19.object({
+  schema: z19.literal("omnius.command-evidence-receipt.v1"),
   command: token2,
   canonicalCommand: token2,
   cwd: token2,
@@ -355141,20 +355489,20 @@ var CommandEvidenceReceiptSchema = z18.object({
   primaryCommand: token2.optional(),
   primaryExitCode: integer3.nullable().optional(),
   runnerExitCode: integer3.nullable().optional(),
-  primaryExitProvenance: z18.enum(["runner_process", "trailing_exit_reporter"]).optional(),
-  pipefail: z18.boolean(),
-  timedOut: z18.boolean(),
+  primaryExitProvenance: z19.enum(["runner_process", "trailing_exit_reporter"]).optional(),
+  pipefail: z19.boolean(),
+  timedOut: z19.boolean(),
   startedAtIso: timestamp2,
   finishedAtIso: timestamp2,
-  shellRunId: z18.string().uuid().optional(),
+  shellRunId: z19.string().uuid().optional(),
   timeoutMs: integer3.positive().nullable().optional(),
-  cancelled: z18.boolean().optional(),
+  cancelled: z19.boolean().optional(),
   signal: token2.nullable().optional(),
-  observation: z18.object({ kind: z18.literal("search_no_match") }).strict().optional(),
+  observation: z19.object({ kind: z19.literal("search_no_match") }).strict().optional(),
   outputRef: token2.optional(),
-  observedPaths: z18.array(token2).optional(),
-  artifactHashes: z18.array(z18.object({ path: token2, sha256: z18.string().regex(/^[a-f0-9]{64}$/) }).strict()).optional(),
-  declaredVerification: z18.object({ protocol: z18.literal("OMNIUS_VERIFICATION_RESULT"), outcome: z18.enum(["pass", "fail"]) }).strict().optional()
+  observedPaths: z19.array(token2).optional(),
+  artifactHashes: z19.array(z19.object({ path: token2, sha256: z19.string().regex(/^[a-f0-9]{64}$/) }).strict()).optional(),
+  declaredVerification: z19.object({ protocol: z19.literal("OMNIUS_VERIFICATION_RESULT"), outcome: z19.enum(["pass", "fail"]) }).strict().optional()
 }).strict().refine((value) => Date.parse(value.finishedAtIso) >= Date.parse(value.startedAtIso));
 function parseCommandEvidenceReceipt(value) {
   try {
@@ -355167,21 +355515,21 @@ function parseCommandEvidenceReceipt(value) {
 
 // packages/orchestrator/dist/conversationReportEvidence.js
 var SCHEMA = "omnius.conversation-report-evidence.v2";
-var token3 = z19.string().refine((value) => value.trim().length > 0 && !value.includes("\0"));
-var timestamp3 = z19.string().datetime({ offset: true });
-var integer4 = z19.number().int().safe();
-var identitySchema = z19.object({ sessionId: token3, runId: token3, taskEpoch: integer4.nonnegative() }).strict();
-var reference = z19.string().regex(/^omnius-artifact:\/\/sha256\/[a-f0-9]{64}$/);
-var paths = z19.array(token3);
-var deliveryReceiptSchema = z19.object({
-  schema: z19.literal("omnius.completion-delivery-receipt.v1"),
+var token3 = z20.string().refine((value) => value.trim().length > 0 && !value.includes("\0"));
+var timestamp3 = z20.string().datetime({ offset: true });
+var integer4 = z20.number().int().safe();
+var identitySchema = z20.object({ sessionId: token3, runId: token3, taskEpoch: integer4.nonnegative() }).strict();
+var reference = z20.string().regex(/^omnius-artifact:\/\/sha256\/[a-f0-9]{64}$/);
+var paths = z20.array(token3);
+var deliveryReceiptSchema = z20.object({
+  schema: z20.literal("omnius.completion-delivery-receipt.v1"),
   provider: token3,
   target: token3,
   receiptId: token3,
   deliveredAtIso: timestamp3,
   artifactPaths: paths.optional()
 }).strict();
-var objectiveEvidenceKindSchema = z19.enum([
+var objectiveEvidenceKindSchema = z20.enum([
   "visible_response",
   "observation",
   "mutation",
@@ -355193,79 +355541,79 @@ var objectiveEvidenceKindSchema = z19.enum([
   "authenticated_session",
   "human_input"
 ]);
-var externalEffectReceiptSchema = z19.object({
-  schema: z19.literal("omnius.external-effect-receipt.v1"),
+var externalEffectReceiptSchema = z20.object({
+  schema: z20.literal("omnius.external-effect-receipt.v1"),
   effectKind: token3,
   semanticTarget: token3,
   idempotencyKey: token3,
-  effectState: z19.enum(["pending", "applied", "absent", "unknown"]),
+  effectState: z20.enum(["pending", "applied", "absent", "unknown"]),
   artifactRevision: token3.optional(),
   evidenceId: token3,
-  criterionIds: z19.array(token3),
-  evidenceKinds: z19.array(objectiveEvidenceKindSchema).optional(),
-  destination: z19.object({ url: z19.string().url(), provider: token3 }).strict().optional()
+  criterionIds: z20.array(token3),
+  evidenceKinds: z20.array(objectiveEvidenceKindSchema).optional(),
+  destination: z20.object({ url: z20.string().url(), provider: token3 }).strict().optional()
 }).strict();
-var verificationReceiptSchema = z19.object({
-  schema: z19.literal("omnius.verification-receipt.v1"),
+var verificationReceiptSchema = z20.object({
+  schema: z20.literal("omnius.verification-receipt.v1"),
   evidenceId: token3,
   criterionId: token3,
   artifactEvidenceId: token3,
   artifactRevision: token3.optional(),
   verifierMethod: token3,
-  outcome: z19.enum(["passed", "artifact_failed", "verifier_invalid", "downstream_auth_required", "inconclusive"]),
-  evidenceIds: z19.array(token3),
-  evidenceKinds: z19.array(objectiveEvidenceKindSchema).optional()
+  outcome: z20.enum(["passed", "artifact_failed", "verifier_invalid", "downstream_auth_required", "inconclusive"]),
+  evidenceIds: z20.array(token3),
+  evidenceKinds: z20.array(objectiveEvidenceKindSchema).optional()
 }).strict();
-var externalBlockerSchema = z19.object({
-  schema: z19.literal("omnius.objective-external-blocker.v1"),
-  criterionIds: z19.array(token3),
+var externalBlockerSchema = z20.object({
+  schema: z20.literal("omnius.objective-external-blocker.v1"),
+  criterionIds: z20.array(token3),
   evidenceId: token3,
   blockerKind: token3,
-  retryable: z19.boolean()
+  retryable: z20.boolean()
 }).strict();
-var evidenceSchema = z19.object({
+var evidenceSchema = z20.object({
   id: token3,
-  kind: z19.literal("tool_result"),
+  kind: z20.literal("tool_result"),
   observedAtIso: timestamp3,
-  summary: z19.string(),
+  summary: z20.string(),
   toolName: token3,
-  success: z19.boolean().optional(),
+  success: z20.boolean().optional(),
   rawRef: token3.optional(),
   targetPaths: paths.optional(),
-  role: z19.enum(["observation", "verification", "mutation", "blocker", "delivery"]).optional(),
+  role: z20.enum(["observation", "verification", "mutation", "blocker", "delivery"]).optional(),
   family: token3.optional(),
-  verificationImpact: z19.enum(["invalidates", "neutral"]).optional(),
-  metrics: z19.record(z19.string(), z19.unknown()).optional(),
+  verificationImpact: z20.enum(["invalidates", "neutral"]).optional(),
+  metrics: z20.record(z20.string(), z20.unknown()).optional(),
   receipt: CommandEvidenceReceiptSchema.optional(),
   deliveryReceipt: deliveryReceiptSchema.optional(),
-  progressClass: z19.enum(["work_product", "control_bookkeeping", "observation", "blocker"]).optional(),
-  criterionIds: z19.array(token3).optional(),
-  objectiveEvidenceKinds: z19.array(objectiveEvidenceKindSchema).optional(),
+  progressClass: z20.enum(["work_product", "control_bookkeeping", "observation", "blocker"]).optional(),
+  criterionIds: z20.array(token3).optional(),
+  objectiveEvidenceKinds: z20.array(objectiveEvidenceKindSchema).optional(),
   externalEffectReceipt: externalEffectReceiptSchema.optional(),
   verificationReceipt: verificationReceiptSchema.optional(),
   externalBlocker: externalBlockerSchema.optional()
 }).strict();
-var chunkSchema = z19.object({
-  schema: z19.literal(SCHEMA),
+var chunkSchema = z20.object({
+  schema: z20.literal(SCHEMA),
   identity: identitySchema,
   previousReference: reference.nullable(),
   sequence: integer4.positive(),
   startEntry: integer4.nonnegative(),
   entryCount: integer4.nonnegative(),
-  entries: z19.array(z19.object({ callId: token3, evidence: evidenceSchema }).strict()),
+  entries: z20.array(z20.object({ callId: token3, evidence: evidenceSchema }).strict()),
   ledgerCreatedAtIso: timestamp3,
   updatedAtIso: timestamp3,
   recoveryGap: token3.max(500).optional()
 }).strict();
-var pointerSchema = z19.object({
-  schema: z19.literal(SCHEMA),
+var pointerSchema = z20.object({
+  schema: z20.literal(SCHEMA),
   identity: identitySchema,
   reference,
   entryCount: integer4.nonnegative(),
   chunkCount: integer4.positive()
 }).strict();
-var pendingSchema = z19.object({
-  schema: z19.literal(SCHEMA),
+var pendingSchema = z20.object({
+  schema: z20.literal(SCHEMA),
   identity: identitySchema,
   previousReference: reference.nullable(),
   previousEntryCount: integer4.nonnegative(),
@@ -355472,7 +355820,7 @@ var ConversationReportEvidence = class {
       this.persistedChunkCount = pointer.chunkCount;
       this.persistedGap = chain[0].recoveryGap;
     } catch (error) {
-      const detail = error instanceof z19.ZodError || error instanceof SyntaxError ? "Saved report evidence has invalid fields or contains task authority." : error instanceof Error ? error.message : String(error);
+      const detail = error instanceof z20.ZodError || error instanceof SyntaxError ? "Saved report evidence has invalid fields or contains task authority." : error instanceof Error ? error.message : String(error);
       this.recoveryGap = `Earlier conversation evidence could not be restored: ${detail}${pendingGap ? ` ${pendingGap}` : ""}`.slice(0, 500);
     }
   }
@@ -355607,7 +355955,7 @@ init_dist5();
 import { createHash as createHash71 } from "node:crypto";
 import { closeSync as closeSync14, existsSync as existsSync32, fsyncSync as fsyncSync8, lstatSync as lstatSync4, mkdirSync as mkdirSync26, openSync as openSync14, readFileSync as readFileSync36, readdirSync as readdirSync11, realpathSync as realpathSync10, renameSync as renameSync14, statSync as statSync17, unlinkSync as unlinkSync14, writeFileSync as writeFileSync24 } from "node:fs";
 import { dirname as dirname24, isAbsolute as isAbsolute13, join as join42, relative as relative9, resolve as resolve27 } from "node:path";
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // packages/orchestrator/dist/contentAddressedArtifactStore.js
 import { createHash as createHash70, randomUUID as randomUUID42 } from "node:crypto";
@@ -356478,10 +356826,10 @@ var equal = (a, b) => canonical6(a) === canonical6(b);
 function fail3(reason) {
   throw new Error(`feature_workflow_${reason}`);
 }
-var token4 = z20.string().trim().min(1).max(1e3);
-var integer5 = z20.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-var ref7 = z20.string().regex(/^omnius-artifact:\/\/sha256\/[a-f0-9]{64}$/);
-var digest5 = z20.string().regex(/^[a-f0-9]{64}$/);
+var token4 = z21.string().trim().min(1).max(1e3);
+var integer5 = z21.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var ref7 = z21.string().regex(/^omnius-artifact:\/\/sha256\/[a-f0-9]{64}$/);
+var digest5 = z21.string().regex(/^[a-f0-9]{64}$/);
 function featureWorkflowInputArtifactsHash(artifacts) {
   return createHash71("sha256").update(JSON.stringify([...artifacts].sort((a, b) => a.slotId.localeCompare(b.slotId)).map((a) => ({
     slotId: a.slotId,
@@ -356489,13 +356837,13 @@ function featureWorkflowInputArtifactsHash(artifacts) {
     content: a.content
   })))).digest("hex");
 }
-var identitySchema2 = z20.object({
+var identitySchema2 = z21.object({
   sessionId: token4,
   runId: token4,
   taskEpoch: integer5,
   generation: integer5
 }).strict();
-var bindingSchema = z20.object({
+var bindingSchema = z21.object({
   parentOperationId: token4,
   parentRunId: token4,
   parentGeneration: integer5,
@@ -356503,22 +356851,22 @@ var bindingSchema = z20.object({
   cardId: token4,
   planReference: ref7,
   cardContract: digest5,
-  inputSlots: z20.record(token4, ref7),
-  kind: z20.enum(["work", "review", "verification"]),
-  readOnly: z20.boolean(),
-  ownedFiles: z20.array(token4).max(128),
+  inputSlots: z21.record(token4, ref7),
+  kind: z21.enum(["work", "review", "verification"]),
+  readOnly: z21.boolean(),
+  ownedFiles: z21.array(token4).max(128),
   inputArtifactsHash: digest5
 }).strict();
 var childSchema = bindingSchema.extend({
-  schema: z20.literal("omnius.feature-workflow-child-receipt.v1"),
+  schema: z21.literal("omnius.feature-workflow-child-receipt.v1"),
   childId: token4,
   childRunId: token4,
   childTaskEpoch: integer5,
   childInputHash: digest5,
-  status: z20.enum(["completed", "failed", "cancelled", "running"]),
+  status: z21.enum(["completed", "failed", "cancelled", "running"]),
   terminalReceiptId: token4.optional()
 }).strict();
-var slotSchema = z20.object({
+var slotSchema = z21.object({
   reference: ref7,
   cardId: token4,
   cardContract: digest5,
@@ -356527,61 +356875,61 @@ var slotSchema = z20.object({
   mutationSequence: integer5,
   workspaceRevision: digest5
 }).strict();
-var operationSchema = z20.object({
+var operationSchema = z21.object({
   binding: bindingSchema,
   actorId: token4,
   toolName: token4,
   command: token4.optional(),
-  effect: z20.enum(["read_only", "local_mutation", "external_effect"]),
-  state: z20.enum(["pending", "interrupted"]),
+  effect: z21.enum(["read_only", "local_mutation", "external_effect"]),
+  state: z21.enum(["pending", "interrupted"]),
   mutationSequence: integer5,
   workspaceRevision: digest5
 }).strict();
-var resultSchema = z20.object({
+var resultSchema = z21.object({
   binding: bindingSchema,
   actorId: token4,
-  success: z20.boolean(),
+  success: z21.boolean(),
   receiptReference: ref7,
-  reviewDisposition: z20.enum(["approved", "changes_requested"]).optional(),
+  reviewDisposition: z21.enum(["approved", "changes_requested"]).optional(),
   childReceipt: childSchema.optional(),
-  commandReceipt: z20.unknown().optional(),
+  commandReceipt: z21.unknown().optional(),
   childReportReference: ref7.optional(),
-  blockers: z20.array(token4).max(96),
-  unresolvedQuestions: z20.array(token4).max(32),
+  blockers: z21.array(token4).max(96),
+  unresolvedQuestions: z21.array(token4).max(32),
   mutationSequence: integer5,
   workspaceRevision: digest5
 }).strict();
-var commandReceiptSchema = z20.object({
-  schema: z20.literal("omnius.command-evidence-receipt.v1"),
+var commandReceiptSchema = z21.object({
+  schema: z21.literal("omnius.command-evidence-receipt.v1"),
   command: token4,
   canonicalCommand: token4,
   cwd: token4,
-  pipefail: z20.boolean(),
-  timedOut: z20.boolean(),
-  cancelled: z20.boolean().optional(),
-  startedAtIso: z20.string().datetime(),
-  finishedAtIso: z20.string().datetime(),
-  exitCode: z20.number().int().nullable().optional(),
-  primaryExitCode: z20.number().int().nullable().optional()
+  pipefail: z21.boolean(),
+  timedOut: z21.boolean(),
+  cancelled: z21.boolean().optional(),
+  startedAtIso: z21.string().datetime(),
+  finishedAtIso: z21.string().datetime(),
+  exitCode: z21.number().int().nullable().optional(),
+  primaryExitCode: z21.number().int().nullable().optional()
 }).passthrough();
-var checkpointSchema = z20.object({
-  schema: z20.literal(SCHEMA2),
+var checkpointSchema = z21.object({
+  schema: z21.literal(SCHEMA2),
   identity: identitySchema2,
   boardRunId: token4,
   planReference: ref7,
   sequence: integer5,
   mutationSequence: integer5,
-  slots: z20.record(token4, slotSchema),
-  operations: z20.record(token4, operationSchema),
-  results: z20.record(token4, resultSchema),
-  recentSettlements: z20.array(z20.object({ operationId: token4, resultHash: digest5 }).strict()).max(256),
-  retired: z20.object({
+  slots: z21.record(token4, slotSchema),
+  operations: z21.record(token4, operationSchema),
+  results: z21.record(token4, resultSchema),
+  recentSettlements: z21.array(z21.object({ operationId: token4, resultHash: digest5 }).strict()).max(256),
+  retired: z21.object({
     reason: token4,
-    at: z20.string().datetime(),
+    at: z21.string().datetime(),
     toEpoch: integer5.optional()
   }).strict().optional(),
   workingDir: token4,
-  adoptions: z20.array(z20.object({
+  adoptions: z21.array(z21.object({
     from: identitySchema2,
     to: identitySchema2,
     sourceCheckpointReference: ref7,
@@ -356858,8 +357206,8 @@ var FeatureWorkflowController = class {
     return this.state;
   }
   assertCurrentSelector() {
-    const actual = existsSync32(this.selectorPath) ? z20.object({
-      schema: z20.literal(SELECTOR_SCHEMA),
+    const actual = existsSync32(this.selectorPath) ? z21.object({
+      schema: z21.literal(SELECTOR_SCHEMA),
       checkpointReference: ref7
     }).strict().parse(JSON.parse(readFileSync36(this.selectorPath, "utf8"))).checkpointReference : null;
     if (actual !== this.selectorReference) {
@@ -356995,8 +357343,8 @@ var FeatureWorkflowController = class {
     try {
       if (!existsSync32(this.selectorPath)) {
         const matches = this.selectorCandidates().filter((file) => {
-          const selector2 = z20.object({
-            schema: z20.literal(SELECTOR_SCHEMA),
+          const selector2 = z21.object({
+            schema: z21.literal(SELECTOR_SCHEMA),
             checkpointReference: ref7
           }).strict().parse(JSON.parse(readFileSync36(join42(dirname24(this.selectorPath), file), "utf8")));
           const state2 = checkpointSchema.parse(JSON.parse(this.store.read(selector2.checkpointReference).content));
@@ -357008,8 +357356,8 @@ var FeatureWorkflowController = class {
           fail3("same_run_checkpoint_not_unique");
         this.selectorPath = join42(dirname24(this.selectorPath), matches[0]);
       }
-      const selector = z20.object({
-        schema: z20.literal(SELECTOR_SCHEMA),
+      const selector = z21.object({
+        schema: z21.literal(SELECTOR_SCHEMA),
         checkpointReference: ref7
       }).strict().parse(JSON.parse(readFileSync36(this.selectorPath, "utf8")));
       const state = checkpointSchema.parse(JSON.parse(this.store.read(selector.checkpointReference).content));
@@ -357063,8 +357411,8 @@ var FeatureWorkflowController = class {
       return [];
     const results = [];
     for (const file of this.selectorCandidates()) {
-      const selector = z20.object({
-        schema: z20.literal(SELECTOR_SCHEMA),
+      const selector = z21.object({
+        schema: z21.literal(SELECTOR_SCHEMA),
         checkpointReference: ref7
       }).strict().parse(JSON.parse(readFileSync36(join42(directory, file), "utf8")));
       const state = checkpointSchema.parse(JSON.parse(this.store.read(selector.checkpointReference).content));
@@ -357091,8 +357439,8 @@ var FeatureWorkflowController = class {
       fail3("continuation_not_found");
     const matches = [];
     for (const file of this.selectorCandidates()) {
-      const selector = z20.object({
-        schema: z20.literal(SELECTOR_SCHEMA),
+      const selector = z21.object({
+        schema: z21.literal(SELECTOR_SCHEMA),
         checkpointReference: ref7
       }).strict().parse(JSON.parse(readFileSync36(join42(directory, file), "utf8")));
       const state = checkpointSchema.parse(JSON.parse(this.store.read(selector.checkpointReference).content));
@@ -357145,7 +357493,7 @@ var FeatureWorkflowController = class {
       if (card.phase === "implementation" && !card.ownedFiles.some((path7) => failed.verifier.targetPaths.some((target2) => resolve27(this.options.workingDir, path7) === resolve27(this.options.workingDir, target2))))
         fail3("repair_not_failed_verifier_target");
     }
-    const reason = z20.string().trim().min(1).max(4e3).parse(input.reason);
+    const reason = z21.string().trim().min(1).max(4e3).parse(input.reason);
     const affected = /* @__PURE__ */ new Set([card.id]);
     for (const item of compileFeatureWorkflow(plan).cards) {
       const candidate = plan.cards.find((c) => featureWorkflowCardId(plan, c.id) === item.id);
@@ -358162,7 +358510,7 @@ function isSnapshot(value) {
   const owner = record9["owner"];
   const acknowledgements = pending;
   const acknowledgementById = new Map(acknowledgements.map((entry) => [entry.id, entry]));
-  if (acknowledgements.some((entry) => entry.generation !== owner.generation)) {
+  if (acknowledgements.some((entry) => entry.generation > owner.generation || entry.generation < owner.generation && entry.status === "pending")) {
     return false;
   }
   const phase = record9["phase"];
@@ -358233,6 +358581,16 @@ var InterruptionLifecycle = class {
   snapshot() {
     return cloneSnapshot(this.state);
   }
+  /** A retired instance may retry a failed checkpoint only while its exact
+   * durable owner boundary still exists. Never reopen or rewrite a successor. */
+  isCurrentDurableBoundary() {
+    if (this.durabilityUncertain)
+      return false;
+    if (!this.persistEnabled || !this.statePath)
+      return true;
+    const saved = this.load();
+    return !!saved && saved.runId === this.state.runId && saved.sessionId === this.state.sessionId && saved.taskEpoch === this.state.taskEpoch && saved.sequence === this.state.sequence && saved.phase === this.state.phase && JSON.stringify(saved.owner) === JSON.stringify(this.state.owner);
+  }
   /** A post-rename durability failure closes admission until process recovery. */
   get requiresDurabilityRecovery() {
     return this.durabilityUncertain;
@@ -358338,6 +358696,32 @@ var InterruptionLifecycle = class {
     this.transition("paused", this.state.requestedBy, reason, true);
     return this.receipt("pause_acknowledged", true, false, previous, reason);
   }
+  /** Explicit owner handoff, never an acknowledgement of unfinished work. */
+  forcePauseForUpdate(requestedBy, reason = "explicit update retired unfinished owners") {
+    const previous = this.state.phase;
+    if (!["running", "pausing", "paused"].includes(previous) || !this.ownerMatches(requestedBy))
+      return this.receipt("pause_acknowledged", false, false, previous, "Update handoff rejected for a stale owner or terminal run.");
+    this.assertDurabilityCertain();
+    const before = cloneSnapshot(this.state);
+    try {
+      const at = this.timestamp();
+      for (const acknowledgement of this.state.pendingAcknowledgements) {
+        if (acknowledgement.status !== "pending")
+          continue;
+        acknowledgement.status = "timed_out";
+        acknowledgement.acknowledgedAt = at;
+        if (acknowledgement.effect === "external_effect")
+          this.recordAmbiguity(acknowledgement, at);
+      }
+      this.state.owner = { ...this.state.owner, generation: this.state.owner.generation + 1 };
+      this.transition("paused", this.state.owner, reason, true);
+    } catch (error) {
+      if (!persistenceMayHaveCommitted(error))
+        this.state = before;
+      throw error;
+    }
+    return this.receipt("pause_acknowledged", true, false, previous, reason);
+  }
   requestResume(requestedBy, reason = "resume requested") {
     const previous = this.state.phase;
     if (previous === "running" || previous === "resuming") {
@@ -359177,7 +359561,7 @@ function checkDoomLoop(context) {
 // packages/orchestrator/dist/steeringIntake.js
 import { appendFileSync as appendFileSync4, existsSync as existsSync34, mkdirSync as mkdirSync28, readFileSync as readFileSync39 } from "node:fs";
 import { join as join44 } from "node:path";
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 function classifySteeringIntent(content, requestedIntent) {
   void content;
   return requestedIntent ?? "context_only";
@@ -359189,12 +359573,12 @@ function steeringGatesOldPlan(intent) {
   return intent !== "cancel";
 }
 var LEDGER_FILE = "steering-ledger.jsonl";
-var SteeringInterpretationSchema = z21.object({
-  inference: z21.string().trim().min(1),
-  runnerInstruction: z21.string().trim().min(1),
-  conflicts: z21.array(z21.string().trim().min(1)).optional().default([]),
-  alternatives: z21.array(z21.string().trim().min(1)).optional().default([]),
-  memoryNote: z21.string().trim().min(1).optional()
+var SteeringInterpretationSchema = z22.object({
+  inference: z22.string().trim().min(1),
+  runnerInstruction: z22.string().trim().min(1),
+  conflicts: z22.array(z22.string().trim().min(1)).optional().default([]),
+  alternatives: z22.array(z22.string().trim().min(1)).optional().default([]),
+  memoryNote: z22.string().trim().min(1).optional()
 });
 function appendSteeringLedgerEntry(repoRoot, entry) {
   try {
@@ -359207,13 +359591,17 @@ function appendSteeringLedgerEntry(repoRoot, entry) {
 }
 
 // packages/orchestrator/dist/steeringEvidence.js
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 
 // packages/orchestrator/dist/typed-model-output.js
 var STEERING_RECONCILIATION_REGION = "steering_reconciliation";
 var OPEN = "[STEERING_RECONCILIATION";
 var CLOSE = "[/STEERING_RECONCILIATION";
 var RESERVED_INTERNAL_LINE_MARKERS = [
+  "[ADJUDICATION_ARGUMENT_REPAIR]",
+  "[ADJUDICATION_INVALID_REPLAY]",
+  "[HUMAN_RESPONSE_REQUIRED]",
+  "[HUMAN_RESPONSE_TURN_REQUIRED]",
   "[STEERING_RECONCILIATION_REQUIRED]",
   "[STEERING_REPLAN_TURN_REQUIRED]",
   "[STEERING_CLARIFICATION_REQUIRED]",
@@ -359621,38 +360009,38 @@ ${marker}`);
 
 // packages/orchestrator/dist/steeringEvidence.js
 var STEERING_CHECKPOINT_SCHEMA = "omnius.steering-checkpoint.v1";
-var identity = z22.string().min(1).max(500).refine((value) => value === value.trim());
-var epoch = z22.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-var intake = z22.object({
+var identity = z23.string().min(1).max(500).refine((value) => value === value.trim());
+var epoch = z23.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var intake = z23.object({
   inputId: identity,
-  content: z22.string().min(1),
-  source: z22.string().min(1),
-  receivedAt: z22.string().datetime(),
-  intent: z22.enum(["clarify", "append", "context_only", "constraint", "priority_change", "redirect", "replace", "cancel"]),
-  state: z22.enum(["received", "queued", "acknowledged", "visible_in_request", "reconciliation_required", "reconciled", "first_affected_action", "consumed", "superseded", "cancelled"]),
-  allowTaskReplacement: z22.boolean().optional(),
+  content: z23.string().min(1),
+  source: z23.string().min(1),
+  receivedAt: z23.string().datetime(),
+  intent: z23.enum(["clarify", "append", "context_only", "constraint", "priority_change", "redirect", "replace", "cancel"]),
+  state: z23.enum(["received", "queued", "acknowledged", "visible_in_request", "reconciliation_required", "reconciled", "first_affected_action", "consumed", "superseded", "cancelled"]),
+  allowTaskReplacement: z23.boolean().optional(),
   taskEpoch: epoch
 });
-var call = z22.object({
+var call = z23.object({
   id: identity,
   name: identity,
-  arguments: z22.record(z22.string(), z22.unknown()),
-  executionArguments: z22.record(z22.string(), z22.unknown()).optional(),
-  state: z22.enum(["pending", "running", "completed"]),
-  success: z22.boolean().optional()
+  arguments: z23.record(z23.string(), z23.unknown()),
+  executionArguments: z23.record(z23.string(), z23.unknown()).optional(),
+  state: z23.enum(["pending", "running", "completed"]),
+  success: z23.boolean().optional()
 }).refine((value) => value.state === "completed" === (value.success !== void 0));
-var activeSchema = z22.object({
+var activeSchema = z23.object({
   input: intake,
-  relatedInputs: z22.array(intake).max(127).optional(),
+  relatedInputs: z23.array(intake).max(127).optional(),
   historyStartIndex: epoch.optional(),
   appliedTurn: epoch,
-  requiresReconciliation: z22.boolean(),
-  gatesOldPlan: z22.boolean(),
-  visibleRequestTurns: z22.array(epoch),
-  reconciliation: z22.unknown().optional(),
+  requiresReconciliation: z23.boolean(),
+  gatesOldPlan: z23.boolean(),
+  visibleRequestTurns: z23.array(epoch),
+  reconciliation: z23.unknown().optional(),
   reconciledTurn: epoch.optional(),
-  firstAffectedAction: z22.object({ toolName: identity, turn: epoch }).optional(),
-  evidence: z22.object({ phases: z22.number().int().min(1).max(3), calls: z22.array(call).min(1).max(12) }).optional()
+  firstAffectedAction: z23.object({ toolName: identity, turn: epoch }).optional(),
+  evidence: z23.object({ phases: z23.number().int().min(1).max(3), calls: z23.array(call).min(1).max(12) }).optional()
 });
 function isSteeringScopeResolved(active) {
   const decision2 = active.reconciliation;
@@ -359667,7 +360055,7 @@ function renderSteeringReconciliationProtocol(inputId) {
     taskDisposition: "continue"
   });
   return [
-    "Before any tool call, respond with exactly one structured reconciliation and no tool calls in that response:",
+    "First answer the latest user briefly in ordinary visible prose; then include exactly one internal structured reconciliation. Include no tool calls in that response:",
     "[STEERING_RECONCILIATION]",
     template,
     "[/STEERING_RECONCILIATION]",
@@ -359686,14 +360074,14 @@ function steeringEvidenceArgumentsKey(value) {
   return JSON.stringify(value) ?? "undefined";
 }
 function validateSteeringCheckpoint(value, expected) {
-  const parsed = z22.object({
-    schema: z22.literal(STEERING_CHECKPOINT_SCHEMA),
+  const parsed = z23.object({
+    schema: z23.literal(STEERING_CHECKPOINT_SCHEMA),
     runId: identity,
     sessionId: identity,
     taskEpoch: epoch,
     active: activeSchema,
-    goal: z22.string().min(1).max(16e3),
-    messages: z22.array(z22.unknown()).min(1).max(1e5)
+    goal: z23.string().min(1).max(16e3),
+    messages: z23.array(z23.unknown()).min(1).max(1e5)
   }).parse(value);
   if (parsed.runId !== expected.runId || parsed.sessionId !== expected.sessionId || parsed.taskEpoch !== expected.taskEpoch)
     throw new Error("steering_checkpoint_identity_mismatch");
@@ -365409,7 +365797,7 @@ function reconcileShellExecutionOutcome(command, result) {
 }
 
 // packages/orchestrator/dist/agenticRunner.js
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 init_ollama_pool();
 
 // packages/orchestrator/dist/personality.js
@@ -366153,7 +366541,7 @@ function buildPhaseSkillGuidance(input) {
 import { createHash as createHash87 } from "node:crypto";
 import { existsSync as existsSync40, readFileSync as readFileSync46 } from "node:fs";
 import { join as join50 } from "node:path";
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var deliveryRealityStates = [
   "simulation_only",
   "hardware_integrated",
@@ -366169,70 +366557,70 @@ var acceptanceLayers = [
   "hardware_in_loop",
   "documentation"
 ];
-var sourceSchema = z23.object({
-  id: z23.string().min(1),
-  kind: z23.enum(["local_contract", "official_vendor", "third_party", "generated"]),
-  pathOrUrl: z23.string().min(1),
-  revision: z23.string().min(1).optional(),
-  hash: z23.string().min(8).optional()
+var sourceSchema = z24.object({
+  id: z24.string().min(1),
+  kind: z24.enum(["local_contract", "official_vendor", "third_party", "generated"]),
+  pathOrUrl: z24.string().min(1),
+  revision: z24.string().min(1).optional(),
+  hash: z24.string().min(8).optional()
 });
-var contractSchema = z23.object({
-  id: z23.string().min(1),
-  productSeries: z23.string().min(1),
-  sourceId: z23.string().min(1),
-  declaredCommands: z23.array(z23.string().min(1)).default([]),
-  declaredParameters: z23.array(z23.string().min(1)).default([]),
-  declaredModelFormats: z23.array(z23.string().min(1)).default([])
+var contractSchema = z24.object({
+  id: z24.string().min(1),
+  productSeries: z24.string().min(1),
+  sourceId: z24.string().min(1),
+  declaredCommands: z24.array(z24.string().min(1)).default([]),
+  declaredParameters: z24.array(z24.string().min(1)).default([]),
+  declaredModelFormats: z24.array(z24.string().min(1)).default([])
 });
-var acceptanceSchema = z23.object({
-  id: z23.string().min(1),
-  layer: z23.enum(acceptanceLayers),
-  requiredFor: z23.array(z23.enum(deliveryRealityStates)).min(1),
+var acceptanceSchema = z24.object({
+  id: z24.string().min(1),
+  layer: z24.enum(acceptanceLayers),
+  requiredFor: z24.array(z24.enum(deliveryRealityStates)).min(1),
   /** Canonical commands whose successful receipts prove this layer ran. */
-  verificationCommands: z23.array(z23.string().min(1)).min(1),
-  safetyInterlock: z23.string().min(1).optional()
+  verificationCommands: z24.array(z24.string().min(1)).min(1),
+  safetyInterlock: z24.string().min(1).optional()
 });
-var inspectionSchema = z23.object({
-  id: z23.string().min(1),
-  boundary: z23.string().min(1),
-  targetPaths: z23.array(z23.string().min(1)).min(1),
-  proves: z23.string().min(1)
+var inspectionSchema = z24.object({
+  id: z24.string().min(1),
+  boundary: z24.string().min(1),
+  targetPaths: z24.array(z24.string().min(1)).min(1),
+  proves: z24.string().min(1)
 });
-var contradictionCheckSchema = z23.object({
-  id: z23.string().min(1),
-  question: z23.string().min(1),
-  inspectionIds: z23.array(z23.string().min(1)).min(1)
+var contradictionCheckSchema = z24.object({
+  id: z24.string().min(1),
+  question: z24.string().min(1),
+  inspectionIds: z24.array(z24.string().min(1)).min(1)
 });
-var subjectSchema = z23.object({
-  productSeries: z23.string().min(1),
-  commands: z23.array(z23.string().min(1)).default([]),
-  parameters: z23.array(z23.string().min(1)).default([]),
-  modelFormats: z23.array(z23.string().min(1)).default([])
+var subjectSchema = z24.object({
+  productSeries: z24.string().min(1),
+  commands: z24.array(z24.string().min(1)).default([]),
+  parameters: z24.array(z24.string().min(1)).default([]),
+  modelFormats: z24.array(z24.string().min(1)).default([])
 });
-var claimSchema = z23.object({
-  id: z23.string().min(1),
-  subjects: z23.array(subjectSchema).min(1),
-  state: z23.enum(deliveryRealityStates),
-  contractId: z23.string().min(1).optional(),
-  sourceIds: z23.array(z23.string().min(1)).min(1),
-  evidenceIds: z23.array(z23.string().min(1)).default([]),
-  requiredAcceptanceIds: z23.array(z23.string().min(1)).default([]),
+var claimSchema = z24.object({
+  id: z24.string().min(1),
+  subjects: z24.array(subjectSchema).min(1),
+  state: z24.enum(deliveryRealityStates),
+  contractId: z24.string().min(1).optional(),
+  sourceIds: z24.array(z24.string().min(1)).min(1),
+  evidenceIds: z24.array(z24.string().min(1)).default([]),
+  requiredAcceptanceIds: z24.array(z24.string().min(1)).default([]),
   /** Source boundaries that must be freshly read before this claim is true. */
-  requiredInspectionIds: z23.array(z23.string().min(1)).default([]),
+  requiredInspectionIds: z24.array(z24.string().min(1)).default([]),
   /** Falsification checks that must be grounded in those source inspections. */
-  requiredContradictionCheckIds: z23.array(z23.string().min(1)).default([]),
-  blockedReason: z23.string().min(1).optional()
+  requiredContradictionCheckIds: z24.array(z24.string().min(1)).default([]),
+  blockedReason: z24.string().min(1).optional()
 });
-var deliveryCoverageManifestSchema = z23.object({
+var deliveryCoverageManifestSchema = z24.object({
   // Version 1 remains readable for existing workspaces. Version 2 activates
   // claim-driven source inspection and falsification gates.
-  schemaVersion: z23.union([z23.literal(1), z23.literal(2)]),
-  sources: z23.array(sourceSchema),
-  contracts: z23.array(contractSchema),
-  acceptance: z23.array(acceptanceSchema),
-  inspections: z23.array(inspectionSchema).default([]),
-  contradictionChecks: z23.array(contradictionCheckSchema).default([]),
-  claims: z23.array(claimSchema)
+  schemaVersion: z24.union([z24.literal(1), z24.literal(2)]),
+  sources: z24.array(sourceSchema),
+  contracts: z24.array(contractSchema),
+  acceptance: z24.array(acceptanceSchema),
+  inspections: z24.array(inspectionSchema).default([]),
+  contradictionChecks: z24.array(contradictionCheckSchema).default([]),
+  claims: z24.array(claimSchema)
 });
 function canonicalPath(path7) {
   return String(path7 ?? "").trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
@@ -388296,6 +388684,10 @@ var AgenticRunner = class _AgenticRunner {
    */
   _immediateSteeringWakeInputId = null;
   _steeringSequence = 0;
+  /** Explicit foreground human input is answered before optional advice/actions. */
+  _pendingSteeringReply = null;
+  _steeringReplyTurn = null;
+  _adjudicationArgumentRepair = null;
   _taskEpoch = 0;
   _exclusiveTaskOwner = null;
   _hasStartedTask = false;
@@ -388357,6 +388749,15 @@ var AgenticRunner = class _AgenticRunner {
   _inputWaitSequence = 0;
   _inputWaitPauseReceipt = null;
   _inputWaitBoundaryController = new AbortController();
+  _updateAbortController = new AbortController();
+  _updateRestartCheckpointForced = false;
+  _updateRestartOwnerRevoked = false;
+  _updateRestartCheckpointSaved = false;
+  _updateCheckpointWriteAuthorized = false;
+  _forcedUpdateRequirementRecoveryHandler;
+  _forcedUpdateRequirementRecoveryApplied;
+  _forcedUpdateRequirementRecoveryPending;
+  _forcedUpdateRequirementTaskReplaced = false;
   _interruptionMessages = null;
   _interruptionToolCallLog = null;
   _interruptionExplicitGoal = "";
@@ -388470,6 +388871,8 @@ var AgenticRunner = class _AgenticRunner {
   _desktopVerificationObservation = null;
   _desktopVerificationPending = null;
   _trajectoryGeneratedGrounding = null;
+  _trajectoryGroundingRequest = null;
+  _virtualContextRequest = null;
   _taskWorkOperationBindings = /* @__PURE__ */ new Map();
   _taskWorkDispatchUnits = /* @__PURE__ */ new Map();
   // -- File State Registry (SWE-agent inspired) --
@@ -392946,7 +393349,7 @@ ${read.content}`;
       request.maxTokens = Math.min(outputIntent, configuredCeiling);
     }
     const steering = this._activeSteering;
-    const maskSteeringTools = Boolean(steering?.input.taskEpoch === this._taskEpoch && steering.gatesOldPlan && steering.requiresReconciliation && !steering.reconciliation && this._requestCarriesCurrentSteering(request, steering));
+    const maskSteeringTools = Boolean(this._currentSteeringReplyPending() || steering?.input.taskEpoch === this._taskEpoch && steering.gatesOldPlan && steering.requiresReconciliation && !steering.reconciliation && this._requestCarriesCurrentSteering(request, steering));
     const contracts = JSON.stringify([...this._canonicalToolExposureContracts]);
     let toolIntent = this._contextAdmissionToolIntents.get(request);
     if (toolIntent && (toolIntent.runId !== this._activeRunId || toolIntent.taskEpoch !== this._taskEpoch || toolIntent.contracts !== contracts || toolIntent.registry.some((entry) => this.tools.get(entry.name) !== entry.tool))) {
@@ -393525,6 +393928,15 @@ ${read.content}`;
         });
       }
     }
+    const argumentRepair = this._currentAdjudicationArgumentRepair(turn);
+    if (argumentRepair)
+      latest.set("adjudication-argument-repair", {
+        slot: "next_action",
+        source: "runtime.adjudication-argument-repair",
+        priority: 100,
+        protection: ["active_requirement"],
+        content: this._adjudicationArgumentRepairGuidance(argumentRepair)
+      });
     return [...latest.entries()].map(([id5, signal]) => ({
       id: `canonical-late:${id5}`,
       slot: signal.slot,
@@ -394628,7 +395040,7 @@ ${read.content}`;
     const kind = admittedMediaEvidenceRead ? "read_tool" : this.interruptionToolKind(tool, readOnly);
     const ticket = this._interruptionLifecycle?.registerOperation({
       kind,
-      effect: readOnly ? "read_only" : "external_effect",
+      effect: tool.interruptionEffect ?? (readOnly ? "read_only" : "external_effect"),
       ownerId: `tool:${name}`
     });
     if (this._interruptionLifecycle && !ticket) {
@@ -394668,10 +395080,18 @@ ${read.content}`;
     let workflowTicket;
     let uiInvocationActive = false;
     const desktopScope = this._objectiveRecoveryScope(), desktopController = this._turnAbortController;
+    const cognitionSignal = ticket?.effect === "read_only" && ticket.kind === "background_cognition" ? this._inputWaitBoundaryController.signal : void 0;
     try {
       const corpusReadAllocation = this._allocateCorpusRead(tool, name, args);
       let invocation = tool.acceptsInvocationContext === true ? {
-        signal: this._turnAbortController.signal,
+        signal: AbortSignal.any([this._turnAbortController.signal, this._updateAbortController.signal, ...cognitionSignal ? [cognitionSignal] : []]),
+        assertCurrent: () => {
+          if (cognitionSignal?.aborted)
+            throw new InputWaitInterruption();
+          if (this._updateRestartCheckpointForced || ticket && !this._interruptionLifecycle?.canCommit(ticket))
+            throw new InputWaitInterruption();
+          assertDispatchScope?.();
+        },
         ...corpusReadAllocation ? { corpusReadAllocation } : {},
         ...objectiveEffectIntent ? { objectiveEffectIntent } : {},
         elevationPolicy: {
@@ -394690,7 +395110,14 @@ ${read.content}`;
       if (workflowAdmission && ticket && this._featureWorkflow) {
         workflowTicket = this._featureWorkflow.admit(workflowAdmission, ticket, name, args);
         invocation = {
-          signal: this._turnAbortController.signal,
+          signal: AbortSignal.any([this._turnAbortController.signal, this._updateAbortController.signal, ...cognitionSignal ? [cognitionSignal] : []]),
+          assertCurrent: () => {
+            if (cognitionSignal?.aborted)
+              throw new InputWaitInterruption();
+            if (this._updateRestartCheckpointForced || ticket && !this._interruptionLifecycle?.canCommit(ticket))
+              throw new InputWaitInterruption();
+            assertDispatchScope?.();
+          },
           ...objectiveEffectIntent ? { objectiveEffectIntent } : {},
           elevationPolicy: {
             mode: this.options.surface === "tui" ? "native" : "deny",
@@ -394760,12 +395187,18 @@ ${read.content}`;
       };
     } finally {
       uiInvocationActive = false;
-      if (ticket) {
-        this._interruptionLifecycle?.acknowledgeOperation(ticket, this.aborted ? "unknown" : "completed");
+      if (ticket && !this._updateRestartCheckpointForced) {
+        const unknown = this.aborted || this._updateAbortController.signal.aborted && ticket.effect === "external_effect";
+        this._interruptionLifecycle?.acknowledgeOperation(ticket, unknown ? "unknown" : "completed");
         if (!progressOnly)
-          this._transitionTaskWorkOperation(ticket.id, this.aborted ? "unknown" : "settled");
+          this._transitionTaskWorkOperation(ticket.id, unknown ? "unknown" : "settled");
       }
     }
+    if (this._updateRestartCheckpointForced) {
+      if (!this.aborted)
+        await new Promise((resolve42) => this._pauseWaiters.add(resolve42));
+      throw new InputWaitInterruption();
+    }
     if (pendingObjectiveEffect && !normalizeExternalEffectReceiptV1(result.externalEffectReceipt)) {
       result = {
         ...result,
@@ -396469,6 +396902,8 @@ Use exact start_char/end_char or start_line/end_line ranges, or query/resume_sou
     }
   }
   _saveCompletionLedgerSafe() {
+    if (this._updateRestartCheckpointForced && !this._updateCheckpointWriteAuthorized)
+      return false;
     if (!this._completionLedger)
       return true;
     if (!this.writesUserTaskArtifacts() && !this._completionLedger.objectiveContract)
@@ -396739,6 +397174,52 @@ ${content}`)].join("\n\n");
   _hasUnresolvedCurrentSteeringInputs() {
     return this._nativeRequirementInterpretationHolds.size > 0 || this.pendingSteeringInputs.some((input) => (input.taskEpoch === void 0 || input.taskEpoch === this._taskEpoch) && (input.state === "received" || input.state === "queued" || input.state === "acknowledged" || input.state === "visible_in_request" || input.state === "reconciliation_required"));
   }
+  _currentSteeringReplyPending() {
+    const pending = this._pendingSteeringReply;
+    return pending && pending.runId === this.currentArtifactRunId() && pending.ownerId === this._interruptionOwnerId && pending.input.taskEpoch === this._taskEpoch && !pending.input.humanResponse && !["cancelled", "superseded", "consumed"].includes(pending.input.state) ? pending : null;
+  }
+  _adjudicationArgumentRepairIsCurrent(repair) {
+    const tool = this.lookupRegisteredTool(ADJUDICATION_TOOL_NAME)?.tool;
+    return repair.runId === this.currentArtifactRunId() && repair.taskEpoch === this._taskEpoch && repair.ownerId === this._interruptionOwnerId && repair.tool === tool && repair.schema === tool?.inputSchema && repair.parameters === JSON.stringify(tool?.parameters);
+  }
+  _currentAdjudicationArgumentRepair(turn) {
+    const repair = this._adjudicationArgumentRepair;
+    return repair && this._adjudicationArgumentRepairIsCurrent(repair) && (turn === void 0 || repair.settled && turn === repair.turn + 1) ? repair : null;
+  }
+  _adjudicationArgumentRepairGuidance(repair) {
+    return (repair.repeats ? "[ADJUDICATION_INVALID_REPLAY] Identical known-invalid arguments were refused without execution. Correct the named values before retrying.\n" : "") + formatAdjudicationArgumentRepair(repair.error, repair.contract.args_sha256);
+  }
+  _observePrimarySteeringReply(content, turn, emitMixedReply = false) {
+    const pending = this._currentSteeringReplyPending();
+    const visible = content ? partitionTypedModelOutput(content).visibleText.trim() : "";
+    let fence2;
+    const hasProse = visible.split(/\r?\n/).some((line) => {
+      const boundary2 = /^\s*(`{3,}|~{3,})(.*)$/.exec(line);
+      if (boundary2) {
+        if (!fence2)
+          fence2 = { marker: boundary2[1][0], length: boundary2[1].length };
+        else if (boundary2[1][0] === fence2.marker && boundary2[1].length >= fence2.length && !boundary2[2].trim())
+          fence2 = void 0;
+        return false;
+      }
+      return !fence2 && Boolean(line.trim());
+    });
+    const carried = Boolean(pending?.visibleRequestTurns.includes(turn));
+    const active = this._activeSteering;
+    if (emitMixedReply && hasProse && (carried || active?.input.taskEpoch === this._taskEpoch && active.requiresReconciliation && active.visibleRequestTurns.includes(turn))) {
+      this.emit({ type: "assistant_text", content: visible, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      this._assistantTextEmitted = true;
+    }
+    if (carried && hasProse) {
+      this._pendingSteeringReply = null;
+      this._steeringReplyTurn = {
+        runId: this.currentArtifactRunId(),
+        taskEpoch: this._taskEpoch,
+        ownerId: this._interruptionOwnerId,
+        turn
+      };
+    }
+  }
   _objectiveReadBatchAuxiliaryEligible() {
     const continuation = this._objectiveReadBatchContinuation;
     const batch = this.options.objectiveReadBatch;
@@ -396827,6 +397308,8 @@ ${content}`)].join("\n\n");
     const configuredPinnedBudget = this.options.virtualContext?.pinnedMemoryTokenBudget;
     const pinnedTokenBudget = Math.max(0, Math.min(physicalInputBudget, Number.isFinite(configuredPinnedBudget) && (configuredPinnedBudget ?? 0) > 0 ? Math.floor(configuredPinnedBudget) : adaptiveBudget.pinnedState));
     const pinnedMessages = this._pinnedStructuredMemoryMessages(pinnedTokenBudget, physicalInputBudget, turn);
+    if (this._currentAdjudicationArgumentRepair(turn) || this._currentSteeringReplyPending() || this._hasUnresolvedCurrentSteeringInputs())
+      return pinnedMessages;
     const residentInputTokens = estimateConservativeRequestInputTokens({
       messages: messages2.map((message) => ({ ...message })),
       tools,
@@ -396935,11 +397418,34 @@ ${content}`)].join("\n\n");
         }))
       ];
     }
+    const projectionRequest = {
+      controller: new AbortController(),
+      runId: this.currentArtifactRunId(),
+      taskEpoch: this._taskEpoch,
+      ownerId: this._interruptionOwnerId,
+      generation: this._modelRequestGeneration
+    };
+    this._virtualContextRequest = projectionRequest;
+    const signal = AbortSignal.any([
+      projectionRequest.controller.signal,
+      this._abortController.signal,
+      this._turnAbortController.signal,
+      this._inputWaitBoundaryController.signal
+    ]);
+    const isCurrent = () => !signal.aborted && this._virtualContextRequest === projectionRequest && projectionRequest.runId === this.currentArtifactRunId() && projectionRequest.taskEpoch === this._taskEpoch && projectionRequest.ownerId === this._interruptionOwnerId && projectionRequest.generation === this._modelRequestGeneration;
+    const assertCurrent = () => {
+      if (!isCurrent())
+        throw new InputWaitInterruption();
+    };
     try {
       const timeoutMs = this.options.requestTimeoutMs === 0 ? 0 : Number.isFinite(this.options.requestTimeoutMs) && (this.options.requestTimeoutMs ?? 0) > 0 ? this.options.requestTimeoutMs : 3e5;
-      const projection = await buildLiveVirtualContextProjection({
+      assertCurrent();
+      const projection = await withInputWaitCancellation(signal, () => buildLiveVirtualContextProjection({
         store,
-        archiveDocument: (document) => this._archiveVirtualEvidenceDocument(document),
+        archiveDocument: (document) => {
+          assertCurrent();
+          return this._archiveVirtualEvidenceDocument(document);
+        },
         ...this._structuredMemoryStore ? { memoryStore: this._structuredMemoryStore } : {},
         query,
         scopeId: this._sessionId,
@@ -396952,9 +397458,11 @@ ${content}`)].join("\n\n");
         auxiliaryContextWindowTokens: physicalWindow,
         auxiliaryMaxOutputTokens: this._explicitGenerationMaxTokens || this.options.maxTokens !== 16384 ? this._generationOutputCeiling() : void 0,
         maxRetrievalRounds: this.options.virtualContext?.maxRetrievalRounds,
-        signal: this._turnAbortController.signal,
+        signal,
         requestTimeoutMs: timeoutMs > 0 ? Math.min(timeoutMs, 3e4) : 3e4,
         onTrace: (event) => {
+          if (!isCurrent())
+            return;
           this._recordLiveVirtualContextTrace(event, turn);
           this.emit({
             type: "status",
@@ -396965,9 +397473,11 @@ ${content}`)].join("\n\n");
           });
         },
         infer: async (request) => {
+          assertCurrent();
           this._emitModelResolutionTelemetry(`virtual_memory_${request.stage}`, turn);
-          const response = await this._auxInferenceBackend({
-            dumpStage: `virtual_memory_${request.stage}`
+          const response = await withInputWaitCancellation(request.signal, () => this._auxInferenceBackend({
+            dumpStage: `virtual_memory_${request.stage}`,
+            assertCurrent
           }).chatCompletion({
             messages: [
               { role: "system", content: request.system },
@@ -396981,10 +397491,12 @@ ${content}`)].join("\n\n");
             think: false,
             workloadClass: this.options.workloadClass,
             logicalRequestId: this._modelTurnRequestId(turn, `virtual-memory:${request.stage}`)
-          });
+          }));
+          assertCurrent();
           return response.choices?.[0]?.message?.content ?? "";
         }
-      });
+      }));
+      assertCurrent();
       this._liveVirtualContextAttempt = { semanticKey, turn };
       if (!projection)
         return pinnedMessages;
@@ -397011,6 +397523,8 @@ ${content}`)].join("\n\n");
         }))
       ];
     } catch (error) {
+      if (!isCurrent() || error instanceof InputWaitInterruption)
+        return pinnedMessages;
       if (this._turnAbortController.signal.aborted)
         throw error;
       this._liveVirtualContextAttempt = { semanticKey, turn };
@@ -397022,6 +397536,9 @@ ${content}`)].join("\n\n");
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       return pinnedMessages;
+    } finally {
+      if (this._virtualContextRequest === projectionRequest)
+        this._virtualContextRequest = null;
     }
   }
   _pinnedStructuredMemoryMessages(defaultTokenBudget, physicalInputBudget, turn) {
@@ -397774,49 +398291,59 @@ ${currentIntent.trim().slice(0, 6e3)}`,
     const b = this.backend;
     return {
       chatCompletion: async (req) => {
-        const r = {
-          ...req,
-          responseFormat: req.responseFormat ?? { type: "json_object" }
-        };
-        const explicitAuxiliaryCap = this._explicitGenerationMaxTokens || this.options.maxTokens !== 16384 ? this._generationOutputCeiling() : void 0;
-        const desired = auxiliaryOutputBudget({
-          request: r,
-          explicitMaxOutputTokens: explicitAuxiliaryCap
-        }).maxTokens;
-        let allocated = auxiliaryOutputBudget({
-          request: r,
-          contextWindowTokens: this._contextAdmissionLimit(r).limit,
-          explicitMaxOutputTokens: this._explicitGenerationMaxTokens || this.options.maxTokens !== 16384 ? this._generationOutputCeiling() : void 0
-        });
-        if (allocated.maxTokens < desired && b.prepareContextCapacity) {
-          const priorFloor = r.minimumOutputReservation;
-          r.maxTokens = desired;
-          r.minimumOutputReservation = Math.min(4096, desired);
-          if (await this._prepareRequestContextCapacity(r, b, opts?.assertCurrent))
-            allocated = auxiliaryOutputBudget({
-              request: r,
-              contextWindowTokens: this._contextAdmissionLimit(r).limit,
-              explicitMaxOutputTokens: explicitAuxiliaryCap
-            });
-          else
-            r.minimumOutputReservation = priorFloor;
-        }
-        if (allocated.maxTokens <= 0)
-          throw Object.assign(new Error("auxiliary_output_capacity_unavailable"), { code: "context_admission_failed" });
-        r.maxTokens = allocated.maxTokens;
-        if (!opts?.suppressContextDump) {
-          recordContextWindowDump({
-            source: "agenticRunner",
-            stage: opts?.dumpStage ?? "aux_inference",
-            agentType: "internal",
-            sessionId: this._sessionId,
-            runId: this._workboardRunId(),
-            model: this._backendModelLabel(this.backend),
-            cwd: this._workingDirectory || process.cwd(),
-            request: r
+        const signal = AbortSignal.any([
+          this._abortController.signal,
+          this._turnAbortController.signal,
+          this._inputWaitBoundaryController.signal,
+          this._updateAbortController.signal,
+          ...req.signal ? [req.signal] : []
+        ]);
+        return withInputWaitCancellation(signal, async () => {
+          const r = {
+            ...req,
+            signal,
+            responseFormat: req.responseFormat ?? { type: "json_object" }
+          };
+          const explicitAuxiliaryCap = this._explicitGenerationMaxTokens || this.options.maxTokens !== 16384 ? this._generationOutputCeiling() : void 0;
+          const desired = auxiliaryOutputBudget({
+            request: r,
+            explicitMaxOutputTokens: explicitAuxiliaryCap
+          }).maxTokens;
+          let allocated = auxiliaryOutputBudget({
+            request: r,
+            contextWindowTokens: this._contextAdmissionLimit(r).limit,
+            explicitMaxOutputTokens: this._explicitGenerationMaxTokens || this.options.maxTokens !== 16384 ? this._generationOutputCeiling() : void 0
           });
-        }
-        return this._dispatchInterruptionOwnedModelRequest(b, r, `model:aux:${opts?.dumpStage ?? "aux_inference"}`, { assertCurrent: opts?.assertCurrent });
+          if (allocated.maxTokens < desired && b.prepareContextCapacity) {
+            const priorFloor = r.minimumOutputReservation;
+            r.maxTokens = desired;
+            r.minimumOutputReservation = Math.min(4096, desired);
+            if (await this._prepareRequestContextCapacity(r, b, opts?.assertCurrent))
+              allocated = auxiliaryOutputBudget({
+                request: r,
+                contextWindowTokens: this._contextAdmissionLimit(r).limit,
+                explicitMaxOutputTokens: explicitAuxiliaryCap
+              });
+            else
+              r.minimumOutputReservation = priorFloor;
+          }
+          if (allocated.maxTokens <= 0)
+            throw Object.assign(new Error("auxiliary_output_capacity_unavailable"), { code: "context_admission_failed" });
+          r.maxTokens = allocated.maxTokens;
+          if (!opts?.suppressContextDump) {
+            recordContextWindowDump({
+              source: "agenticRunner",
+              stage: opts?.dumpStage ?? "aux_inference",
+              agentType: "internal",
+              sessionId: this._sessionId,
+              runId: this._workboardRunId(),
+              model: this._backendModelLabel(this.backend),
+              cwd: this._workingDirectory || process.cwd(),
+              request: r
+            });
+          }
+          return this._dispatchInterruptionOwnedModelRequest(b, r, `model:aux:${opts?.dumpStage ?? "aux_inference"}`, { assertCurrent: opts?.assertCurrent, signal: r.signal });
+        });
       }
     };
   }
@@ -400166,12 +400693,12 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
     if (!candidate)
       return { quality: "not_candidate", summary: "not a validation command" };
     if (!commandReliablySatisfiesVerifyCommand(command, command, result.executionReceipt)) {
-      const shape2 = describeUntrustedVerificationCommand(command, result.executionReceipt);
+      const shape3 = describeUntrustedVerificationCommand(command, result.executionReceipt);
       return {
         quality: "rejected_untrusted",
-        summary: `validation command is not receipt-authoritative: ${shape2}`,
-        reason: `Repair the execution shape: ${shape2}.`,
-        nextAction: `Run the canonical validation with a receipt-authoritative shape; current issue: ${shape2}.`
+        summary: `validation command is not receipt-authoritative: ${shape3}`,
+        reason: `Repair the execution shape: ${shape3}.`,
+        nextAction: `Run the canonical validation with a receipt-authoritative shape; current issue: ${shape3}.`
       };
     }
     if (result.success !== true) {
@@ -405802,7 +406329,16 @@ ${findingsBody}`;
     }
     return null;
   }
-  buildToolArgumentRepairFeedback(toolName, args, tool, validationError) {
+  buildToolArgumentRepairFeedback(toolName, args, tool, validationError, admittedRepair) {
+    if (tool.name === ADJUDICATION_TOOL_NAME) {
+      const argsKey = this._buildExactArgsKey(args);
+      const candidate = admittedRepair ?? this._currentAdjudicationArgumentRepair();
+      const repair = candidate && this._adjudicationArgumentRepairIsCurrent(candidate) && candidate.argsKey === argsKey ? candidate : null;
+      const guidance = repair ? this._adjudicationArgumentRepairGuidance(repair) : formatAdjudicationArgumentRepair(validationError, _createHash("sha256").update(argsKey).digest("hex"));
+      const message = `Invalid arguments for ${toolName}.
+${guidance}`;
+      return { error: message, llmContent: message, systemGuidance: guidance };
+    }
     const parameters = tool.parameters ?? {};
     const props = this.schemaProperties(parameters);
     const required = this.schemaRequired(parameters);
@@ -406002,28 +406538,12 @@ ${findingsBody}`;
     return corrected;
   }
   findSiblingToolSchemaMatches(requestedToolName, providedKeys) {
-    if (providedKeys.length === 0)
-      return [];
-    const provided = new Set(providedKeys);
-    const matches = [];
-    for (const candidate of this.tools.values()) {
-      if (candidate.name === requestedToolName)
-        continue;
-      const props = this.schemaProperties(candidate.parameters ?? {});
-      if (props.size === 0)
-        continue;
-      const required = this.schemaRequired(candidate.parameters ?? {});
-      const matched = providedKeys.filter((key) => props.has(key)).length;
-      if (matched === 0)
-        continue;
-      const requiredPresent = required.filter((key) => provided.has(key)).length;
-      const requiredSatisfied = required.length === 0 || requiredPresent === required.length;
-      const score = matched * 2 + requiredPresent * 3 + (requiredSatisfied ? 3 : 0) - Math.max(0, required.length - requiredPresent);
-      if (score >= 5 || matched >= 2 && requiredSatisfied) {
-        matches.push({ name: candidate.name, score });
-      }
-    }
-    return matches.sort((a, b) => b.score - a.score).slice(0, 3).map((match2) => match2.name);
+    return findBetterToolSchemaMatches({
+      requestedToolName,
+      requestedParameters: this.lookupRegisteredTool(requestedToolName)?.tool.parameters ?? {},
+      providedKeys,
+      candidates: this.tools.values()
+    });
   }
   unknownToolError(name) {
     const names = Array.from(this.tools.values()).map((tool) => tool.aliases?.length ? `${tool.name} (aliases: ${tool.aliases.join("|")})` : tool.name).sort();
@@ -406416,6 +406936,8 @@ ${notice}`;
    * active turn, which closes the old bridge-to-runner message-loss race.
    */
   injectSteeringInput(input) {
+    if (this._updateRestartCheckpointForced)
+      throw new Error("This runner was retired for update; retain input for the replacement process.");
     const now2 = (/* @__PURE__ */ new Date()).toISOString();
     const content = this.scrubUserInput(input.content, "steering-input").trim();
     const record9 = {
@@ -406428,6 +406950,7 @@ ${notice}`;
       state: "received",
       taskEpoch: input.taskEpoch ?? (this._taskEpoch || void 0)
     };
+    delete record9.humanResponse;
     this.pendingSteeringInputs.push(record9);
     this._emitSteeringLifecycle(record9, "received by runner");
     if (!content || record9.allowTaskReplacement === false && (record9.intent === "replace" || record9.intent === "redirect")) {
@@ -406435,6 +406958,14 @@ ${notice}`;
       this._emitSteeringLifecycle(record9, !content ? "empty steering input rejected" : "replacement exceeds host intake authority");
       return this._steeringReceipt(record9);
     }
+    if ((record9.source === "tui-work-intake" || record9.source === "tui") && record9.intent !== "cancel") {
+      this._pendingSteeringReply = {
+        input: record9,
+        runId: this.currentArtifactRunId(),
+        ownerId: this._interruptionOwnerId,
+        visibleRequestTurns: []
+      };
+    }
     record9.state = "queued";
     this._emitSteeringLifecycle(record9, "queued for next safe turn boundary");
     if (steeringGatesOldPlan(record9.intent)) {
@@ -406444,8 +406975,82 @@ ${notice}`;
       this._requestSteeringPreemption(record9);
     }
     this._trajectoryDirtyCauses.add("user_steering");
+    const grounding = this._trajectoryGroundingRequest;
+    if (grounding?.runId === this.currentArtifactRunId() && grounding.taskEpoch === this._taskEpoch) {
+      grounding.controller.abort(new InputWaitInterruption());
+    }
+    const projection = this._virtualContextRequest;
+    if (projection?.runId === this.currentArtifactRunId() && projection.taskEpoch === this._taskEpoch && projection.ownerId === this._interruptionOwnerId)
+      projection.controller.abort(new InputWaitInterruption());
     return this._steeringReceipt(record9);
   }
+  /** A small communication snapshot, independent of atomic tool completion.
+   * The full input remains in the ordinary steering and reconciliation path. */
+  captureSteeringReply(inputId) {
+    const pending = this._currentSteeringReplyPending();
+    if (!pending || pending.input.inputId !== inputId || this.aborted || this._updateAbortController.signal.aborted)
+      return null;
+    const state = this.interruptionState;
+    if (state && ["stopping", "stopped", "failed", "completed"].includes(state.phase))
+      return null;
+    const input = pending.input;
+    const excerpt = (text13, limit2) => {
+      if (Buffer.byteLength(text13, "utf8") <= limit2)
+        return text13;
+      let size = Math.max(1, limit2 - 100), result;
+      do {
+        result = `${text13.slice(0, Math.floor(size * 0.7))}
+[Excerpt; remaining text is retained for the main task.]
+${text13.slice(-Math.max(1, Math.floor(size * 0.3)))}`;
+        size = Math.floor(size * 0.7);
+      } while (size > 0 && Buffer.byteLength(result, "utf8") > limit2);
+      return result;
+    };
+    const recent = (this._interruptionMessages ?? []).filter((message) => message.role !== "system" && typeof message.content === "string").slice(-4).map((message) => ({ role: message.role, text: excerpt(partitionTypedModelOutput(message.content).visibleText, 600) }));
+    return {
+      inputId,
+      runId: this.currentArtifactRunId(),
+      taskEpoch: this._taskEpoch,
+      ownerGeneration: state?.owner.generation ?? 0,
+      inputSha256: _createHash("sha256").update(input.content).digest("hex"),
+      turn: this._currentSteeringTurn,
+      contextWindowTokens: Math.min(8192, this.effectiveContextWindow() || 8192),
+      messages: [
+        { role: "system", content: "Respond directly to the latest user input in one or two concise sentences. This is the ongoing conversation, not a new task. Answer questions using only the supplied observations; distinguish intentions from completed work. For a requested change, state its concrete effect or what you will do next. Keep the existing objective unless the user changes it. Do not call tools, plan, reconcile authority, describe internal processing, or claim actions have run. Do not invent facts missing from this compact snapshot. The full input and task will be reconciled separately after this reply." },
+        { role: "user", content: JSON.stringify({
+          originalObjective: excerpt(this._taskState.originalGoal || this._taskState.goal || "", 1400),
+          constraints: (this._taskState.steeringConstraints ?? []).slice(-8).map((value) => excerpt(value, 240)),
+          recentObservations: recent,
+          priorAcceptedInputs: this.pendingSteeringInputs.filter((prior) => prior.inputId !== inputId && prior.taskEpoch === this._taskEpoch && !["cancelled", "superseded", "consumed"].includes(prior.state)).slice(-6).map((prior) => ({ inputId: prior.inputId, text: excerpt(prior.content, 480) })),
+          runningOperations: (state?.pendingAcknowledgements ?? []).filter((item) => item.status === "pending").slice(0, 6).map((item) => ({ kind: item.kind, owner: item.ownerId })),
+          latestInput: excerpt(input.content, 8e3),
+          latestInputExcerpted: Buffer.byteLength(input.content, "utf8") > 8e3
+        }) }
+      ]
+    };
+  }
+  isSteeringReplyCurrent(packet2) {
+    const pending = this._currentSteeringReplyPending(), state = this.interruptionState;
+    return !this.aborted && !this._updateRestartCheckpointForced && !this._updateAbortController.signal.aborted && !!pending && pending.input.inputId === packet2.inputId && this.currentArtifactRunId() === packet2.runId && this._taskEpoch === packet2.taskEpoch && (state?.owner.generation ?? 0) === packet2.ownerGeneration && (!state || !["stopping", "stopped", "failed", "completed"].includes(state.phase)) && _createHash("sha256").update(pending.input.content).digest("hex") === packet2.inputSha256;
+  }
+  /** Record real visible prose without satisfying the internal scope gate. */
+  recordSteeringReply(packet2, content) {
+    if (!this.isSteeringReplyCurrent(packet2))
+      return false;
+    const visible = partitionTypedModelOutput(content).visibleText.trim();
+    if (!visible)
+      return false;
+    const input = this._pendingSteeringReply.input;
+    input.humanResponse = { content: visible, deliveredAt: (/* @__PURE__ */ new Date()).toISOString(), inputSha256: packet2.inputSha256 };
+    try {
+      this._emitSteeringLifecycle(input, "visible model reply delivered; objective reconciliation remains pending");
+    } catch (error) {
+      delete input.humanResponse;
+      throw error;
+    }
+    this._pendingSteeringReply = null;
+    return true;
+  }
   /**
    * Request safe-boundary preemption for an already accepted typed input.
    * Frontends use this after delivery so cancellation reaches an in-flight
@@ -406773,7 +407378,7 @@ ${notice}`;
     hold2.wake();
   }
   get taskRequirementInterpretationPending() {
-    return this._nativeRequirementInterpretationHolds.size > 0 || this._pendingNativeRequirementAmendments.size > 0;
+    return this._nativeRequirementInterpretationHolds.size > 0 || this._pendingNativeRequirementAmendments.size > 0 || !!(this._forcedUpdateRequirementRecoveryPending?.requirementHolds.length || this._forcedUpdateRequirementRecoveryPending?.requirementAmendments.length);
   }
   /** Host-only authenticated new human instruction; existing steering gates remain authoritative. */
   queueNativeTaskRequirementAmendment(authority) {
@@ -407302,10 +407907,22 @@ The previous reviewer response failed exact candidate-quote serialization. Host
       this._pendingSteeringPreemption = null;
     }
     this._emitSteeringLifecycle(record9, "retracted before admission at a safe boundary");
+    if (this._activeSteering) {
+      this._activeSteering.relatedInputs = this._activeSteering.relatedInputs?.filter((input) => input !== record9);
+      if (this._activeSteering.input === record9 && !this._activeSteering.relatedInputs?.length)
+        this._activeSteering = null;
+    }
     return record9.content;
   }
   /** Abort the current task run through the generation-bound stop lineage. */
   abort() {
+    if (this._updateRestartCheckpointForced) {
+      this.aborted = true;
+      this._abortController.abort();
+      this._turnAbortController.abort();
+      this._releasePauseWaiters();
+      return null;
+    }
     const transition = this._interruptionLifecycle?.requestStop(this._interruptionLifecycle.snapshot().owner, "runner abort requested") ?? null;
     if (transition && !transition.accepted)
       return transition;
@@ -408014,6 +408631,8 @@ issuer=${predecessor.runId}; evidence=${receipt.id}; raw_ref=${receipt.rawRef ??
     }
   }
   _emitSteeringLifecycle(record9, reason) {
+    if (this._updateRestartCheckpointForced)
+      return;
     const receipt = this._steeringReceipt(record9);
     const reconciliation = this._activeSteering && [
       this._activeSteering.input,
@@ -408282,6 +408901,16 @@ issuer=${predecessor.runId}; evidence=${receipt.id}; raw_ref=${receipt.rawRef ??
   }
   async _drainPendingSteeringMessages(messages2, turn) {
     this.drainPendingRuntimeGuidance(turn);
+    const appendReply = (record9) => {
+      const reply = record9.humanResponse;
+      if (!reply || reply.materialized || record9.taskEpoch !== this._taskEpoch || ["cancelled", "superseded"].includes(record9.state) || reply.inputSha256 !== _createHash("sha256").update(record9.content).digest("hex") || !messages2.some((message) => message.role === "user" && message.content === record9.content))
+        return;
+      messages2.push({ role: "assistant", content: reply.content, taskEpoch: this._taskEpoch });
+      reply.materialized = true;
+    };
+    for (const record9 of this.pendingSteeringInputs)
+      if (record9.state !== "queued" && record9.state !== "acknowledged")
+        appendReply(record9);
     const pending = this.pendingSteeringInputs.filter((record9) => (record9.state === "queued" || record9.state === "acknowledged") && (!record9.taskEpoch || record9.taskEpoch === this._taskEpoch));
     for (const record9 of pending) {
       const replacement = this._pendingSteeringPreemption;
@@ -408294,6 +408923,7 @@ issuer=${predecessor.runId}; evidence=${receipt.id}; raw_ref=${receipt.rawRef ??
       const historyStart = messages2.length;
       await this.appendInjectedUserMessage(record9.content, messages2, turn);
       this._activateSteering(record9, turn);
+      appendReply(record9);
       if (this._immediateSteeringWakeInputId === record9.inputId) {
         this._immediateSteeringWakeInputId = null;
       }
@@ -408306,6 +408936,8 @@ issuer=${predecessor.runId}; evidence=${receipt.id}; raw_ref=${receipt.rawRef ??
       if (record9)
         this._applyNativeTaskRequirementAmendmentAtBoundary(record9);
     }
+    for (const record9 of this.pendingSteeringInputs)
+      appendReply(record9);
     while (this.pendingUserMessages.length > 0) {
       await this.appendInjectedUserMessage(this.pendingUserMessages.shift(), messages2, turn);
     }
@@ -408769,9 +409401,10 @@ issuer=${predecessor.runId}; evidence=${receipt.id}; raw_ref=${receipt.rawRef ??
     if (!active)
       return null;
     const { input, reconciliation } = active;
-    if (isSteeringScopeResolved(active))
+    if (isSteeringScopeResolved(active) && !this._currentSteeringReplyPending())
       return null;
     const sources = [input, ...active.relatedInputs ?? []];
+    const humanResponse = [...sources].reverse().find((source) => source.humanResponse)?.humanResponse;
     const exactSourcesPresent = this.effectiveContextWindow() > 0 && this.effectiveContextWindow() <= 8192 && input.taskEpoch === this._taskEpoch && sources.every((source) => source.taskEpoch === this._taskEpoch && source.state !== "cancelled" && source.state !== "superseded" && sourceMessages?.some((message) => message.role === "user" && message.content === source.content && message.requiredSourceEvidence?.schema === "omnius.required-source-evidence.v1" && message.requiredSourceEvidence.scope === this._steeringAuthorityScope(source)));
     const exactSourcePointer = (source) => `Exact admitted instruction is already present in its required user message: input_id=${source.inputId}; sha256=${_createHash("sha256").update(source.content).digest("hex")}.`;
     const needsClarification = reconciliation?.status === "needs_clarification";
@@ -408782,6 +409415,9 @@ issuer=${predecessor.runId}; evidence=${receipt.id}; raw_ref=${receipt.rawRef ??
       `kind=${input.intent}`,
       `admission=${active.gatesOldPlan ? "old_plan_gated" : "context_active"}`,
       "This is current user authority, not historical transcript context.",
+      humanResponse ? `You have already visibly responded to the latest input: ${humanResponse.content}
+Do not repeat that response. Reconcile the complete instruction internally before the next action; this conversational reply granted no tool or scope authority.` : "Answer the latest user's question or briefly state the concrete effect of their change first, in ordinary visible prose. Then reconcile the current instruction internally before deeper planning or tools. Do not announce steering, reconciliation, or internal reviews.",
+      isSteeringScopeResolved(active) && this._currentSteeringReplyPending() ? "The internal scope decision is already stored. Give the actual user-facing answer now; do not repeat the internal reconciliation, call tools, or replace the original objective." : null,
       input.intent === "redirect" || input.intent === "replace" ? "The prior task epoch is historical evidence only. Do not continue its plan, todos, recovery cards, or completion contract." : null,
       needsClarification ? "You requested clarification. Do not call tools or resume the old plan; ask the user one concise question." : active.requiresReconciliation ? [
         renderSteeringReconciliationProtocol(input.inputId),
@@ -408807,9 +409443,13 @@ ${exactSourcesPresent ? exactSourcePointer(related) : related.content}`),
   }
   _markActiveSteeringVisible(turn) {
     const active = this._activeSteering;
-    if (!active || isSteeringScopeResolved(active) || active.visibleRequestTurns.includes(turn))
+    const pendingReply = this._currentSteeringReplyPending();
+    if (pendingReply && active && [active.input, ...active.relatedInputs ?? []].includes(pendingReply.input) && !pendingReply.visibleRequestTurns.includes(turn))
+      pendingReply.visibleRequestTurns.push(turn);
+    if (!active || isSteeringScopeResolved(active) || active.visibleRequestTurns.includes(turn) && ![active.input, ...active.relatedInputs ?? []].some((input) => input.state === "queued" || input.state === "acknowledged"))
       return;
-    active.visibleRequestTurns.push(turn);
+    if (!active.visibleRequestTurns.includes(turn))
+      active.visibleRequestTurns.push(turn);
     for (const input of [active.input, ...active.relatedInputs ?? []]) {
       input.state = "visible_in_request";
       this._emitSteeringLifecycle(input, `visible in model request at turn ${turn}`);
@@ -408953,6 +409593,11 @@ ${exactSourcesPresent ? exactSourcePointer(related) : related.content}`),
     if (this.taskRequirementInterpretationPending)
       return "native_requirement_interpretation_pending: the host is reviewing the latest authenticated human instruction; no new action or completion is admitted until its canonical requirements are durably resolved.";
     const active = this._activeSteering;
+    const replyTurn = this._steeringReplyTurn;
+    if (replyTurn?.runId === this.currentArtifactRunId() && replyTurn.taskEpoch === this._taskEpoch && replyTurn.ownerId === this._interruptionOwnerId && replyTurn.turn === turn)
+      return "[HUMAN_RESPONSE_TURN_REQUIRED] The current response answers the user. Wait for the next model decision before executing tools.";
+    if (this._currentSteeringReplyPending() && (!active || isSteeringScopeResolved(active)))
+      return "[HUMAN_RESPONSE_REQUIRED] Answer the current user's question or change briefly in visible prose before further tools or planning. Its internal scope decision is already stored.";
     if (!active)
       return null;
     if (active.input.taskEpoch === this._taskEpoch && active.reconciliation && active.reconciliation.status !== "needs_clarification" && active.reconciledTurn === turn) {
@@ -408973,7 +409618,7 @@ The steering reconciliation was emitted this turn. Wait for the next model decis
       return [
         `[STEERING_RECONCILIATION_REQUIRED]
 input_id=${active.input.inputId}`,
-        "Do not execute the old-plan tool call. Emit the steering reconciliation first, as text in your very next response, with no tool calls in that response.",
+        "Do not execute the old-plan tool call. Answer the current user briefly in visible prose first, then emit the internal steering reconciliation, with no tool calls in that response.",
         priorRefusals > 0 ? `You have already been refused this exact call ${priorRefusals} time(s). Repeating it will keep being refused. Emit the reconciliation now, or take a different concrete action.` : null,
         renderSteeringReconciliationProtocol(active.input.inputId)
       ].filter(Boolean).join("\n");
@@ -409011,7 +409656,7 @@ Only the exact pending declared read tickets may execute. Old-plan mutations and
         authoritySlot: "[ACTIVE USER STEERING]",
         priorRefusals
       }),
-      "Do not execute or retry old-plan tools. Emit [STEERING_RECONCILIATION] as your next response text with no tool calls; follow the complete protocol and user instruction in [ACTIVE USER STEERING]."
+      "Do not execute or retry old-plan tools. Answer the current user briefly in visible prose, then emit [STEERING_RECONCILIATION] with no tool calls; follow the complete protocol and user instruction in [ACTIVE USER STEERING]."
     ].join("\n");
   }
   _markFirstSteeringAffectedAction(toolName, turn) {
@@ -409055,6 +409700,63 @@ Only the exact pending declared read tickets may execute. Old-plan mutations and
     }
     return receipt;
   }
+  /** Explicit update interrupts inference/owned children without stopping the durable task. */
+  pauseForUpdate() {
+    const receipt = this.pauseForInput();
+    if (receipt?.accepted === false)
+      return receipt;
+    const reason = new InputWaitInterruption();
+    this._updateAbortController.abort(reason);
+    this._turnAbortController.abort(reason);
+    this._trajectoryGroundingRequest?.controller.abort(reason);
+    this._virtualContextRequest?.controller.abort(reason);
+    const names = new Set(this.interruptionState?.pendingAcknowledgements.filter((item) => item.status === "pending" && item.ownerId.startsWith("tool:")).map((item) => item.ownerId.slice(5)) ?? []);
+    for (const name of names) {
+      try {
+        void Promise.resolve(this.lookupRegisteredTool(name)?.tool.cancel?.()).catch(() => void 0);
+      } catch {
+      }
+    }
+    return receipt;
+  }
+  get updateRestartCheckpointForced() {
+    return this._updateRestartCheckpointForced;
+  }
+  /** Native host review capability, installed before this runner accepts work. */
+  setForcedUpdateRequirementRecoveryHandler(handler, onApplied) {
+    if (this._hasStartedTask || this._updateRestartCheckpointForced)
+      throw new Error("Native recovery handler must be bound before task admission");
+    this._forcedUpdateRequirementRecoveryHandler = handler;
+    this._forcedUpdateRequirementRecoveryApplied = onApplied;
+  }
+  /** Called only after the updater's bounded cooperative deadline. One-way. */
+  forceUpdateRestartCheckpoint() {
+    if (this._updateRestartCheckpointSaved)
+      return true;
+    if (!this._interruptionLifecycle || !this._interruptionMessages?.length)
+      return false;
+    if (!this._interruptionLifecycle.isCurrentDurableBoundary())
+      return false;
+    if (!this._updateRestartCheckpointForced) {
+      if (this.pauseForUpdate()?.accepted === false)
+        return false;
+      this._updateRestartCheckpointForced = true;
+    }
+    if (!this._updateRestartOwnerRevoked) {
+      const receipt = this._interruptionLifecycle.forcePauseForUpdate(this._interruptionLifecycle.snapshot().owner);
+      if (!receipt.accepted)
+        return false;
+      this._updateRestartOwnerRevoked = true;
+      this._modelRequestGeneration = receipt.sequence;
+      this._paused = true;
+    }
+    this._updateCheckpointWriteAuthorized = true;
+    try {
+      return this._updateRestartCheckpointSaved = this._prepareUpdateRestartCheckpoint(true);
+    } finally {
+      this._updateCheckpointWriteAuthorized = false;
+    }
+  }
   /** A typed instruction resumes only after the exact atomic owners settle. */
   async resumeAfterInput() {
     const sequence = this._inputWaitSequence;
@@ -409083,6 +409785,25 @@ Only the exact pending declared read tickets may execute. Old-plan mutations and
    * Resume a paused task. The run loop continues from where it left off.
    */
   resume() {
+    if (this._updateRestartCheckpointForced) {
+      const state = this.interruptionState;
+      return state ? {
+        accepted: false,
+        idempotent: false,
+        action: "resume",
+        previousPhase: state.phase,
+        phase: state.phase,
+        sequence: state.sequence,
+        sessionId: state.sessionId,
+        runId: state.runId,
+        taskEpoch: state.taskEpoch,
+        ownerGeneration: state.owner.generation,
+        resumable: true,
+        pendingAcknowledgements: state.pendingAcknowledgements.filter((item) => item.status === "pending").length,
+        unresolvedAmbiguousEffects: state.ambiguousEffects.filter((item) => item.state === "unknown_after_interrupt").length,
+        reason: "This instance was retired for update. Restore its durable checkpoint in the replacement process."
+      } : null;
+    }
     const transition = this._interruptionLifecycle?.requestResume(this._interruptionLifecycle.snapshot().owner, "resume requested by active owner") ?? null;
     if (transition && !transition.accepted)
       return transition;
@@ -409092,6 +409813,11 @@ Only the exact pending declared read tickets may execute. Old-plan mutations and
     this._paused = false;
     this._inputWaitPaused = false;
     this._inputWaitBoundaryController = new AbortController();
+    if (this._updateAbortController.signal.aborted) {
+      this._updateAbortController = new AbortController();
+      this._turnAbortController = new AbortController();
+      this._setBackendTurnAbortSignal(this._turnAbortController.signal);
+    }
     this._releasePauseWaiters();
     return resumed;
   }
@@ -409224,10 +409950,15 @@ Only the exact pending declared read tickets may execute. Old-plan mutations and
   }
   /** Persist exact owned work before an update can replace this process. */
   prepareUpdateRestartCheckpoint() {
-    if (this.taskRequirementInterpretationPending)
+    if (this._updateRestartCheckpointForced)
+      return this._updateRestartCheckpointSaved;
+    return this._prepareUpdateRestartCheckpoint(false);
+  }
+  _prepareUpdateRestartCheckpoint(allowUnresolvedEffects) {
+    if (!allowUnresolvedEffects && this.taskRequirementInterpretationPending)
       return false;
     const state = this._interruptionLifecycle?.snapshot();
-    if (!state || state.phase !== "paused" || !this._interruptionMessages?.length || state.pendingAcknowledgements.some((item) => item.status === "pending") || state.ambiguousEffects.some((item) => item.state === "unknown_after_interrupt"))
+    if (!state || state.phase !== "paused" || !this._interruptionMessages?.length || state.pendingAcknowledgements.some((item) => item.status === "pending") || !allowUnresolvedEffects && state.ambiguousEffects.some((item) => item.state === "unknown_after_interrupt"))
       return false;
     if (!this._saveCompletionLedgerSafe())
       throw new Error("paused_run_checkpoint_ledger_not_durable");
@@ -409244,7 +409975,7 @@ Only the exact pending declared read tickets may execute. Old-plan mutations and
       messages2.push({
         role: "tool",
         tool_call_id: id5,
-        content: `Host update checkpoint: queued ${name} did not finish before the pause. No success or effect is claimed. Consult the exact durable receipts and decide what remaining work to perform.`
+        content: allowUnresolvedEffects ? `Host forced update checkpoint: unfinished ${name} was retired without a success claim. Its effect may be unknown. Reconcile the durable interruption record before replaying any mutation or external effect.` : `Host update checkpoint: queued ${name} did not finish before the pause. No success or effect is claimed. Consult the exact durable receipts and decide what remaining work to perform.`
       });
     const checkpoint = {
       schema: "omnius.paused-run-checkpoint.v1",
@@ -409260,7 +409991,33 @@ Only the exact pending declared read tickets may execute. Old-plan mutations and
       observedEffects: [...this._expectedOutcomeObservedEffects],
       modelRequestGeneration: this._modelRequestGeneration,
       toolPromotions: this._checkpointToolPromotions(),
-      runtimeRecovery: this._captureRuntimeRecovery(messages2)
+      runtimeRecovery: this._captureRuntimeRecovery(messages2),
+      ...allowUnresolvedEffects ? { forcedInterruption: state } : {},
+      forcedIntake: this._forcedUpdateRequirementRecoveryPending ? {
+        ...structuredClone(this._forcedUpdateRequirementRecoveryPending),
+        steering: [...new Map([...this._forcedUpdateRequirementRecoveryPending.steering, ...this.pendingSteeringInputs].map((input) => [input.inputId, structuredClone(input)])).values()],
+        compatibilityMessages: [...this._forcedUpdateRequirementRecoveryPending.compatibilityMessages, ...this.pendingUserMessages],
+        requirementHolds: [...new Map([
+          ...this._forcedUpdateRequirementRecoveryPending.requirementHolds,
+          ...[...this._nativeRequirementInterpretationHolds].map(([inputId, hold2]) => ({ inputId, runId: hold2.runId, taskEpoch: hold2.taskEpoch, nativeInputSha256: hold2.nativeInputSha256 }))
+        ].map((hold2) => [hold2.inputId, hold2])).values()],
+        requirementAmendments: [...new Map([
+          ...this._forcedUpdateRequirementRecoveryPending.requirementAmendments,
+          ...[...this._pendingNativeRequirementAmendments.values()].map((pending) => structuredClone(pending.authority))
+        ].map((authority) => [authority.inputId, authority])).values()]
+      } : {
+        steering: structuredClone(this.pendingSteeringInputs),
+        compatibilityMessages: [...this.pendingUserMessages],
+        requirementHolds: [...this._nativeRequirementInterpretationHolds].map(([inputId, hold2]) => ({
+          inputId,
+          runId: hold2.runId,
+          taskEpoch: hold2.taskEpoch,
+          nativeInputSha256: hold2.nativeInputSha256
+        })),
+        requirementAmendments: [...this._pendingNativeRequirementAmendments.values()].map((pending) => structuredClone(pending.authority)),
+        ...this.options.taskNativeScope ? { nativeScope: structuredClone(this.options.taskNativeScope) } : {},
+        ...this.options.expectedOutcomeContract ? { expectedOutcome: structuredClone(this.options.expectedOutcomeContract) } : {}
+      }
     };
     const body = JSON.stringify(checkpoint);
     const stored = this._artifactStore().put({
@@ -409351,13 +410108,192 @@ Earlier host presentation and its quoted source/history bytes are retained lossl
       throw new Error("paused_run_checkpoint_invalid_identity");
     const archived = this._artifactStore().read(selector.reference);
     const checkpoint = JSON.parse(archived.content);
-    if (!matches(checkpoint) || checkpoint.modelRequestGeneration !== selector.modelRequestGeneration || typeof checkpoint.goal !== "string" || !Array.isArray(checkpoint.messages) || !checkpoint.messages.every((message) => message && ["system", "user", "assistant", "tool"].includes(message.role)) || !checkpoint.taskState || typeof checkpoint.taskState.goal !== "string" || !Array.isArray(checkpoint.taskState.modifiedFiles) || !checkpoint.taskState.modifiedFiles.every((entry) => Array.isArray(entry) && entry.length === 2 && entry.every((value) => typeof value === "string")) || !Array.isArray(checkpoint.taskState.completedSteps) || !Array.isArray(checkpoint.taskState.pendingSteps) || !Array.isArray(checkpoint.taskState.failedApproaches) || !Number.isSafeInteger(checkpoint.taskState.toolCallCount) || !Array.isArray(checkpoint.toolCallLog) || !Array.isArray(checkpoint.observedEffects) || checkpoint.toolPromotions !== void 0 && !this._validCheckpointToolPromotions(checkpoint.toolPromotions) || checkpoint.runtimeRecovery !== void 0 && !this._validRuntimeRecovery(checkpoint.runtimeRecovery, checkpoint)) {
+    if (!matches(checkpoint) || checkpoint.modelRequestGeneration !== selector.modelRequestGeneration || typeof checkpoint.goal !== "string" || !Array.isArray(checkpoint.messages) || !checkpoint.messages.every((message) => message && ["system", "user", "assistant", "tool"].includes(message.role)) || !checkpoint.taskState || typeof checkpoint.taskState.goal !== "string" || !Array.isArray(checkpoint.taskState.modifiedFiles) || !checkpoint.taskState.modifiedFiles.every((entry) => Array.isArray(entry) && entry.length === 2 && entry.every((value) => typeof value === "string")) || !Array.isArray(checkpoint.taskState.completedSteps) || !Array.isArray(checkpoint.taskState.pendingSteps) || !Array.isArray(checkpoint.taskState.failedApproaches) || !Number.isSafeInteger(checkpoint.taskState.toolCallCount) || !Array.isArray(checkpoint.toolCallLog) || !Array.isArray(checkpoint.observedEffects) || checkpoint.toolPromotions !== void 0 && !this._validCheckpointToolPromotions(checkpoint.toolPromotions) || checkpoint.runtimeRecovery !== void 0 && !this._validRuntimeRecovery(checkpoint.runtimeRecovery, checkpoint) || checkpoint.forcedIntake !== void 0 && !this._validForcedIntake(checkpoint.forcedIntake, checkpoint)) {
       throw new Error("paused_run_checkpoint_invalid_snapshot");
     }
     return checkpoint;
   }
+  _validForcedIntake(value, checkpoint) {
+    return !!value && typeof value === "object" && Array.isArray(value.steering) && new Set(value.steering.map((input) => input?.inputId)).size === value.steering.length && value.steering.every((input) => input && typeof input.inputId === "string" && !!input.inputId.trim() && typeof input.content === "string" && typeof input.source === "string" && typeof input.receivedAt === "string" && ["clarify", "append", "context_only", "constraint", "priority_change", "redirect", "replace", "cancel"].includes(input.intent) && ["received", "queued", "acknowledged", "visible_in_request", "reconciliation_required", "reconciled", "first_affected_action", "consumed", "superseded", "cancelled"].includes(input.state) && (input.taskEpoch === void 0 || Number.isSafeInteger(input.taskEpoch) && input.taskEpoch >= 0) && (input.allowTaskReplacement === void 0 || typeof input.allowTaskReplacement === "boolean")) && Array.isArray(value.compatibilityMessages) && value.compatibilityMessages.every((message) => typeof message === "string") && Array.isArray(value.requirementHolds) && value.requirementHolds.every((hold2) => hold2 && typeof hold2.inputId === "string" && hold2.runId === checkpoint.runId && hold2.taskEpoch === checkpoint.taskEpoch && /^[a-f0-9]{64}$/.test(hold2.nativeInputSha256)) && Array.isArray(value.requirementAmendments) && value.requirementAmendments.every((amendment) => amendment && amendment.schema === "omnius.native-requirement-amendment.v1" && typeof amendment.inputId === "string" && amendment.scope?.nativeRunnerRunId === checkpoint.runId && amendment.scope?.taskEpoch === checkpoint.taskEpoch) && (!!checkpoint.forcedInterruption || !value.requirementHolds.length && !value.requirementAmendments.length && !value.reviewedRecovery);
+  }
+  _restoreForcedIntake(checkpoint) {
+    const intake2 = checkpoint.forcedIntake;
+    if (!intake2)
+      return;
+    const activeIds = new Set(this._activeSteering ? [this._activeSteering.input, ...this._activeSteering.relatedInputs ?? []].map((input) => input.inputId) : []);
+    for (const saved of intake2.steering) {
+      const prior = this.pendingSteeringInputs.find((input2) => input2.inputId === saved.inputId);
+      const input = prior ? Object.assign(prior, structuredClone(saved)) : structuredClone(saved);
+      if (!prior)
+        this.pendingSteeringInputs.push(input);
+      if (input.taskEpoch !== void 0 && input.taskEpoch !== this._taskEpoch || ["cancelled", "superseded", "reconciled", "first_affected_action", "consumed"].includes(input.state))
+        continue;
+      if (!activeIds.has(input.inputId))
+        input.state = "queued";
+      if (input.intent === "redirect" || input.intent === "replace" || input.intent === "cancel")
+        this._pendingSteeringPreemption = input;
+      if ((input.source === "tui-work-intake" || input.source === "tui") && input.intent !== "cancel" && !input.humanResponse)
+        this._pendingSteeringReply = { input, runId: this.currentArtifactRunId(), ownerId: this._interruptionOwnerId, visibleRequestTurns: [] };
+    }
+    this.pendingUserMessages.push(...intake2.compatibilityMessages);
+  }
+  async _recoverForcedUpdateRequirements(checkpoint, state) {
+    const intake2 = checkpoint.forcedIntake;
+    if (!intake2 || !intake2.requirementHolds.length && !intake2.requirementAmendments.length)
+      return;
+    if (!checkpoint.completionLedger || !intake2.nativeScope || !intake2.expectedOutcome)
+      throw new Error("forced_update_requirement_recovery_missing_native_authority");
+    this._forcedUpdateRequirementRecoveryPending = structuredClone(intake2);
+    this._completionLedger = restoreCompletionLedgerSnapshot(checkpoint.completionLedger);
+    this._taskObjectiveContract = this._completionLedger.objectiveContract ?? null;
+    const recovery = {
+      schema: "omnius.forced-update-requirement-recovery.v1",
+      checkpointSha256: taskExecutionDigest(checkpoint),
+      runId: state.runId,
+      sessionId: state.sessionId,
+      taskEpoch: state.taskEpoch,
+      ownerGeneration: state.owner.generation,
+      completionLedger: reconcileForcedUpdateReadOnlyOperations(restoreCompletionLedgerSnapshot(checkpoint.completionLedger), state),
+      nativeScope: intake2.nativeScope,
+      expectedOutcome: intake2.expectedOutcome,
+      steering: intake2.steering,
+      requirementHolds: intake2.requirementHolds,
+      requirementAmendments: intake2.requirementAmendments
+    };
+    const lifecycle = this._interruptionLifecycle;
+    const signal = AbortSignal.any([this._turnAbortController.signal, this._updateAbortController.signal, this._abortController.signal]);
+    const assertCurrent = () => {
+      signal.throwIfAborted();
+      if (this._updateRestartCheckpointForced || lifecycle !== this._interruptionLifecycle || !lifecycle?.isCurrentDurableBoundary() || lifecycle.snapshot().phase !== "paused" || lifecycle.snapshot().owner.generation !== recovery.ownerGeneration)
+        throw new InputWaitInterruption();
+    };
+    const file = this._taskScopeBoundaryPath().replace(/\.json$/, ".requirement-recovery.json");
+    let receipt;
+    if (_fsExistsSync(file)) {
+      const stored = JSON.parse(_fsReadFileSync(file, "utf8"));
+      if (stored.checkpointSha256 === recovery.checkpointSha256 && typeof stored.reference === "string")
+        receipt = JSON.parse(this._artifactStore().read(stored.reference).content);
+    }
+    let result;
+    if (receipt)
+      result = applyForcedUpdateRequirementRecovery(recovery, receipt);
+    else {
+      const resolutions = [];
+      const expected = new Map(recovery.requirementHolds.map((hold2) => [hold2.inputId, hold2]));
+      for (const amendment of recovery.requirementAmendments)
+        if (!expected.has(amendment.inputId))
+          expected.set(amendment.inputId, { inputId: amendment.inputId, runId: recovery.runId, taskEpoch: recovery.taskEpoch, nativeInputSha256: amendment.scope.nativeInputSha256 });
+      const prefix = {
+        ...this._forcedRequirementRecoveryIdentity(recovery),
+        schema: "omnius.forced-update-requirement-recovery-receipt.v1",
+        resolutions,
+        ...intake2.reviewedRecovery ? { predecessor: structuredClone(intake2.reviewedRecovery) } : {}
+      };
+      let current2 = projectForcedUpdateRequirementRecoveryPrefix(recovery, prefix);
+      for (const inputId of current2.resolvedInputIds)
+        expected.delete(inputId);
+      const orderedIds = [.../* @__PURE__ */ new Set([...recovery.steering.map((input) => input.inputId), ...expected.keys()])];
+      for (const inputId of orderedIds) {
+        const hold2 = expected.get(inputId);
+        if (!hold2)
+          continue;
+        assertCurrent();
+        const amendment = recovery.requirementAmendments.find((authority) => authority.inputId === inputId);
+        const one = {
+          ...structuredClone(recovery),
+          ...structuredClone(current2),
+          steering: structuredClone(current2.recoveredSteering),
+          requirementHolds: [hold2],
+          requirementAmendments: amendment ? [amendment] : []
+        };
+        let reviewed;
+        if (amendment)
+          reviewed = {
+            ...this._forcedRequirementRecoveryIdentity(recovery),
+            schema: "omnius.forced-update-requirement-recovery-receipt.v1",
+            resolutions: [{
+              inputId,
+              nativeInputSha256: hold2.nativeInputSha256,
+              disposition: "amendment",
+              authority: amendment
+            }]
+          };
+        else {
+          if (!this._forcedUpdateRequirementRecoveryHandler)
+            throw new Error(`interruption_requirement_review_required:${recovery.runId}`);
+          reviewed = await withInputWaitCancellation(signal, () => this._forcedUpdateRequirementRecoveryHandler(one, { signal, assertCurrent }));
+        }
+        assertCurrent();
+        current2 = applyForcedUpdateRequirementRecovery(one, reviewed);
+        resolutions.push(...reviewed.resolutions);
+        expected.delete(inputId);
+      }
+      if (expected.size)
+        throw new Error("forced_update_requirement_recovery_missing_intake");
+      receipt = prefix;
+      result = applyForcedUpdateRequirementRecovery(recovery, receipt);
+      assertCurrent();
+      const body = JSON.stringify(receipt), stored = this._artifactStore().put({
+        path: `forced-requirement-recovery/${state.runId}/${state.taskEpoch}`,
+        revision: taskExecutionDigest(receipt),
+        content: body,
+        ranges: [{ start: 1, end: 1 }],
+        fidelity: "full"
+      });
+      this._artifactStore().flush(stored.reference);
+      _fsMkdirSync(_pathJoin(file, ".."), { recursive: true });
+      const temporary = `${file}.${crypto.randomUUID()}.tmp`;
+      _fsWriteFileSync(temporary, JSON.stringify({ checkpointSha256: recovery.checkpointSha256, reference: stored.reference }), { encoding: "utf8", mode: 384 });
+      this._syncTaskScopeFile(temporary);
+      assertCurrent();
+      _fsRenameSync(temporary, file);
+      this._syncTaskScopeDirectories(file);
+    }
+    assertCurrent();
+    this._forcedUpdateRequirementRecoveryPending.reviewedRecovery = { recovery: structuredClone(recovery), receipt: structuredClone(receipt) };
+    checkpoint.completionLedger = result.completionLedger;
+    this.options.taskObjectiveContract = result.completionLedger.objectiveContract;
+    this.options.taskNativeScope = structuredClone(result.nativeScope);
+    this.options.expectedOutcomeContract = structuredClone(result.expectedOutcome);
+    intake2.steering = result.recoveredSteering;
+    for (const input of result.recoveredSteering)
+      if (input.state === "consumed" && receipt.resolutions.some((resolution) => resolution.inputId === input.inputId)) {
+        const context = `[REVIEWED USER CONTEXT]
+input_id=${input.inputId}
+The native host reviewed this input as context without a new task action. Preserve its quoted source meaning.
+${JSON.stringify(input.content)}
+[/REVIEWED USER CONTEXT]`;
+        if (!checkpoint.messages.some((message) => message.role === "system" && message.content === context))
+          checkpoint.messages.push({ role: "system", content: context, taskEpoch: checkpoint.taskEpoch });
+      }
+    intake2.requirementHolds = [];
+    intake2.requirementAmendments = [];
+    if (result.responseInputs.length && !this._forcedUpdateRequirementRecoveryApplied)
+      throw new Error("forced_update_requirement_response_not_delivered");
+    if (this._forcedUpdateRequirementRecoveryApplied) {
+      await withInputWaitCancellation(signal, () => Promise.resolve(this._forcedUpdateRequirementRecoveryApplied(structuredClone(recovery), structuredClone(result), { signal, assertCurrent })));
+      assertCurrent();
+    }
+    if (result.replacementInputs.length) {
+      if (!this._forcedUpdateRequirementRecoveryApplied)
+        throw new Error("forced_update_requirement_replacement_not_staged");
+      this._forcedUpdateRequirementTaskReplaced = true;
+      const stopped = lifecycle.requestStop(lifecycle.snapshot().owner, "native host durably staged an authenticated replacement task after update");
+      if (!stopped.accepted)
+        throw new Error(stopped.reason);
+      if (lifecycle.snapshot().phase === "stopping")
+        lifecycle.acknowledgeStop("old native objective superseded after durable replacement staging");
+    }
+    this._forcedUpdateRequirementRecoveryPending = void 0;
+  }
+  _forcedRequirementRecoveryIdentity(recovery) {
+    const { checkpointSha256, runId, sessionId, taskEpoch, ownerGeneration } = recovery;
+    return { checkpointSha256, runId, sessionId, taskEpoch, ownerGeneration };
+  }
   /** Resolve one persisted ambiguous effect before admitting another run. */
   resolveInterruptionEffect(operationId, state, evidenceId) {
+    if (this._updateRestartCheckpointForced)
+      return false;
     const resolved = this._interruptionLifecycle?.resolveAmbiguousEffect(operationId, state, evidenceId) ?? false;
     this._reconcileRetiredLegacyOperations(this.interruptionState);
     return resolved;
@@ -409416,6 +410352,10 @@ Earlier host presentation and its quoted source/history bytes are retained lossl
    * Returns true if the loop should continue, false if aborted while paused.
    */
   async waitIfPaused() {
+    if (this._updateRestartCheckpointForced && this.aborted)
+      throw new InputWaitInterruption();
+    if (this.aborted)
+      return false;
     if (!this._paused)
       return true;
     this._interruptionLifecycle?.acknowledgePauseBoundary();
@@ -409426,6 +410366,8 @@ Earlier host presentation and its quoted source/history bytes are retained lossl
     await new Promise((resolve42) => {
       this._pauseWaiters.add(resolve42);
     });
+    if (this._updateRestartCheckpointForced)
+      throw new InputWaitInterruption();
     return !this.aborted;
   }
   /** Commit a streamed final reply only after its model owner reached a safe boundary. */
@@ -411269,6 +412211,8 @@ ${rawTask}`;
     if (this.options.trajectoryCheckpoint === "shadow" || this.options.trajectoryGrounding === "off") {
       return null;
     }
+    if (this._hasUnresolvedCurrentSteeringInputs() || this._currentSteeringReplyPending() || this._currentAdjudicationArgumentRepair(turn))
+      return null;
     const { id: _id, revision: _revision, turn: _turn, ...base } = checkpoint;
     const semanticKey = this._loopRecoveryAdvisoryKey();
     const baseFingerprint = `${trajectoryCheckpointFingerprint(base)}:${semanticKey}`;
@@ -411344,12 +412288,29 @@ ${rawTask}`;
     this._trajectoryGroundingAttemptedFingerprint = baseFingerprint;
     this._trajectoryGroundingMaterial = materialFingerprint;
     const review = this._beginRecoveryReview("trajectory");
+    const grounding = { controller: new AbortController(), runId: this.currentArtifactRunId(), taskEpoch: this._taskEpoch };
+    this._trajectoryGroundingRequest = grounding;
+    const signal = AbortSignal.any([
+      grounding.controller.signal,
+      this._abortController.signal,
+      this._turnAbortController.signal,
+      this._inputWaitBoundaryController.signal
+    ]);
+    const owner = this._interruptionOwnerId;
+    const requestGeneration = this._modelRequestGeneration;
+    const assertCurrent = () => {
+      signal.throwIfAborted();
+      if (grounding.runId !== this.currentArtifactRunId() || grounding.taskEpoch !== this._taskEpoch || owner !== this._interruptionOwnerId || requestGeneration !== this._modelRequestGeneration || !this._recoveryReviewIsCurrent(review) || this._hasUnresolvedCurrentSteeringInputs())
+        throw new InputWaitInterruption();
+    };
     try {
+      assertCurrent();
       this._emitModelResolutionTelemetry("trajectory_grounding", turn);
       const backend = this._auxInferenceBackend({
-        dumpStage: "trajectory_grounding"
+        dumpStage: "trajectory_grounding",
+        assertCurrent
       });
-      const response = await backend.chatCompletion({
+      const response = await withInputWaitCancellation(signal, () => backend.chatCompletion({
         messages: [
           {
             role: "system",
@@ -411368,8 +412329,10 @@ ${rawTask}`;
         timeoutMs: this.options.requestTimeoutMs,
         // The output is an explicit concise assessment, not a hidden-think
         // transcript. Keep Qwen's structured response path reliable.
-        think: false
-      });
+        think: false,
+        signal
+      }));
+      assertCurrent();
       const generated = parseTrajectoryGeneratedGrounding(response.choices?.[0]?.message?.content ?? "", checkpoint.groundedFacts.map((fact) => fact.evidence));
       if (!this._recoveryReviewIsCurrent(review))
         return null;
@@ -411425,7 +412388,9 @@ ${rawTask}`;
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       return generated;
-    } catch {
+    } catch (error) {
+      if (signal.aborted || error instanceof InputWaitInterruption || !this._recoveryReviewIsCurrent(review))
+        return null;
       this.emit({
         type: "status",
         content: "Trajectory grounding unavailable; retaining deterministic safety orientation",
@@ -411433,6 +412398,9 @@ ${rawTask}`;
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       return null;
+    } finally {
+      if (this._trajectoryGroundingRequest === grounding)
+        this._trajectoryGroundingRequest = null;
     }
   }
   /**
@@ -411444,6 +412412,8 @@ ${rawTask}`;
   _observabilityActionSequence = 0;
   _observabilityPendingActions = /* @__PURE__ */ new Map();
   emit(event) {
+    if (this._updateRestartCheckpointForced)
+      return;
     if (event.type === "tool_call" && event.toolName !== "task_complete" && !this._isProgressTool(event.toolName ?? "")) {
       const candidate = this._latestModelVisibleAssistantText;
       this._telegramDeliveryRefinementCandidateKey = this._isTelegramSurface() && candidate?.runId === this.currentArtifactRunId() && candidate.taskEpoch === this._taskEpoch ? [candidate.runId, candidate.taskEpoch, candidate.turn].join(":") : void 0;
@@ -411887,7 +412857,7 @@ Respond with the assessment and take the selected evidence-backed action.`;
       try {
         if (pending.size)
           this.abort();
-        if (admitted && !terminalAccepted)
+        if (admitted && !terminalAccepted && !this._updateRestartCheckpointForced)
           lifecycle?.requestStop(lifecycle.snapshot().owner, "host session closed without inferring task completion");
         this._saveCompletionLedgerSafe();
       } catch (error) {
@@ -411900,6 +412870,8 @@ Respond with the assessment and take the selected evidence-backed action.`;
   }
   /** Run a task through the agentic loop; a host session may not re-enter it. */
   async run(task, context, actualUserGoal) {
+    if (this._updateRestartCheckpointForced)
+      throw new Error("This runner was retired for update; restore its durable checkpoint in a replacement process.");
     if (this._exclusiveTaskOwner || this._activeDirectToolCalls)
       throw new Error("A task or direct call already owns this runner.");
     this._exclusiveTaskOwner = "model";
@@ -412088,6 +413060,36 @@ Respond with the assessment and take the selected evidence-backed action.`;
         this._taskEpoch = recovered.taskEpoch;
         this._activeRunId = recovered.runId;
         pausedCheckpoint = this._readPausedRunCheckpoint(recovered);
+        if (pausedCheckpoint) {
+          this._paused = true;
+          this._modelRequestGeneration = pausedCheckpoint.modelRequestGeneration ?? 0;
+          this._interruptionMessages = pausedCheckpoint.messages;
+          this._interruptionToolCallLog = pausedCheckpoint.toolCallLog;
+          this._taskState = { ...pausedCheckpoint.taskState, modifiedFiles: new Map(pausedCheckpoint.taskState.modifiedFiles) };
+          try {
+            await this._recoverForcedUpdateRequirements(pausedCheckpoint, recovered);
+          } catch (error) {
+            if (this._paused && this._updateAbortController.signal.aborted) {
+              await this.waitIfPaused();
+            }
+            throw error;
+          }
+          if (this._forcedUpdateRequirementTaskReplaced)
+            return {
+              status: "incomplete",
+              completed: false,
+              turns: 0,
+              toolCalls: 0,
+              totalTokens: 0,
+              promptTokens: 0,
+              completionTokens: 0,
+              estimatedTokens: 0,
+              summary: "",
+              durationMs: 0
+            };
+          if (pausedCheckpoint.forcedInterruption && pausedCheckpoint.completionLedger)
+            pausedCheckpoint.completionLedger = reconcileForcedUpdateReadOnlyOperations(pausedCheckpoint.completionLedger, recovered);
+        }
         if (pausedCheckpoint) {
           actualUserGoal = pausedCheckpoint.goal;
           this._interruptionExplicitGoal = pausedCheckpoint.goal;
@@ -412107,6 +413109,7 @@ Respond with the assessment and take the selected evidence-backed action.`;
         const acknowledged = lifecycle.acknowledgeResume("restart recovery checks complete");
         if (!acknowledged.accepted)
           throw new Error(acknowledged.reason);
+        this._paused = false;
         const priorGeneration = pausedCheckpoint?.modelRequestGeneration ?? 0;
         if (!Number.isSafeInteger(acknowledged.sequence) || acknowledged.sequence <= priorGeneration) {
           throw new Error("paused_run_checkpoint_invalid_request_generation");
@@ -412862,6 +413865,8 @@ ${dynamicProjectContext}`
         retainedTaskHistory = this._refreshPausedTelegramNativeContext(retainedTaskHistory, dynamicContextMessages, currentNativeInstruction);
       messages2.splice(0, messages2.length, ...currentRuntimePolicy, ...retainedTaskHistory);
     }
+    if (pausedCheckpoint)
+      this._restoreForcedIntake(pausedCheckpoint);
     this._interruptionMessages = messages2;
     const preflightMemoryRecall = await this._buildPreflightTaskMemoryRecall(persistentTaskGoal);
     if (preflightMemoryRecall) {
@@ -413875,12 +414880,16 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
     };
     const preparedToolArguments = /* @__PURE__ */ new WeakMap();
     const originalToolArguments = /* @__PURE__ */ new WeakMap();
+    const preparedAdjudicationRepairs = /* @__PURE__ */ new WeakMap();
     const prepareToolArguments = async (tc, toolTurn) => {
       if (preparedToolArguments.has(tc))
         return preparedToolArguments.get(tc);
       originalToolArguments.set(tc, structuredClone(tc.arguments ?? {}));
+      const preparationScope = { runId: this.currentArtifactRunId(), taskEpoch: this._taskEpoch, ownerId: this._interruptionOwnerId };
+      const preparationIsCurrent = () => preparationScope.runId === this.currentArtifactRunId() && preparationScope.taskEpoch === this._taskEpoch && preparationScope.ownerId === this._interruptionOwnerId;
       const resolved = this.lookupRegisteredTool(tc.name);
       let error = null;
+      let adjudicationArgs;
       if (resolved && !(tc.arguments && "_raw" in tc.arguments)) {
         try {
           const workflow = extractFeatureWorkflowToolBinding(tc.arguments ?? {});
@@ -413894,6 +414903,18 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
             args = this._autoDeriveDelegationMutationScope(resolved.name, args, toolTurn);
             args = await this._enrichDelegationToolArgs(resolved.name, args, messages2, toolTurn);
           }
+          if (resolved.name === ADJUDICATION_TOOL_NAME) {
+            adjudicationArgs = args;
+            tc.arguments = args;
+            const prior = preparationIsCurrent() ? this._currentAdjudicationArgumentRepair() : null;
+            if (prior?.argsKey === this._buildExactArgsKey(args)) {
+              const replay = { ...prior, turn: toolTurn, repeats: prior.repeats + 1, settled: false };
+              preparedAdjudicationRepairs.set(tc, replay);
+              this._adjudicationArgumentRepair = replay;
+              preparedToolArguments.set(tc, prior.error);
+              return prior.error;
+            }
+          }
           if (resolved.tool.inputSchema)
             args = this._parsedToolArgumentRecord(resolved.tool.inputSchema.parse(args));
           else {
@@ -413906,6 +414927,22 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
             this._featureWorkflowBindings.set(args, workflow.cardId);
         } catch (caught) {
           error = caught instanceof Error ? caught.message : String(caught);
+          if (resolved.name === ADJUDICATION_TOOL_NAME && adjudicationArgs && preparationIsCurrent()) {
+            const repair = {
+              ...preparationScope,
+              tool: resolved.tool,
+              schema: resolved.tool.inputSchema,
+              parameters: JSON.stringify(resolved.tool.parameters),
+              argsKey: this._buildExactArgsKey(adjudicationArgs),
+              contract: adjudicationArgumentRepairContract(error, _createHash("sha256").update(this._buildExactArgsKey(adjudicationArgs)).digest("hex")),
+              error,
+              turn: toolTurn,
+              repeats: 0,
+              settled: false
+            };
+            preparedAdjudicationRepairs.set(tc, repair);
+            this._adjudicationArgumentRepair = repair;
+          }
         }
       }
       preparedToolArguments.set(tc, error);
@@ -414891,7 +415928,8 @@ ${cachedResult}`,
         if (resolvedTool && !this._isToolExposedForModelCall(resolvedTool.name) && !this._admitDeferredDirectCall(resolvedTool.name, turn)) {
           result = this._missingCapabilityResult(resolvedTool.name, turn);
         } else if (preparedArgumentError && tool) {
-          const repair = this.buildToolArgumentRepairFeedback(tc.name, tc.arguments, tool, preparedArgumentError);
+          const admittedRepair = preparedAdjudicationRepairs.get(tc);
+          const repair = this.buildToolArgumentRepairFeedback(tc.name, tc.arguments, tool, preparedArgumentError, admittedRepair);
           runtimeSystemGuidance = repair.systemGuidance;
           result = {
             success: false,
@@ -414900,6 +415938,21 @@ ${cachedResult}`,
             llmContent: repair.llmContent,
             runtimeAuthored: true
           };
+          const argumentRepair = admittedRepair && this._adjudicationArgumentRepairIsCurrent(admittedRepair) && admittedRepair.argsKey === this._buildExactArgsKey(tc.arguments) ? admittedRepair : null;
+          if (argumentRepair) {
+            argumentRepair.settled = true;
+            this._adjudicationArgumentRepair = argumentRepair;
+            result.data = { kind: "adjudication_argument_repair", contract: argumentRepair.contract };
+            result.failure = { kind: "schema_validation", field: argumentRepair.contract.fields[0]?.path };
+            result.failureDiagnosis = {
+              ...classifyRuntimeFailure({ toolName: resolvedTool.name, failure: result.failure, errorText: repair.error }),
+              retryable: false,
+              createRecoveryCard: false,
+              guidance: repair.systemGuidance
+            };
+            if (argumentRepair.repeats)
+              repeatShortCircuit = result;
+          }
         } else if (repeatShortCircuit) {
           result = repeatShortCircuit;
         } else if (tc.arguments && "_raw" in tc.arguments) {
@@ -416484,6 +417537,8 @@ ${bookkeepingGuidance}` : bookkeepingGuidance;
         }
         if (result.success) {
           delete result.failureDiagnosis;
+          if (result.runtimeAuthored !== true && this._currentAdjudicationArgumentRepair()?.settled)
+            this._adjudicationArgumentRepair = null;
         } else if (!processWasStopped && !completionReviewIsPending && !this._isPdfTerminalFeedback(result)) {
           this._diagnoseToolFailure(tc.name, tc.arguments, result);
           const staleHashRetryGuidance = this._buildStaleHashRetryGuidance(tc.name, tc.arguments, result);
@@ -418850,7 +419905,12 @@ ${memoryLines.join("\n")}`
       }
       const { maxOutputTokens: effectiveMaxTokens } = this.contextLimits();
       this.gcSystemMessages(requestMessages2);
+      const steeringBeforeVirtualContext = new Set(this.pendingSteeringInputs);
       const virtualEvidenceMessages = await this._buildLiveVirtualContextMessages(task, requestMessages2, turn, toolDefs);
+      if (this.pendingSteeringInputs.some((input) => !steeringBeforeVirtualContext.has(input) && !["cancelled", "superseded", "consumed"].includes(input.state))) {
+        --localTurn;
+        continue;
+      }
       if (virtualEvidenceMessages.length > 0) {
         const insertionIndex = requestMessages2[0]?.role === "system" ? 1 : 0;
         requestMessages2.splice(insertionIndex, 0, ...virtualEvidenceMessages);
@@ -419423,6 +420483,7 @@ ${transportFailure2}` : transportFailure2;
       if (!choice)
         break;
       const msg = choice.message;
+      this._observePrimarySteeringReply(response["_rawTypedModelContent"] ?? msg.content, turn, !this.options.streamEnabled && Boolean(msg.toolCalls?.length));
       this._reconcileActiveSteeringFromModel(response["_rawTypedModelContent"] ?? msg.content, turn, messages2);
       if (this._preparedTaskScopeBoundary && this._pendingSteeringPreemption) {
         await this._applySteeringAtSafeBoundary(messages2, turn);
@@ -420299,6 +421360,8 @@ Your most recent tool calls SUCCEEDED. If the task is complete, call task_comple
       } catch {
       }
     }
+    if (this._updateRestartCheckpointForced)
+      throw new InputWaitInterruption();
     let prevCycleSubstantiveProgress = substantiveProgressCount;
     while (!completed && !this.aborted && !nonRetryableBackendFailure && !this._terminalRuntimeFailure && !this._completionIncompleteVerification && this.options.bruteForce && bruteForceCycle < this.options.bruteForceMaxCycles) {
       bruteForceCycle++;
@@ -420457,7 +421520,12 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
         }
         this._insertContextFrame(compactedMsgs, await this._buildTurnContextFrame(turn, compactedMsgs, void 0, bfEnvironmentBlock));
         this.gcSystemMessages(compactedMsgs);
+        const steeringBeforeVirtualContext = new Set(this.pendingSteeringInputs);
         const virtualEvidenceMessages = await this._buildLiveVirtualContextMessages(persistentTaskGoal, compactedMsgs, turn, toolDefs);
+        if (this.pendingSteeringInputs.some((input) => !steeringBeforeVirtualContext.has(input) && !["cancelled", "superseded", "consumed"].includes(input.state))) {
+          --localTurn;
+          continue;
+        }
         const bfRequestMessages = compactedMsgs.map((message) => ({
           ...message
         }));
@@ -420777,6 +421845,7 @@ ${diagnosis}` : diagnosis;
         if (!choice)
           break;
         const msg = choice.message;
+        this._observePrimarySteeringReply(response["_rawTypedModelContent"] ?? msg.content, turn, !this.options.streamEnabled && Boolean(msg.toolCalls?.length));
         this._reconcileActiveSteeringFromModel(response["_rawTypedModelContent"] ?? msg.content, turn, messages2);
         if (this._preparedTaskScopeBoundary && this._pendingSteeringPreemption) {
           await this._applySteeringAtSafeBoundary(messages2, turn);
@@ -421060,6 +422129,8 @@ ${diagnosis}` : diagnosis;
       } catch {
       }
     }
+    if (this._updateRestartCheckpointForced)
+      throw new InputWaitInterruption();
     const durationMs = Date.now() - start;
     const incompleteVerification = this._completionIncompleteVerification;
     if (incompleteVerification && !summary) {
@@ -422371,6 +423442,8 @@ Result: ${summary.slice(0, 330)}`,
   // -------------------------------------------------------------------------
   /** Inject an image into the running conversation (for drag-drop / paste) */
   injectImage(base64, mimeType, description) {
+    if (this._updateRestartCheckpointForced)
+      throw new Error("This runner was retired for update; retain input for the replacement process.");
     const marker = `[IMAGE_BASE64:${mimeType}:${base64}]`;
     this.pendingUserMessages.push(description ? `${description}
 ${marker}` : marker);
@@ -429166,6 +430239,9 @@ var OllamaAgenticBackend = class _OllamaAgenticBackend {
       if (enabledGpuUuids !== void 0) {
         headers["X-Ollama-Unify-GPU-UUIDs"] = enabledGpuUuids.length > 0 ? enabledGpuUuids.join(",") : "none";
       }
+      if (cpuOffloadAllowedFromEnv()) {
+        headers["X-Ollama-Unify-CPU-Offload"] = "allow";
+      }
       const envOverride = process.env["OMNIUS_OLLAMA_BROKER_ADMISSION_WAIT_MS"];
       const classDefault = workloadClass === "background" ? 500 : workloadClass === "interactive-control" ? 3e4 : void 0;
       const configured = Number.parseInt(String(request?.brokerAdmissionWaitMs ?? envOverride ?? classDefault ?? 0), 10);
@@ -430321,114 +431397,6 @@ init_dist3();
 init_ollama_pool();
 init_ollama_pool_cleanup();
 
-// packages/orchestrator/dist/adjudication.js
-import { z as z25 } from "zod";
-var IdSchema = z25.string().trim().min(1).max(96).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/, "use a stable identifier without whitespace");
-var AdjudicationEvidenceSchema = z25.object({
-  id: IdSchema,
-  content: z25.string().trim().min(1).max(32e3),
-  source: z25.string().trim().min(1).max(500),
-  kind: z25.enum([
-    "fact",
-    "observation",
-    "artifact",
-    "test_result",
-    "testimony",
-    "constraint",
-    "precedent"
-  ]).default("observation"),
-  observedAt: z25.string().trim().max(80).optional(),
-  sha256: z25.string().trim().regex(/^[a-fA-F0-9]{64}$/).optional(),
-  reliability: z25.number().min(0).max(1).optional()
-});
-var AdjudicationArgumentSchema = z25.object({
-  id: IdSchema,
-  position: z25.string().trim().min(1).max(160),
-  claim: z25.string().trim().min(1).max(4e3),
-  citedEvidenceIds: z25.array(IdSchema).min(1).max(64),
-  submittedBy: z25.string().trim().max(160).optional()
-});
-var AdjudicationConstituentInputSchema = z25.object({
-  id: IdSchema.optional(),
-  label: z25.string().trim().min(1).max(120),
-  question: z25.string().trim().min(1).max(2e3),
-  instructions: z25.string().trim().max(2e3).optional(),
-  evidenceIds: z25.array(IdSchema).min(1).max(128).optional(),
-  argumentIds: z25.array(IdSchema).max(64).optional(),
-  decisionRuleIds: z25.array(IdSchema).max(32).optional()
-});
-var AdjudicationInputSchema = z25.object({
-  caseId: IdSchema.optional(),
-  question: z25.string().trim().min(1).max(4e3),
-  context: z25.string().trim().max(8e3).optional(),
-  exclusions: z25.array(z25.string().trim().min(1).max(2e3)).max(32).default([]),
-  allowedOutcomes: z25.array(IdSchema).min(2).max(12),
-  decisionRules: z25.array(z25.string().trim().min(1).max(2e3)).max(24).default([]),
-  burdenOfProof: z25.enum([
-    "best_supported",
-    "preponderance",
-    "clear_and_convincing",
-    "beyond_reasonable_doubt",
-    "risk_averse"
-  ]).default("best_supported"),
-  evidence: z25.array(AdjudicationEvidenceSchema).min(1).max(128),
-  arguments: z25.array(AdjudicationArgumentSchema).max(64).default([]),
-  constituents: z25.array(AdjudicationConstituentInputSchema).min(2).max(6).optional(),
-  panelSize: z25.number().int().min(2).max(6).default(3),
-  maxConcurrency: z25.number().int().min(1).max(6).default(3),
-  quorum: z25.number().int().min(2).max(6).optional(),
-  constituentExecution: z25.enum(["auto", "full_sub_agent", "direct"]).default("auto"),
-  timeoutMs: z25.number().int().min(5e3).max(6e5).default(12e4),
-  maxTokensPerConstituent: z25.number().int().min(512).max(8192).default(2048),
-  maxJudgeTokens: z25.number().int().min(768).max(12288).default(3072)
-});
-var PlannerResponseSchema = z25.object({
-  schemaVersion: z25.literal(1),
-  caseId: IdSchema,
-  assignments: z25.array(z25.object({
-    id: IdSchema,
-    label: z25.string().trim().min(1).max(120),
-    question: z25.string().trim().min(1).max(2e3),
-    instructions: z25.string().trim().max(2e3).default(""),
-    evidenceIds: z25.array(IdSchema).min(1).max(128),
-    argumentIds: z25.array(IdSchema).max(64).default([]),
-    decisionRuleIds: z25.array(IdSchema).min(1).max(32)
-  })).min(2).max(6)
-});
-var ConstituentResponseSchema = z25.object({
-  schemaVersion: z25.literal(1),
-  caseId: IdSchema,
-  constituentId: IdSchema,
-  assessment: z25.string().trim().min(20).max(8e3),
-  recommendation: IdSchema,
-  confidence: z25.number().min(0).max(1),
-  citedEvidenceIds: z25.array(IdSchema).min(1).max(128),
-  claims: z25.array(z25.object({
-    claim: z25.string().trim().min(1).max(2e3),
-    evidenceIds: z25.array(IdSchema).min(1).max(64)
-  })).min(1).max(24),
-  counterarguments: z25.array(z25.string().trim().min(1).max(2e3)).max(16).default([]),
-  uncertainties: z25.array(z25.string().trim().min(1).max(2e3)).max(16).default([])
-});
-var JudgeResponseSchema = z25.object({
-  schemaVersion: z25.literal(1),
-  caseId: IdSchema,
-  verdict: IdSchema,
-  confidence: z25.number().min(0).max(1),
-  rationale: z25.string().trim().min(30).max(12e3),
-  citedEvidenceIds: z25.array(IdSchema).min(1).max(128),
-  consideredConstituentIds: z25.array(IdSchema).min(2).max(6),
-  acceptedFindingIds: z25.array(IdSchema).max(144),
-  rejectedFindingIds: z25.array(IdSchema).max(144),
-  dissent: z25.array(z25.object({
-    constituentId: IdSchema,
-    recommendation: IdSchema,
-    summary: z25.string().trim().min(1).max(2e3)
-  })).max(6).default([]),
-  unresolvedQuestions: z25.array(z25.string().trim().min(1).max(2e3)).max(24).default([]),
-  nextAction: z25.string().trim().min(1).max(4e3)
-});
-
 // packages/orchestrator/dist/agent-types.js
 var READ_ONLY_TOOLS = [
   "file_read",