@sema-agent/core 7.51.2 → 7.53.0

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

@@ -4,24 +4,28 @@ 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";
+import { readToolCallArguments, uuidv7 } from "../../internal/harness.js";
 import { ORG_ADJUDICATION_TIMEOUT_MS, settleOrgVerdictWithin } from "../permission-rule-org.js";
 import { applyPersistedTightening, disclosedRuleSet } from "../persisted-rule-arms.js";
+import { argsReadBy, stampArgsReading } from "../effective-path-target.js";
 import { parkedSkillApprovalRefusal, skillRowRefusal } from "../skill-grant.js";
 import { SKILL_TOOL_NAME } from "./synthetic-tools.js";
 import { computeCostMicroUsd } from "../pricing.js";
 import { mintSystemReminder } from "../reminder-mint.js";
 import { hasDestroy } from "../remote-env.js";
-import { advertisedWritableRootsSeat, attestationOf, exemptRootsSeat, humanRefusalSentence, policyCannotAnswer, policyRefusalMessage, refuseOutOfContractDecision } from "../tool-policy.js";
+import { advertisedWritableRootsSeat, attestationOf, exemptRootsSeat, humanRefusalSentence, ownedReading, policyCannotAnswer, policyRefusalMessage, refuseOutOfContractDecision } from "../tool-policy.js";
+import { failedJudgmentDeny } from "./policy-throw.js";
 import { pathDenialCardOf } from "../../tools/fs/safety.js";
 import { callFaceSeat, judgeParkedToolIdentity, parkedRowLiveFace, rosterEntryNamed } from "../tool-roster.js";
 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 +41,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 +172,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 +284,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) => {
@@ -580,20 +556,41 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
         throw new CheckpointError("checkpoint.invalid_outcome", "pending action reached the resolver with no settlement record on its decision (gateOutcome) — refusing to execute or settle a decision that carries no record");
     }
     const humanRewrite = wireOf("resume.questionArgsShown", pendingAction) === ASK_USER_QUESTION_TOOL_NAME ? undefined : outcome.updatedInput;
-    const resolvedArgs = humanRewrite !== undefined ? humanRewrite : pendingAction.args;
+    const liveTool = prepared.tools.find((x) => x.name === pendingAction.toolName);
+    const reading = liveTool === undefined ? undefined : ownedReading((a) => readToolCallArguments(liveTool, { type: "toolCall", id: pendingAction.toolCallId, name: pendingAction.toolName, arguments: {} }, a));
+    const beltFace = () => { const f = parkedRowLiveFace(prepared.toolRosterDeltas.current, pendingAction); if (f !== undefined && reading !== undefined)
+        stampArgsReading(f, reading); return f; };
+    const tryRead = (v) => { try {
+        return { args: reading === undefined ? v : argsReadBy(reading, v) };
+    }
+    catch (error) {
+        return { args: v, unread: { error } };
+    } };
+    const decided = outcome.decision === "allow" ? tryRead(humanRewrite !== undefined ? humanRewrite : pendingAction.args) : { args: humanRewrite !== undefined ? humanRewrite : pendingAction.args };
+    const resolvedArgs = decided.args;
     const pendingLabel = (() => { const l = prepared.tools.find((t) => t.name === pendingAction.toolName)?.label; return l !== undefined && l !== pendingAction.toolName ? { label: l } : {}; })();
     const spelledName = pendingAction.names?.[0] ?? pendingAction.toolName;
     const occurrences = prepared.toolOccurrences;
     const callStart = { toolCallId: pendingAction.toolCallId, spelledName, wireName: pendingAction.toolName, ...pendingLabel, args: resolvedArgs };
     announceToolCall(occurrences, callStart, { push: emit });
     occurrences.gateRound(pendingAction.toolCallId, decidedGate, frozenInputSnapshot(resolvedArgs));
-    const settleEnd = async (isError, result, refusedBy) => {
+    let notExecuted = false;
+    const resultRow = (text, isError) => withRowNotExecuted(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, text, isError), notExecuted);
+    const settleEnd = async (isError, result, refusedBy, neverRan) => {
         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, ...(neverRan ? { notExecuted: true } : {}) }, { 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 } : {}) });
     };
+    const settleUnreadable = async (error, which) => {
+        const marks = egressValue("same-principal", thrownMarksOf(error));
+        const text = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: the tool could not read ${which} — its argument preparation failed (${egressThrownText("same-principal", error)}). This approval is spent — the call has to be re-issued.`, prepared.reminderMark);
+        await settleEnd(true, { content: text, ...(marks !== undefined ? { details: marks } : {}) }, undefined, true);
+        emitCommitted(await prepared.session.appendMessage(resultRow(text, true)), "toolResult", pendingAction.toolCallId);
+    };
     if (outcome.decision === "deny") {
         const settlementKind = outcome.gateOutcome?.settlement?.kind;
         const reason = settlementKind === "policy_refused"
@@ -604,7 +601,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]) {
@@ -615,22 +612,27 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     if (outcome.decision !== "allow") {
         throw new CheckpointError("checkpoint.invalid_outcome", `pending action reached the resolver with decision "${String(outcome.decision)}" — only "allow" executes and only "deny" injects a denial; refusing to execute`);
     }
+    if (decided.unread !== undefined)
+        return settleUnreadable(decided.unread.error, humanRewrite !== undefined ? "the arguments the decision edited it to" : "its arguments");
     const screened = await prepared.approvedCallScreen?.({ toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, args: structuredClone(resolvedArgs), decidedBy: outcome.hostDecision.decidedBy });
     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;
+    const rescreened = humanRewrite === undefined && screened !== undefined ? tryRead(screened.args) : undefined;
+    if (rescreened?.unread !== undefined)
+        return settleUnreadable(rescreened.unread.error, "the arguments a PreToolUse hook rewrote it to");
+    const executedArgs = rescreened !== undefined ? rescreened.args : resolvedArgs;
     const unseen = !deepJsonEqual(executedArgs, pendingAction.args);
     let beltReading;
-    const beltReq = () => ({ toolName: pendingAction.toolName, args: executedArgs, toolCallId: pendingAction.toolCallId, ...callFaceSeat(parkedRowLiveFace(prepared.toolRosterDeltas.current, pendingAction)), budget: beltBudget, ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}), ...(prepared.handsRoot !== undefined ? { root: prepared.handsRoot } : {}), ...advertisedWritableRootsSeat(prepared.advertisedWritableDirs), ...exemptRootsSeat(prepared.exemptRoots), ...(beltReading !== undefined ? { targetReading: beltReading } : {}) });
+    const beltReq = () => ({ toolName: pendingAction.toolName, args: executedArgs, toolCallId: pendingAction.toolCallId, ...callFaceSeat(beltFace()), budget: beltBudget, ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}), ...(prepared.handsRoot !== undefined ? { root: prepared.handsRoot } : {}), ...advertisedWritableRootsSeat(prepared.advertisedWritableDirs), ...exemptRootsSeat(prepared.exemptRoots), ...(beltReading !== undefined ? { targetReading: beltReading } : {}) });
     const unjudgeable = unseen ? chainCannotJudge(resume.cp.state.inheritedGate) : undefined;
     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 = {
@@ -642,14 +644,20 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
         const card = pathDenialCardOf(attestationOf(d, { toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName })?.pathDenial);
         return card !== undefined ? { details: card } : {};
     };
+    const beltCheck = async (judge, seat) => { const signal = prepared.abortController.signal; try {
+        return await judge(signal);
+    }
+    catch (err) {
+        return failedJudgmentDeny(err, signal, (e) => runner.deps.onError?.(e, { phase: "hook", sessionId: prepared.sessionId }), seat, pendingAction);
+    } };
     const beltStamped = prepared.stampCallTarget?.(beltReq(), prepared.abortController.signal);
     if (beltStamped !== undefined)
         beltReading = (await beltStamped).targetReading;
     if (unseen && prepared.basePolicyForResumeEdit) {
-        const rechecked = refuseOutOfContractDecision(await prepared.basePolicyForResumeEdit.check(beltReq(), prepared.abortController.signal));
+        const rechecked = refuseOutOfContractDecision(await beltCheck((signal) => prepared.basePolicyForResumeEdit.check(beltReq(), signal), "the deployment's tool policy re-checking a resumed call"));
         const personUnanswered = policyCannotAnswer(rechecked, outcome.hostDecision.decidedBy);
         const beltUnsafe = rechecked.action === "deny" ||
-            (rechecked.updatedInput !== undefined && !deepJsonEqual(rechecked.updatedInput, executedArgs)) ||
+            (rechecked.updatedInput !== undefined && ((read) => read.unread !== undefined || !deepJsonEqual(read.args, executedArgs))(tryRead(rechecked.updatedInput))) ||
             personUnanswered;
         if (beltUnsafe) {
             const why = rechecked.action === "deny"
@@ -659,7 +667,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,13 +677,13 @@ 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;
     }
     if (prepared.permissionRuleOrg !== undefined) {
         const orgVerdict = prepared.permissionRuleOrg
-            .adjudicate({ toolName: pendingAction.toolName, args: executedArgs, toolCallId: pendingAction.toolCallId, ...callFaceSeat(parkedRowLiveFace(prepared.toolRosterDeltas.current, pendingAction)) })
+            .adjudicate({ toolName: pendingAction.toolName, args: executedArgs, toolCallId: pendingAction.toolCallId, ...callFaceSeat(beltFace()) })
             .catch(() => ({ status: "unavailable", disclosures: ["the org adjudication face threw on resume"] }));
         let orgWaitCancelled = false;
         const org = await settleOrgVerdictWithin(orgVerdict, { status: "unavailable", disclosures: [`the org adjudication face did not answer within ${ORG_ADJUDICATION_TIMEOUT_MS}ms (or the task ended first)`] }, {
@@ -703,17 +711,17 @@ 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;
         }
     }
     if (prepared.denyNarrowingPolicy) {
-        const narrowed = refuseOutOfContractDecision(await prepared.denyNarrowingPolicy.check(beltReq(), prepared.abortController.signal));
+        const narrowed = refuseOutOfContractDecision(await beltCheck((signal) => prepared.denyNarrowingPolicy.check(beltReq(), signal), "the narrowing rules re-checking a resumed call"));
         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 +730,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,13 +753,13 @@ 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;
         }
     }
     if (prepared.shellReadCheck !== undefined) {
-        const readCall = { toolName: pendingAction.toolName, ...callFaceSeat(parkedRowLiveFace(prepared.toolRosterDeltas.current, pendingAction)) };
+        const readCall = { toolName: pendingAction.toolName, ...callFaceSeat(beltFace()) };
         const judged = prepared.shellReadCheck.judge(readCall, executedArgs, prepared.cwdRef?.current, prepared.abortController.signal, {
             toolCallId: pendingAction.toolCallId,
             ...(unseen ? { seat: "rejudge" } : {}),
@@ -768,7 +776,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 +787,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 +799,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 +812,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 +824,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 { compactionPassReport, 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,20 @@ 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] : [])]);
+        const passReport = compactionPassReport(queue, ident);
         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 +38,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 +50,8 @@ 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),
+                onStarted: passReport.onStarted,
             });
             if (comp.compacted) {
                 compactionBreaker.failures = 0;
@@ -90,17 +95,15 @@ 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", ...passReport.end, ...ident() });
                 return false;
             }
             compactionBreaker.failures += 1;
             runner.deps.onError?.(asThrownError(err), { phase: "compaction", sessionId: prepared.sessionId });
             const msg = thrownText(err);
-            queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "forced", reason: msg.length > 512 ? `${msg.slice(0, 512)}…` : msg, ...ident() });
+            queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "forced", reason: msg.length > 512 ? `${msg.slice(0, 512)}…` : msg, ...passReport.end, ...ident() });
             return false;
         }
     };

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({