omnius 1.0.892 → 1.0.893

package/dist/library.js

@@ -82937,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();
@@ -82989,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);
@@ -352559,6 +352581,141 @@ function findBetterToolSchemaMatches(input) {
   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";
@@ -358353,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"];
@@ -358424,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;
@@ -358529,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") {
@@ -388556,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 = "";
@@ -394838,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) {
@@ -394878,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: {
@@ -394900,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",
@@ -394970,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,
@@ -396679,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)
@@ -396951,7 +397176,7 @@ ${content}`)].join("\n\n");
   }
   _currentSteeringReplyPending() {
     const pending = this._pendingSteeringReply;
-    return pending && pending.runId === this.currentArtifactRunId() && pending.ownerId === this._interruptionOwnerId && pending.input.taskEpoch === this._taskEpoch && !["cancelled", "superseded", "consumed"].includes(pending.input.state) ? pending : null;
+    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;
@@ -398066,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, signal: r.signal });
+          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 });
+        });
       }
     };
   }
@@ -406701,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 = {
@@ -406713,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")) {
@@ -406746,6 +406984,73 @@ ${notice}`;
       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
@@ -407073,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) {
@@ -407611,6 +407916,13 @@ The previous reviewer response failed exact candidate-quote serialization. Host
   }
   /** 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;
@@ -408319,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,
@@ -408587,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;
@@ -408599,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;
       }
@@ -408611,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);
     }
@@ -409077,6 +409404,7 @@ issuer=${predecessor.runId}; evidence=${receipt.id}; raw_ref=${receipt.rawRef ??
     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";
@@ -409087,7 +409415,8 @@ 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.",
-      "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.",
+      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 ? [
@@ -409371,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;
@@ -409399,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;
@@ -409408,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;
   }
@@ -409540,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");
@@ -409560,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",
@@ -409576,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({
@@ -409667,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;
@@ -409732,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();
@@ -409742,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. */
@@ -411786,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;
@@ -412229,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) {
@@ -412242,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";
@@ -412430,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;
@@ -412449,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");
@@ -413204,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) {
@@ -420697,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++;
@@ -421464,6 +422129,8 @@ ${diagnosis}` : diagnosis;
       } catch {
       }
     }
+    if (this._updateRestartCheckpointForced)
+      throw new InputWaitInterruption();
     const durationMs = Date.now() - start;
     const incompleteVerification = this._completionIncompleteVerification;
     if (incompleteVerification && !summary) {
@@ -422775,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);