@sema-agent/core 7.51.2 → 7.52.0

package/dist/core/runner/run-leg.js

@@ -4,7 +4,8 @@ import { ASK_USER_QUESTION_TOOL_NAME } from "../ask-question.js";
 import { CheckpointError, readPendingSteerQueue, realApprovalOrgFact, remainingBudgetMicroUsd } from "../checkpoint-store.js";
 import { normalizePersistedRuleHit } from "../rule-lane-reads.js";
 import { decidersNote, SETTLEMENT_NOBODY_JUDGED } from "../gate-outcome.js";
-import { formatHookFeedback, hookSeatExpiredError, runHookSeat } from "../hooks.js";
+import { formatHookFeedback } from "../hooks.js";
+import { classicEventBase, failedHandlerClause, screenUserPrompt } from "../mods/stations.js";
 import { buildAppliedHumanInputEvent, buildHumanInputEvent, projectHumanInput } from "../human-input-projection.js";
 import { humanInputAttachmentsOf, readObjectiveAttachments, userAttachmentDeclarations } from "../user-attachment.js";
 import { uuidv7 } from "../../internal/harness.js";
@@ -22,6 +23,7 @@ import { deliverEngineNotice } from "../types.js";
 import { delimitUntrusted, inlineUntrusted, REVIEWER_NOTE_MAX_BODY, sanitizeUntrustedText } from "../untrusted-text.js";
 import { errorCodeOf } from "./terminal-account.js";
 import { DEFAULT_PRECALL_OUTPUT_TOKENS, platformLimitTerminal } from "./clock-and-limits.js";
+import { legContextOverlayOption } from "./compaction-call-options.js";
 import { mintOutputStyleReminder, owedPostureText } from "./compaction-restate.js";
 import { deepJsonEqual, resumeContinuation } from "./decide-continuation.js";
 import { chainCannotJudge } from "./call-hook-stations.js";
@@ -37,10 +39,11 @@ import { maybeHumanRejectionHalt } from "./prepare-gate-stations.js";
 import { nextHumanInputSeq } from "./steer-admission.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
 import { announceToolCall, emitSettled, toolResultMsg } from "./tool-end-body.js";
+import { rowDetailsOf, withRowNotExecuted } from "./tool-not-executed.js";
 import { announceListingTruncation } from "../skill-listing-budget.js";
 import { attachmentEnvelopeTags, collectDateChange, commitAgentListing, commitSkillsListing, reduceToolEnd, renderAgentListingFrame, renderOrphanedBackgroundTasks, renderSkillsListingFrame, stampWriteAnchor } from "./turn-attachments.js";
 import { flushOwedAnnouncedSnapshot } from "./announce-once-ledger.js";
-import { asThrownError, thrownMarksOf } from "../thrown-value.js";
+import { thrownMarksOf } from "../thrown-value.js";
 import { egressThrownText, egressValue } from "../untrusted-egress.js";
 import { ruleSourcePhrase } from "../rule-denial-sentence.js";
 import { wireOf } from "../tool-name-readings.js";
@@ -167,32 +170,21 @@ export async function runLeg(input) {
                         engineSegments.push({ start: hookStart, end: continuation.length });
                     }
                     if (source === "steer") {
-                        const parkedScreen = (spec.hooks ?? runner.deps.hooks)?.userPromptSubmit;
-                        if (parkedScreen !== undefined) {
-                            let outcome;
-                            try {
-                                const seat = await runHookSeat("userPromptSubmit", { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal, abortEnds: true }, (sig) => parkedScreen(steer.text, {
-                                    identity: prepared.hookIdentity, permissionMode: prepared.permissionMode.observed,
-                                    signal: sig,
-                                    source: "parked_redelivery",
-                                    ...(steer.inputId !== undefined ? { inputId: steer.inputId } : {}),
-                                    ...(steer.actor !== undefined ? { actor: snapshotActorAssertion(steer.actor) } : {}),
-                                }));
-                                outcome = seat.expired
-                                    ? { blocked: seat.cause === "timeout" ? `the screen did not answer within its ${prepared.hookTimeoutMs}ms bound (fail-closed)` : "the run was cancelled while the screen was still deciding (fail-closed)" }
-                                    : seat.value?.block !== undefined && seat.value.block !== ""
-                                        ? { blocked: inlineUntrusted(seat.value.block) }
-                                        : { ...(seat.value?.additionalContext !== undefined && seat.value.additionalContext !== "" ? { context: seat.value.additionalContext } : {}) };
-                            }
-                            catch (hookErr) {
-                                const err = asThrownError(hookErr);
-                                try {
-                                    runner.deps.onError?.(err, { phase: "hook", sessionId: prepared.sessionId });
-                                }
-                                catch {
-                                }
-                                outcome = { blocked: `the screen crashed (${inlineUntrusted(err.message)}; fail-closed)` };
-                            }
+                        const screen = await screenUserPrompt(prepared.modBus, {
+                            ...classicEventBase(prepared.hookIdentity, prepared.permissionMode.observed),
+                            prompt: steer.text,
+                            source: "parked_redelivery",
+                            ...(steer.inputId !== undefined ? { inputId: steer.inputId } : {}),
+                            ...(steer.actor !== undefined ? { actor: snapshotActorAssertion(steer.actor) } : {}),
+                        }, prepared.abortController.signal);
+                        if (screen !== undefined) {
+                            const outcome = screen.kind === "aborted"
+                                ? { blocked: "the run was cancelled while the screen was still deciding (fail-closed)" }
+                                : screen.kind === "failed"
+                                    ? { blocked: `the screen ${failedHandlerClause(screen)} (fail-closed)` }
+                                    : screen.block !== undefined && screen.block !== ""
+                                        ? { blocked: inlineUntrusted(screen.block) }
+                                        : { ...(screen.additionalContext !== undefined && screen.additionalContext !== "" ? { context: screen.additionalContext } : {}) };
                             if ("blocked" in outcome) {
                                 if (steer.inputId !== undefined)
                                     withheldSteerIds.add(steer.inputId);
@@ -290,49 +282,31 @@ export async function runLeg(input) {
             const projectedObjective = projectHumanInput({ text: spec.objective, actor: objectiveActor, source: "objective" });
             let effectiveObjective = projectedObjective;
             let promptBlocked = false;
-            const userPromptSubmit = (spec.hooks ?? runner.deps.hooks)?.userPromptSubmit;
-            if (userPromptSubmit) {
-                try {
-                    const promptSeat = await runHookSeat("userPromptSubmit", { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal, abortEnds: true }, (sig) => userPromptSubmit(spec.objective, { identity: prepared.hookIdentity, permissionMode: prepared.permissionMode.observed, signal: sig, source: "objective", ...(objectiveActor !== undefined ? { actor: snapshotActorAssertion(objectiveActor) } : {}), ...(prepared.userAttachments !== undefined ? { userAttachments: userAttachmentDeclarations(prepared.userAttachments) } : {}) }));
-                    if (promptSeat.expired) {
-                        if (promptSeat.cause === "timeout") {
-                            try {
-                                runner.deps.onError?.(hookSeatExpiredError("userPromptSubmit", prepared.hookTimeoutMs, promptSeat.cause, "the prompt was NOT submitted (fail-closed) and the task ends blocked"), { phase: "hook", sessionId: prepared.sessionId });
-                            }
-                            catch {
-                            }
-                        }
-                        const timedOut = promptSeat.cause === "timeout";
-                        holdPrompt(prepared.blockedRef, prepared.reminderMark, timedOut ? "timeout" : "cancelled", timedOut
-                            ? `the deployment's userPromptSubmit hook did not answer within its ${prepared.hookTimeoutMs}ms bound while screening this prompt; ` +
-                                `the prompt was NOT submitted (fail-closed)`
-                            : `the task was cancelled while the deployment's userPromptSubmit hook was still screening this prompt; ` +
-                                `the prompt was NOT submitted (fail-closed)`);
-                        promptBlocked = true;
-                    }
-                    const decision = promptSeat.expired ? undefined : promptSeat.value;
-                    const blockWords = decision?.block;
-                    if (blockWords) {
-                        holdPrompt(prepared.blockedRef, prepared.reminderMark, "block", blockWords);
-                        promptBlocked = true;
-                    }
-                    else if (decision?.additionalContext) {
-                        effectiveObjective = `${formatHookFeedback(decision.additionalContext, prepared.reminderMark)}\n\n${projectedObjective}`;
-                    }
-                }
-                catch (hookErr) {
-                    const err = asThrownError(hookErr);
-                    try {
-                        runner.deps.onError?.(err, { phase: "hook", sessionId: prepared.sessionId });
-                    }
-                    catch {
-                    }
-                    holdPrompt(prepared.blockedRef, prepared.reminderMark, "crashed", `the deployment's userPromptSubmit hook crashed while screening this prompt (${err.message}); ` + `the prompt was NOT submitted (fail-closed)`);
-                    promptBlocked = true;
-                }
+            const screen = await screenUserPrompt(prepared.modBus, {
+                ...classicEventBase(prepared.hookIdentity, prepared.permissionMode.observed),
+                prompt: spec.objective,
+                source: "objective",
+                ...(objectiveActor !== undefined ? { actor: snapshotActorAssertion(objectiveActor) } : {}),
+                ...(prepared.userAttachments !== undefined ? { userAttachments: userAttachmentDeclarations(prepared.userAttachments) } : {}),
+            }, prepared.abortController.signal);
+            if (screen?.kind === "aborted") {
+                holdPrompt(prepared.blockedRef, prepared.reminderMark, "cancelled", `the task was cancelled while the deployment's userPromptSubmit hook was still screening this prompt; ` +
+                    `the prompt was NOT submitted (fail-closed)`);
+                promptBlocked = true;
+            }
+            else if (screen?.kind === "failed") {
+                holdPrompt(prepared.blockedRef, prepared.reminderMark, screen.cause === "timeout" ? "timeout" : "crashed", `the deployment's userPromptSubmit hook ${failedHandlerClause(screen)} while screening this prompt; the prompt was NOT submitted (fail-closed)`);
+                promptBlocked = true;
+            }
+            else if (screen?.block) {
+                holdPrompt(prepared.blockedRef, prepared.reminderMark, "block", screen.block);
+                promptBlocked = true;
+            }
+            else if (screen?.additionalContext) {
+                effectiveObjective = `${formatHookFeedback(screen.additionalContext, prepared.reminderMark)}\n\n${projectedObjective}`;
             }
             const objectiveInputId = uuidv7();
-            const { frames: attachmentFrames, chars: attachmentChars } = await readObjectiveAttachments(prepared, objectiveInputId, promptBlocked);
+            const { frames: attachmentFrames, chars: attachmentChars } = await readObjectiveAttachments(prepared, objectiveInputId, promptBlocked, { overlay: () => legContextOverlayOption(prepared, runner).contextOverlay, objectiveChars: effectiveObjective.length });
             let gitLegDelivered;
             if (!promptBlocked) {
                 const gitBody = await resolveGitLegDelivery(prepared, undefined, (err) => {
@@ -587,10 +561,14 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     const callStart = { toolCallId: pendingAction.toolCallId, spelledName, wireName: pendingAction.toolName, ...pendingLabel, args: resolvedArgs };
     announceToolCall(occurrences, callStart, { push: emit });
     occurrences.gateRound(pendingAction.toolCallId, decidedGate, frozenInputSnapshot(resolvedArgs));
+    let notExecuted = false;
+    const resultRow = (text, isError) => withRowNotExecuted(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, text, isError), notExecuted);
     const settleEnd = async (isError, result, refusedBy) => {
         if (refusedBy !== undefined)
             occurrences.refuse(pendingAction.toolCallId, refusedBy);
-        const gate = emitSettled(occurrences, callStart, { result, isError }, { push: emit, structured: prepared.structuredProjector, mediaByteCapBytes: runner.deps.mediaByteCapBytes }).gate ?? decidedGate;
+        const settled = emitSettled(occurrences, callStart, { result, isError }, { push: emit, structured: prepared.structuredProjector, mediaByteCapBytes: runner.deps.mediaByteCapBytes });
+        notExecuted = settled.notExecuted === true;
+        const gate = settled.gate ?? decidedGate;
         const word = await resume.recordExecutionOutcome(gate);
         settleExecutionRecord(runner.deps.onNotice, word, { toolName: pendingAction.toolName, gate, sessionId: prepared.sessionId, runId: prepared.runId, scope: resume.cp.scope, ...(resume.cp.checkpointId !== undefined ? { checkpointId: resume.cp.checkpointId } : {}) });
     };
@@ -604,7 +582,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
                     : `No one answered the approval request for the pending tool call "${pendingAction.toolName}" — the approval window elapsed with no answer, so it was not executed.`
                 : humanRefusalSentence("tool use", outcome.reason, prepared.hookIdentity.isDelegatedChild);
         await settleEnd(true, { content: formatHookFeedback(reason, prepared.reminderMark) });
-        const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, formatHookFeedback(reason, prepared.reminderMark), true));
+        const eid = await prepared.session.appendMessage(resultRow(formatHookFeedback(reason, prepared.reminderMark), true));
         emitCommitted(eid, "toolResult", pendingAction.toolCallId);
         const parkedFallback = pendingAction.denialLimitFallback;
         if (parkedFallback !== undefined && settlementKind !== undefined && SETTLEMENT_NOBODY_JUDGED[settlementKind]) {
@@ -619,7 +597,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     if (screened !== undefined && "refused" in screened) {
         const hookDenial = formatHookFeedback(screened.refused, prepared.reminderMark);
         await settleEnd(true, { content: hookDenial }, "hook");
-        emitCommitted(await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, hookDenial, true)), "toolResult", pendingAction.toolCallId);
+        emitCommitted(await prepared.session.appendMessage(resultRow(hookDenial, true)), "toolResult", pendingAction.toolCallId);
         return;
     }
     const executedArgs = humanRewrite !== undefined ? resolvedArgs : screened !== undefined ? screened.args : resolvedArgs;
@@ -630,7 +608,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     if (unjudgeable !== undefined) {
         const chainDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: its input changed after the approval and the inherited ancestor chain cannot judge the changed input (${unjudgeable}). This approval is spent — the call has to be re-issued.`, prepared.reminderMark);
         await settleEnd(true, { content: chainDenial }, "policy");
-        emitCommitted(await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, chainDenial, true)), "toolResult", pendingAction.toolCallId);
+        emitCommitted(await prepared.session.appendMessage(resultRow(chainDenial, true)), "toolResult", pendingAction.toolCallId);
         return;
     }
     const beltBudget = {
@@ -659,7 +637,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
                     : " (the policy rewrote these bytes to a value that was not approved)";
             const editedDenial = formatHookFeedback(`${outcome.updatedInput !== undefined ? "The approver EDITED this call's input; the edited call" : "A PreToolUse hook REWROTE this approved call's input; the rewritten call"} is refused by the deployment's tool policy and was not executed${why}.`, prepared.reminderMark);
             await settleEnd(true, { content: editedDenial, ...denialCard(rechecked) }, "policy");
-            const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, editedDenial, true));
+            const eid = await prepared.session.appendMessage(resultRow(editedDenial, true));
             emitCommitted(eid, "toolResult", pendingAction.toolCallId);
             return;
         }
@@ -669,7 +647,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     if (gateOrgGoverned && prepared.permissionRuleOrg === undefined) {
         const unwiredDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: its approval was minted under organization governance (${gateRealApproval.origin}), and this worker has no org adjudication wiring — a governed approval may only be redeemed where governance can be enforced. This approval is spent; re-issue the call on an org-wired worker.`, prepared.reminderMark);
         await settleEnd(true, { content: unwiredDenial }, "org");
-        const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, unwiredDenial, true));
+        const eid = await prepared.session.appendMessage(resultRow(unwiredDenial, true));
         emitCommitted(eid, "toolResult", pendingAction.toolCallId);
         return;
     }
@@ -703,7 +681,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
                 : "";
             const orgDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: ${blocked}.${orgDisclosures} This approval is spent — the call has to be re-issued and ${unanswered ? "decided by a person" : "approved again once organization policy permits it"}.`, prepared.reminderMark);
             await settleEnd(true, { content: orgDenial }, "org");
-            const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, orgDenial, true));
+            const eid = await prepared.session.appendMessage(resultRow(orgDenial, true));
             emitCommitted(eid, "toolResult", pendingAction.toolCallId);
             return;
         }
@@ -713,7 +691,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
         if (narrowed.action === "deny") {
             const narrowedDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" is now denied by ${ruleSourcePhrase("narrowing")} and was not executed${narrowed.message ? `: ${narrowed.message}` : ""}.`, prepared.reminderMark);
             await settleEnd(true, { content: narrowedDenial, ...denialCard(narrowed) }, "policy");
-            const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, narrowedDenial, true));
+            const eid = await prepared.session.appendMessage(resultRow(narrowedDenial, true));
             emitCommitted(eid, "toolResult", pendingAction.toolCallId);
             return;
         }
@@ -722,7 +700,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     if (skillRefusal !== undefined) {
         const skillDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: ${skillRefusal.message}. This approval is spent — the call has to be re-issued.`, prepared.reminderMark);
         await settleEnd(true, { content: skillDenial }, "policy");
-        emitCommitted(await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, skillDenial, true)), "toolResult", pendingAction.toolCallId);
+        emitCommitted(await prepared.session.appendMessage(resultRow(skillDenial, true)), "toolResult", pendingAction.toolCallId);
         return;
     }
     if (prepared.persistedRuleLane !== undefined) {
@@ -745,7 +723,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
                     : `it could not be read against your standing deny/ask rules (${read.reason})`;
             const ruleDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: ${why}. This approval is spent — the call has to be re-issued and approved again.`, prepared.reminderMark);
             await settleEnd(true, { content: ruleDenial, ...denialCard(tightened.decision) }, "persisted_rule");
-            const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, ruleDenial, true));
+            const eid = await prepared.session.appendMessage(resultRow(ruleDenial, true));
             emitCommitted(eid, "toolResult", pendingAction.toolCallId);
             return;
         }
@@ -768,7 +746,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
             if (reading.kind === "refuse" || reading.kind === "silence" || (unseen && reading.kind !== "vouch")) {
                 const readDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: ${reading.verdict.sentence ?? "the read boundary does not vouch for what it reads on this leg"} This approval is spent — the call has to be re-issued and approved again.`, prepared.reminderMark);
                 await settleEnd(true, { content: readDenial, ...(reading.verdict.details !== undefined ? { details: reading.verdict.details } : {}) }, "read_boundary");
-                const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, readDenial, true));
+                const eid = await prepared.session.appendMessage(resultRow(readDenial, true));
                 emitCommitted(eid, "toolResult", pendingAction.toolCallId);
                 return;
             }
@@ -779,7 +757,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     if (grantRefusal !== undefined) {
         const grantDenial = formatHookFeedback(grantRefusal, prepared.reminderMark);
         await settleEnd(true, { content: grantDenial }, "policy");
-        emitCommitted(await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, grantDenial, true)), "toolResult", pendingAction.toolCallId);
+        emitCommitted(await prepared.session.appendMessage(resultRow(grantDenial, true)), "toolResult", pendingAction.toolCallId);
         return;
     }
     const tool = prepared.tools.find((t) => t.name === pendingAction.toolName);
@@ -791,7 +769,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     const args = executedArgs;
     screened?.admit();
     onExecuteStart?.(pendingAction.toolCallId);
-    occurrences.execute(pendingAction.toolCallId);
+    occurrences.release(pendingAction.toolCallId);
     prepared.suspendProgressRef.executedApproved = true;
     const finalize = (executed) => prepared.harness.finalizeToolCall({ type: "toolCall", id: pendingAction.toolCallId, name: spelledName, arguments: executedArgs }, executedArgs, executed);
     let res;
@@ -804,7 +782,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
         const failed = await finalize({ result: { content: [{ type: "text", text: execError }], details: marks ?? {} }, isError: true });
         const failedText = failed.result.content.flatMap((c) => (c.type === "text" ? [c.text] : [])).join("\n");
         await settleEnd(true, { content: failedText, ...(marks !== undefined ? { details: marks } : {}) });
-        const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, failedText, true));
+        const eid = await prepared.session.appendMessage(resultRow(failedText, true));
         emitCommitted(eid, "toolResult", pendingAction.toolCallId);
         return;
     }
@@ -816,7 +794,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
         toolCallId: pendingAction.toolCallId,
         toolName: pendingAction.toolName,
         content: ran.result.content,
-        details: ran.result.details,
+        details: rowDetailsOf(ran.result.details, notExecuted),
         isError: ran.isError,
         timestamp: Date.now(),
     });

package/dist/core/runner/run-notification-lane.js

@@ -15,6 +15,7 @@ async function runNotificationLaneAs(input, obligations) {
             suspendedBatch: new Set(resume.cp.pendingAction.kind === "tool_approval" ? resume.cp.pendingAction.batchToolCallIds : []),
             seed: resume.cp.state,
             outcome: resume.outcome,
+            ...(resume.legMods !== undefined ? { legMods: resume.legMods } : {}),
             priorSuspendCount: resume.cp.suspendCount,
             priorLedger: resume.cp.resourceLedger,
             priorHumanReview: resume.cp.humanReview,

package/dist/core/runner/run-recovery-lanes.d.ts

@@ -3,6 +3,7 @@ import { type MaybeCompactOptions } from "../auto-compaction.js";
 import type { PushQueue } from "../push-queue.js";
 import type { Brain, TaskEvent, TaskSpec } from "../types.js";
 import type { InstallingPhaseResult, Prepared, RunnerDepsSeat, RunState } from "./contracts.js";
+import type { CallerStopGate } from "./caller-stop-gate.js";
 export interface RunRecoveryLanesInput {
     /** borrowed-readonly — the task spec: the compaction settings / instructions and the key-and-headers seat. */
     spec: TaskSpec;
@@ -30,6 +31,8 @@ export interface RunRecoveryLanesInput {
     };
     /** borrowed-readonly — the window-safety option builder (the compaction-machinery lane's), per pass. */
     windowSafetyOptions: (mainModel: Model) => Pick<MaybeCompactOptions, "fallbackBudget" | "onWindowSafety">;
+    /** borrowed-readonly — the run's caller-stop gate: the shared pass admits on it and carries it. */
+    callerStop: CallerStopGate;
     /** borrowed-readonly — the Runner's deployment deps, read LIVE (`onError`; the compaction seams the pass reaches down
      *  for — compaction-seams.ts — read the summary provider and the hooks slot through it on every pass). */
     runner: RunnerDepsSeat;

package/dist/core/runner/run-recovery-lanes.js

@@ -2,7 +2,7 @@ import { compactionKindOf } from "../task-notification.js";
 import { planRejectionClears } from "../context-edit.js";
 import { rosterToolName } from "../tool-roster.js";
 import { landStaleResultClears } from "./prepare-context-lane.js";
-import { DEFAULT_COMPACTION_INSTRUCTIONS, maybeCompact, mintCompactedEvent } from "../auto-compaction.js";
+import { DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, maybeCompact, mintCompactedEvent } from "../auto-compaction.js";
 import { emitTrace } from "../trace.js";
 import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
 import { rebaseCadenceWindows } from "./turn-attachments.js";
@@ -13,17 +13,19 @@ import { COMPACTION_FREED_EPSILON, COMPACTION_REGROWTH_FACTOR, MAX_CONSECUTIVE_C
 import { compactionHookOptions, recordCompactionReuse, seamCCompactionOptions } from "./compaction-seams.js";
 import { asThrownError, thrownText } from "../thrown-value.js";
 export function runRecoveryLanes(input) {
-    const { spec, prepared, queue, rs, ident, compactionBrain, compactionBreaker, windowSafetyOptions, runner } = input;
+    const { spec, prepared, queue, rs, ident, compactionBrain, compactionBreaker, windowSafetyOptions, callerStop, runner } = input;
     const runForcedCompactionPass = async (lane, turnSignal) => {
         if (!compactionEnabled(spec.compaction?.enabled, legContextOverlayOption(prepared, runner).contextOverlay))
             return false;
         if (compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES)
             return false;
-        const passSignal = turnSignal !== undefined ? AbortSignal.any([prepared.abortController.signal, turnSignal]) : prepared.abortController.signal;
+        if (callerStop.signal.aborted)
+            return false;
+        const passSignal = AbortSignal.any([prepared.abortController.signal, callerStop.signal, ...(turnSignal !== undefined ? [turnSignal] : [])]);
         try {
             const comp = await maybeCompact({
                 session: prepared.session,
-                epochDeclaredSections: prepared.epochDeclaredSections,
+                promptIdentity: prepared.promptIdentity,
                 ...centerAdoptionOption(prepared),
                 model: prepared.harness.getModel(),
                 ...legContextOverlayOption(prepared, runner),
@@ -35,6 +37,7 @@ export function runRecoveryLanes(input) {
                 settings: legCompactionSettings(spec, legContextOverlayOption(prepared, runner).contextOverlay),
                 customInstructions: spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
                 signal: passSignal,
+                manualCancelSignal: callerStop.signal,
                 minTokens: 0,
                 force: true,
                 overheadTokens: prepared.promptOverheadTokens,
@@ -46,7 +49,7 @@ export function runRecoveryLanes(input) {
                 ...seamCCompactionOptions(runner, prepared),
                 ...compactionRestateOptions(prepared),
                 ...windowSafetyOptions(prepared.harness.getModel()),
-                ...compactionHookOptions(runner, spec, prepared.sessionId, "forced", prepared.hookIdentity, { timeoutMs: prepared.hookTimeoutMs, signal: passSignal }),
+                ...compactionHookOptions(runner, prepared, "forced", passSignal),
             });
             if (comp.compacted) {
                 compactionBreaker.failures = 0;
@@ -90,11 +93,9 @@ export function runRecoveryLanes(input) {
             return comp.compacted === true;
         }
         catch (err) {
-            if (turnSignal?.aborted === true && !prepared.abortController.signal.aborted) {
-                const interruptReason = lane === "rejection"
-                    ? "prompt-too-long recovery pass cut short by a turn interrupt"
-                    : "guard-chain forced compaction cut short by a turn interrupt";
-                queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "forced", reason: interruptReason, ...ident() });
+            if (isCompactionManualCancel(err) || (turnSignal?.aborted === true && !prepared.abortController.signal.aborted)) {
+                emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.mooted", version: 1, taskId: rs.telemetry.taskId, reason: "cancelled", ts: Date.now() }));
+                queue.push({ type: "compaction_outcome", outcome: "mooted", trigger: "forced", reason: "cancelled", ...ident() });
                 return false;
             }
             compactionBreaker.failures += 1;

package/dist/core/runner/run-settle-and-teardown.js

@@ -6,7 +6,7 @@ import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
 import { hasBackgroundShell, sweepRunBoundaryBackgroundShells } from "../background-shell.js";
 import { resolveCheckpointStore } from "../checkpoint-store.js";
 import { reopenReasonOf, reopenedUnstartedSentence, resumeStartupCauseOf } from "../resume-startup-cause.js";
-import { hookSeatExpiredError, runHookSeat } from "../hooks.js";
+import { classicEventBase, observeClassic } from "../mods/stations.js";
 import { modelCostToPricing } from "../pricing.js";
 import { hasDestroy, isIsolated } from "../remote-env.js";
 import { resolveTaskModel } from "../roles.js";
@@ -25,7 +25,6 @@ import { owedDateAnchor } from "./announce-once-ledger.js";
 import { autoRunConsolidationFromRecommendation, autoRunOnRecommendationEffective, scopeHasUnconsumedRecommendation } from "./memory-consolidation-driver.js";
 import { amendTerminal, terminalProjection } from "./terminal-projection.js";
 import { mintCompactedEvent } from "../auto-compaction.js";
-import { asThrownError } from "../thrown-value.js";
 export async function runSettleAndTeardown(input) {
     const { spec, queue, prepared, resume, internals, rs, stats, ident, loopLatch, timeout, ownCommittedTailRef, emitDelegationLifecycle, taskIdRef, manualCompactRef, drainManualCompact, final, threw, abortedLive, userInterruptedLive, answerSettled, strandedHumanAnswers, reasoningResolution, comp, compactionBreaker, owedUserInput, setResult, onSuggestions, onSuspend, runner, sessions } = input;
     try {
@@ -57,7 +56,7 @@ export async function runSettleAndTeardown(input) {
                 const cause = rs.degrade.degraded
                     ? `a mid-task model switch (${rs.degrade.degraded.from} → ${rs.degrade.degraded.to}, degradation) reset the prefix cache — this is the likely cause`
                     : cacheWritten > 0
-                        ? `this task reported ${cacheWritten} cache-write tokens across its calls (compaction included) but served almost none back as reads — consistent with a prompt prefix that CHANGES between turns (client-side: volatile content up front, or per-turn tool churn/reorder) and, less often, with server-side eviction. Keep volatile content (memory/timestamps/ids) out of the prefix and the tool list stable in membership AND order`
+                        ? `this task reported ${cacheWritten} cache-write tokens across its calls (compaction and the classifier's included) but served almost none back as reads — consistent with a prompt prefix that CHANGES between turns (client-side: volatile content up front, or per-turn tool churn/reorder) and, less often, with server-side eviction. Keep volatile content (memory/timestamps/ids) out of the prefix and the tool list stable in membership AND order`
                         : `no call in this task reported any cache-write tokens — and this API family may not report them at all (an openai-shaped usage row carries cached READS only), so the write side is no evidence here; check that the prompt prefix (system prompt + tool list, membership AND order) is byte-stable across turns and that this route caches this model`;
                 runner.deps.onError?.(new Error(`prompt-cache: low prefix-cache hit rate ${(stats.cacheHitRate * 100).toFixed(0)}% over ${stats.turns} turns (${stats.totalInputTokens} prompt tokens) — ${cause}. See design/09.`), { phase: "prompt-cache", sessionId: prepared.sessionId });
             }
@@ -168,8 +167,7 @@ export async function runSettleAndTeardown(input) {
                 }
             }
         }
-        const stopFailureHook = (spec.hooks ?? runner.deps.hooks)?.stopFailure;
-        if (stopFailureHook !== undefined &&
+        if (prepared.modBus.hasHandlers("classic.StopFailure") &&
             result.terminal.kind === "failed" &&
             final?.stopReason === "error" &&
             !isDegenerateCutMessage(final) &&
@@ -180,29 +178,12 @@ export async function runSettleAndTeardown(input) {
             !abortedLive &&
             result.terminal.code !== "conflict") {
             const failedCause = result.terminal;
-            try {
-                const failureSeat = await runHookSeat("stopFailure", { timeoutMs: prepared.hookTimeoutMs }, (sig) => stopFailureHook({
-                    identity: prepared.hookIdentity,
-                    error: failedCause.message ?? "model error",
-                    ...(failedCause.code !== undefined ? { errorKind: failedCause.code } : {}),
-                    turns: stats.turns,
-                    signal: sig,
-                }));
-                if (failureSeat.expired) {
-                    try {
-                        runner.deps.onError?.(hookSeatExpiredError("stopFailure", prepared.hookTimeoutMs, failureSeat.cause, "the terminal observation was abandoned; the assembled TaskResult is unchanged"), { phase: "hook", sessionId: prepared.sessionId });
-                    }
-                    catch {
-                    }
-                }
-            }
-            catch (err) {
-                try {
-                    runner.deps.onError?.(asThrownError(err), { phase: "hook", sessionId: prepared.sessionId });
-                }
-                catch {
-                }
-            }
+            await observeClassic(prepared.modBus, "classic.StopFailure", {
+                ...classicEventBase(prepared.hookIdentity),
+                error: failedCause.message ?? "model error",
+                ...(failedCause.code !== undefined ? { errorKind: failedCause.code } : {}),
+                turns: stats.turns,
+            }, undefined);
         }
         const terminalFace = terminalProjection(result.terminal);
         emitDelegationLifecycle({

package/dist/core/runner/run-stop-and-final-verify.js

@@ -1,10 +1,12 @@
 import { openSystemReminder } from "../reminder-mint.js";
-import { formatHookFeedback, hookSeatExpiredError, runHookSeat } from "../hooks.js";
+import { formatHookFeedback } from "../hooks.js";
+import { classicEventBase, dispatchClassic, stopEventOf, stringMembersAnswer, stringMembersOf } from "../mods/stations.js";
 import { asThrownError } from "../thrown-value.js";
 const STOP_HOOK_BLOCK_CAP = 8;
 export function runStopAndFinalVerify(input) {
     const { spec, prepared, queue, rs, stats, ident, walltimeMonotonicDeadline, runner } = input;
-    const stopHook = (spec.hooks ?? runner.deps.hooks)?.stop;
+    const stopEvent = stopEventOf(prepared.hookIdentity);
+    const stopArmed = prepared.modBus.hasHandlers(stopEvent);
     const finalVerificationOn = spec.finalVerification === true;
     const finalVerifyBudgetFill = () => {
         let worst = 0;
@@ -22,7 +24,7 @@ export function runStopAndFinalVerify(input) {
     const emitFinalVerifyEcho = (body) => {
         queue.push({ type: "steering_injected", source: "final_verification", preview: body.slice(0, 220), ...ident() });
     };
-    if (stopHook || finalVerificationOn) {
+    if (stopArmed || finalVerificationOn) {
         let consecutiveBlocks = 0;
         prepared.harness.setStopGate(async () => {
             if (prepared.abortController.signal.aborted || prepared.pausedRef.current !== undefined || prepared.batchHaltRef.current !== undefined)
@@ -100,32 +102,23 @@ export function runStopAndFinalVerify(input) {
                     },
                 ];
             }
-            if (!stopHook)
+            if (!stopArmed)
                 return [];
-            let result;
-            try {
-                const stopSeat = await runHookSeat("stop", { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal, abortEnds: true }, (sig) => stopHook({
-                    stopHookActive: consecutiveBlocks > 0,
-                    consecutiveBlocks,
-                    getBranch: () => prepared.session.getBranch(),
-                    backgroundTasks: () => prepared.listBackgroundTasks(),
-                    identity: prepared.hookIdentity,
-                    permissionMode: prepared.permissionMode.observed,
-                    signal: sig,
-                }));
-                if (stopSeat.expired) {
-                    if (stopSeat.cause === "timeout") {
-                        runner.deps.onError?.(hookSeatExpiredError("stop", prepared.hookTimeoutMs, stopSeat.cause, "the run was allowed to END (the seat's own no-opinion answer); no pushback and no additional context were injected"), { phase: "hook", sessionId: prepared.sessionId });
-                    }
-                    consecutiveBlocks = 0;
-                    return [];
-                }
-                result = stopSeat.value;
-            }
-            catch (err) {
+            const outcome = await dispatchClassic(prepared.modBus, stopEvent, {
+                ...classicEventBase(prepared.hookIdentity, prepared.permissionMode.observed),
+                stopHookActive: consecutiveBlocks > 0,
+                consecutiveBlocks,
+                getBranch: () => prepared.session.getBranch(),
+                backgroundTasks: () => prepared.listBackgroundTasks(),
+            }, { signal: prepared.abortController.signal, checkAnswer: stringMembersAnswer(stopEvent, ["block", "additionalContext"]) }).catch((err) => {
                 runner.deps.onError?.(asThrownError(err), { phase: "hook", sessionId: prepared.sessionId });
+                return undefined;
+            });
+            if (outcome?.kind !== "answered") {
+                consecutiveBlocks = 0;
                 return [];
             }
+            const result = stringMembersOf(outcome.answer, ["block", "additionalContext"]);
             const messages = [];
             if (result?.additionalContext) {
                 messages.push({

package/dist/core/runner/run-terminal-adoption.d.ts

@@ -22,6 +22,7 @@ import type { PushQueue } from "../push-queue.js";
 import type { Brain, OwedUserInputAccount, TaskEvent, TaskSpec } from "../types.js";
 import { type Stats } from "./assemble-result.js";
 import type { EndOfTaskCompaction, Prepared, RunnerDepsSeat, RunState } from "./contracts.js";
+import type { CallerStopGate } from "./caller-stop-gate.js";
 export interface RunTerminalAdoptionInput<R> {
     /** borrowed-readonly — the task spec: the task id the account's notices name; `finish`'s first argument (the end-of-task pass below). */
     spec: TaskSpec;
@@ -78,6 +79,8 @@ export interface RunTerminalAdoptionInput<R> {
     abortedLive: boolean;
     /** borrowed-readonly — the leg's snapshot of `loopLatch.userInterrupted` (gates the interruption marker). */
     userInterruptedLive: boolean;
+    /** borrowed-readonly — the run's caller-stop gate: the end-of-task pass admits on it and carries it (read LIVE, never snapshot). */
+    callerStop: CallerStopGate;
     /** borrowed-readonly — the Runner's deployment deps, read LIVE (`onError`, `checkpointStore`, `onNotice`, `mediaByteCapBytes`); the one home of why it is
      *  a seat and not a captured object is {@link RunnerDepsSeat}. */
     runner: RunnerDepsSeat;