@sema-agent/core 7.48.0 → 7.49.0

package/dist/core/runner/resume-checkpoint-screen.js

@@ -1,7 +1,8 @@
 import { persistedReadDenyEntryProblem } from "../../tools/fs/read-deny.js";
-import { isAbsolutePathForm } from "../../tools/fs/safety.js";
+import { validatePath } from "../effective-path-target.js";
 import { isAskOrigin } from "../ask-origin.js";
 import { CHECKPOINT_FEATURES, CheckpointError, checkpointVersionOf, MAX_SUPPORTED_CHECKPOINT_VERSION, realApprovalOrgFact } from "../checkpoint-store.js";
+import { judgeCheckpointRequirements } from "../checkpoint-requirements.js";
 import { constraintChainDigest, constraintChainEntryOfSuppliedLayer } from "../tool-policy.js";
 import { readFrozenSkillGrants } from "../skill-grant.js";
 import { chainInstallationGaps, chainInstallationRefusal } from "./child-tree.js";
@@ -9,8 +10,13 @@ export function resumeCheckpointScreen(input) {
     const { cp, resumeSignal, internals, runner } = input;
     const { realApproval: realApprovalRow, face: faceRow, f012: f012Row } = CHECKPOINT_FEATURES;
     if (checkpointVersionOf(cp) > MAX_SUPPORTED_CHECKPOINT_VERSION) {
-        throw new CheckpointError("checkpoint.unsupported_version", `checkpoint version ${checkpointVersionOf(cp)} is newer than this worker supports (max ${MAX_SUPPORTED_CHECKPOINT_VERSION})`, { reason: "version_newer" });
+        throw new CheckpointError("checkpoint.unsupported_version", `checkpoint requires reader capabilities this worker lacks (row format v${checkpointVersionOf(cp)}; this worker reads up to v${MAX_SUPPORTED_CHECKPOINT_VERSION}) — resume it on a worker at or above the version that parked it`, { reason: "version_newer" });
     }
+    const requirements = judgeCheckpointRequirements(cp);
+    if (requirements.kind === "lacking")
+        throw new CheckpointError("checkpoint.unsupported_version", `checkpoint requires reader capabilities this worker lacks (${requirements.words.join(", ")}) — resume it on a worker at or above the version that parked it`, { reason: "version_newer", requires: requirements.words });
+    if (requirements.kind === "damaged")
+        throw new CheckpointError("checkpoint.invalid_outcome", `this checkpoint's reader-requirement list does not match the row (${requirements.why}) — refusing to resume a damaged row (corruption guard), the checkpoint stays pending; no worker can resume it: start the task again`, { reason: "requirements_damaged" });
     const preCasGateBit = cp.gate.kind === "irreversible_ask" ? cp.gate.realApproval : undefined;
     const preCasBitWellFormed = preCasGateBit !== undefined && typeof preCasGateBit === "object" && isAskOrigin(preCasGateBit.origin);
     const faceSaysGoverned = (cp.state.readFace?.realApproval) === true;
@@ -37,7 +43,8 @@ export function resumeCheckpointScreen(input) {
             (faceCandidate.denyEntries === undefined ||
                 (Array.isArray(faceCandidate.denyEntries) &&
                     faceCandidate.denyEntries.every((e) => persistedReadDenyEntryProblem(e) === null)));
-        if (checkpointVersionOf(cp) >= faceRow.version ? !faceWellFormed : faceSectionRaw !== undefined) {
+        const v = checkpointVersionOf(cp);
+        if (v === faceRow.version ? !faceWellFormed : v < faceRow.version ? faceSectionRaw !== undefined : faceSectionRaw !== undefined && !faceWellFormed) {
             throw new CheckpointError("checkpoint.invalid_outcome", checkpointVersionOf(cp) >= faceRow.version
                 ? `a v${checkpointVersionOf(cp)} checkpoint must carry a well-formed read-face section (state.readFace) — this row's is missing or malformed; refusing to resume a damaged read-face row (corruption / downgrade guard), the checkpoint stays pending`
                 : `a v${checkpointVersionOf(cp)} checkpoint carries a read-face section no release of that version ever minted — refusing to honor a fabricated read-face state (corruption / forgery guard), the checkpoint stays pending`, { reason: checkpointVersionOf(cp) >= faceRow.version ? "read_face_damaged" : "read_face_forged" });
@@ -53,7 +60,7 @@ export function resumeCheckpointScreen(input) {
             throw new CheckpointError("checkpoint.invalid_outcome", "this checkpoint carries a skill-grant section (state.skillGrants) that does not read as grant rows under this engine — a damaged section, or a row an earlier release wrote whose entry this release reads as nothing (an entry with a surrounding space, say) — refusing to resume without the grant rows and refusals it carries; the checkpoint stays pending: finish it on a worker of the release that parked it, or expire it", { reason: "skill_grants_damaged" });
         for (const field of ["handsRoot", "handsHome", "handsCwd"]) {
             const coordinate = cp.state[field];
-            if (coordinate !== undefined && (typeof coordinate !== "string" || !isAbsolutePathForm(coordinate)))
+            if (coordinate !== undefined && validatePath(coordinate, { intent: "validate-coordinate" }) === undefined)
                 throw new CheckpointError("checkpoint.invalid_outcome", `this checkpoint's state.${field} is not an absolute path — refusing to resume a row whose hands' coordinates are damaged (corruption guard), the checkpoint stays pending`, { reason: "hands_coordinates_damaged" });
         }
     }

package/dist/core/runner/resume-internals-and-config.js

@@ -1,12 +1,12 @@
 import { CheckpointError, readPendingSteerQueue } from "../checkpoint-store.js";
 import { GLOBAL_USAGE_KEY, resolveUsageWindows, usageRetryAfterMs } from "../usage-window-store.js";
 import { placementValueOrAbsent } from "./checkpoint-scope.js";
-import { assertNoRetiredRunnerDeps } from "./retired-runner-deps.js";
+import { assertNoRetiredResumeSeats } from "./retired-runner-deps.js";
 import { resolveMicroCompactKnob } from "./prepare-config-doors.js";
 export function resumeInternalsAndConfig(input) {
     const { cp, config, internals, outcomeGate, runner } = input;
     let windowEntrance;
-    assertNoRetiredRunnerDeps(runner.deps);
+    assertNoRetiredResumeSeats(runner.deps, config, internals);
     resolveMicroCompactKnob(runner.deps.microCompact);
     if (runner.deps.lockedConfig?.keys?.includes("toolPolicy") === true && config.basePolicyForResumeEdit !== undefined) {
         throw new CheckpointError("checkpoint.invalid_outcome", "TaskSpec.basePolicyForResumeEdit is administratively locked by this deployment (locked key \"toolPolicy\") — a task-supplied " +

package/dist/core/runner/resume-policy-outcome.js

@@ -1,11 +1,9 @@
 import { canonicalizeCapturedPlainData, classifyQuestionOutcome, isLiveQuestionFace } from "../ask-question.js";
-import { isHostDecider } from "../gate-outcome.js";
 import { CHECKPOINT_FEATURES, CheckpointError, checkpointVersionOf, winnerFromOutcome } from "../checkpoint-store.js";
-import { policyCannotAnswer, screenApproverAttribution } from "../tool-policy.js";
 import { sanitizeUntrustedText } from "../untrusted-text.js";
-import { assertOutcomeText, describeSuppliedValue, pendingContentAskCallId, sameWinner } from "./decide-continuation.js";
+import { assertOutcomeText, captureHostDecision, describeSuppliedValue, pendingContentAskCallId, refuseSuppliedKeys, sameWinner, SUPPLIED_RECORD_KEY } from "./decide-continuation.js";
 const REFUSED_DECIDE_KEYS = [
-    ["gateOutcome", "the settlement record is minted by core from the host's decision facts and the row's origin, never supplied"],
+    SUPPLIED_RECORD_KEY,
     ["settledBy", 'a retired key — the host supplies decision FACTS as hostDecision{decidedBy: "person" | "sla_timeout" | "policy", approver?} and core mints the settlement word from them'],
     ["approver", "a retired key — the attribution rides the facts it belongs to, as hostDecision.approver"],
 ];
@@ -43,35 +41,10 @@ export function resumePolicyOutcome(input) {
         if (decision !== "allow" && decision !== "deny") {
             throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the policy_ask domain — a decide is exactly "allow" or "deny"; refusing pre-CAS, the checkpoint stays pending`);
         }
-        for (const [key, why] of REFUSED_DECIDE_KEYS) {
-            if (Reflect.get(decide, key) !== undefined) {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume carries \`${key}\` — ${why}; refusing pre-CAS, the checkpoint stays pending`, { field: "hostDecision" });
-            }
-        }
-        const hostDecisionRaw = decide.hostDecision;
-        if (typeof hostDecisionRaw !== "object" || hostDecisionRaw === null) {
-            throw new CheckpointError("checkpoint.invalid_outcome", `resume carries no hostDecision — a policy_ask decide names who decided it ({ decidedBy: "person" | "sla_timeout" | "policy", approver? }); refusing pre-CAS, the checkpoint stays pending`, { field: "hostDecision" });
-        }
-        const decidedBy = hostDecisionRaw.decidedBy;
-        if (!isHostDecider(decidedBy)) {
-            throw new CheckpointError("checkpoint.invalid_outcome", `resume hostDecision.decidedBy "${describeSuppliedValue(decidedBy)}" is outside the closed set — it is exactly "person", "sla_timeout" or "policy"; refusing pre-CAS, the checkpoint stays pending`, { field: "hostDecision" });
-        }
-        const cannotAllow = decision !== "allow"
-            ? undefined
-            : decidedBy === "sla_timeout"
-                ? ` — that word names a wait that ended with nobody answering, and it cannot approve an action that EXECUTES (an allow is decided by "person" or "policy")`
-                : policyCannotAnswer(cp, decidedBy)
-                    ? ` on a row that requires real approval — a policy's answer is not a person's, and this row demands a person (decide it as "person", or refuse it as "policy")`
-                    : undefined;
-        if (cannotAllow !== undefined)
-            throw new CheckpointError("checkpoint.invalid_outcome", `resume carries decision "allow" decided by "${decidedBy}"${cannotAllow}; refusing pre-CAS, the checkpoint stays pending`, { field: "hostDecision" });
-        const attribution = screenApproverAttribution(hostDecisionRaw.approver);
-        if (attribution.defect !== undefined) {
-            throw new CheckpointError("checkpoint.invalid_outcome", `resume carries an approver attribution this engine refuses: ${attribution.defect}; refusing pre-CAS, the checkpoint stays pending`, { field: "approver" });
-        }
+        refuseSuppliedKeys(decide, REFUSED_DECIDE_KEYS);
+        const hostDecision = captureHostDecision(cp, decide.hostDecision, "policy_ask", { word: decision, allows: decision === "allow" });
         const reason = decide.reason;
         assertOutcomeText(reason, "reason");
-        const approverCell = attribution.approver !== undefined ? { approver: attribution.approver } : {};
         plainPolicyOutcome = {
             gate: "policy_ask",
             boundCallId: decide.boundCallId,
@@ -80,7 +53,7 @@ export function resumePolicyOutcome(input) {
             ...(updatedInput !== undefined ? { updatedInput } : {}),
             ...(reason !== undefined ? { reason } : {}),
             ...(redeemedAnswer !== undefined ? { answer: redeemedAnswer } : {}),
-            hostDecision: { decidedBy, ...approverCell },
+            hostDecision,
         };
         if (plainPolicyOutcome.decision === "deny" && plainPolicyOutcome.reason && sanitizeUntrustedText(plainPolicyOutcome.reason) !== plainPolicyOutcome.reason) {
             throw new CheckpointError("checkpoint.invalid_outcome", "resume deny/reject reason must not contain a </system-reminder> tag");

package/dist/core/runner/resume-review-outcome.js

@@ -1,7 +1,7 @@
 import { CheckpointError } from "../checkpoint-store.js";
 import { isGateKind, PAUSE_REGISTRY, resumeGateMatches } from "../pause-registry.js";
 import { sanitizeUntrustedText } from "../untrusted-text.js";
-import { assertOutcomeText, describeSuppliedValue } from "./decide-continuation.js";
+import { assertOutcomeText, captureHostDecision, describeSuppliedValue, refuseSuppliedKeys, SUPPLIED_RECORD_KEY } from "./decide-continuation.js";
 export function resumeReviewOutcome(input) {
     const { cp, outcome, outcomeGate, wakeMessage } = input;
     const gateMatch = isGateKind(cp.gate.kind) && resumeGateMatches(cp.gate.kind, outcomeGate);
@@ -20,6 +20,8 @@ export function resumeReviewOutcome(input) {
         if (decision !== "approve" && decision !== "edit" && decision !== "reject") {
             throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the plan_review domain — a plan review is exactly "approve", "edit" or "reject"; refusing pre-CAS, the checkpoint stays pending`);
         }
+        refuseSuppliedKeys(decide, [SUPPLIED_RECORD_KEY]);
+        const hostDecision = captureHostDecision(cp, decide.hostDecision, "plan_review", { word: decision, allows: decision !== "reject" });
         assertOutcomeText(editedPlan, "editedPlan");
         assertOutcomeText(reason, "reason");
         plainReviewOutcome = {
@@ -27,6 +29,7 @@ export function resumeReviewOutcome(input) {
             decision,
             ...(editedPlan !== undefined ? { editedPlan } : {}),
             ...(reason !== undefined ? { reason } : {}),
+            hostDecision,
         };
     }
     else if (cp.gate.kind === "needs_review") {

package/dist/core/runner/retired-runner-deps.d.ts

@@ -1,5 +1,11 @@
 import type { RunnerDeps } from "../types.js";
+import type { ResumeTaskConfig, RunInternals } from "./contracts.js";
 /** Runs on the caller's own argument at `new Runner` (the only point that still sees an inherited or
  *  non-enumerable seat — construction spreads deps into plain objects), and again in the pre-first-await
  *  config-doors phase and pre-CAS on a resume. */
 export declare function assertNoRetiredRunnerDeps(deps: RunnerDeps): void;
+/** The resume ladder's pre-claim door: the retired seats of the deps, then the retired members of the caller policies this
+ *  resume installs (the prepare's own resolution, `callerPolicySeats`) and of the inherited constraints it is handed. The edit
+ *  re-check runs the resume-edit policy before the claim, and a refusal after the claim would burn the token on a store
+ *  without `reopen`. */
+export declare function assertNoRetiredResumeSeats(deps: RunnerDeps, config: ResumeTaskConfig, internals: RunInternals | undefined): void;

package/dist/core/runner/retired-runner-deps.js

@@ -1,10 +1,19 @@
-import { assertNoRetiredKeys } from "../retired-keys.js";
+import { assertNoRetiredKeys, assertNoRetiredToolPolicyKeys } from "../retired-keys.js";
+import { assertCallerPoliciesCurrent, callerPolicySeats } from "../locked-config.js";
 const RETIRED_RUNNER_DEPS_KEYS = {
     legacyRewindBoundaryProbe: "the rewind refusal always names both possibilities (never existed / retired whole-tree era); a deployment that holds that era's table answers the question on its own surface",
     peerAdmission: "the peer lane's knob table is `RunnerDeps.peerLane` (the same fields: admission gate, delivery budgets, listing window)",
+    builtinWorkflows: "the engine ships no built-in named workflows — the Workflow tool's `{name}` resolves only `RunnerDeps.workflowScriptStore`; register any named workflow there",
     graderEnvFactory: "the grader env reaches the repair loop as `RepairLoopConfig.graderEnv`, minted by the trusted control plane (`assertOracleIsolation` / `GraderEnv` unchanged)",
     "hands.readCyberReminder": "a Read result carries only the reminders about that read (an empty file, an offset past the end, a file already in context) — no standing content-safety tail, so there is nothing to switch; a deployment that wants that sentence states it in its own `appendSystemPrompt`",
+    memorySessionIncarnation: "the occupant behind a session id is a cell of the session row now — `SessionMetadata.incarnation` on the metadata `Session.getMetadata()` returns (forks also `forkedFromIncarnation`), with `SessionStore.incarnationOf` for by-id readers; put the token the old seat answered on your sessions instead. A deployment that drops the seat without surfacing the cell loses the axis: records bind by session id alone",
 };
 export function assertNoRetiredRunnerDeps(deps) {
     assertNoRetiredKeys(deps, RETIRED_RUNNER_DEPS_KEYS, "RunnerDeps");
 }
+export function assertNoRetiredResumeSeats(deps, config, internals) {
+    assertNoRetiredRunnerDeps(deps);
+    assertCallerPoliciesCurrent(callerPolicySeats(config, deps, deps.lockedConfig?.keys?.includes("toolPolicy") === true));
+    for (const constraint of internals?.inheritedGate?.parentConstraints ?? [])
+        assertNoRetiredToolPolicyKeys(constraint.policy);
+}

package/dist/core/runner/run-brain-sinks.d.ts

@@ -1,4 +1,5 @@
 import type { ReasoningWireFacts } from "../../brain/reasoning.js";
+import { type ExtraBodyDroppedSeatInput } from "./extra-body-dropped-seat.js";
 import type { PushQueue } from "../push-queue.js";
 import type { TaskEvent } from "../types.js";
 import type { RunInternals, RunState } from "./contracts.js";
@@ -19,11 +20,14 @@ export interface RunBrainSinksInput {
     parentToolCallId: string | undefined;
     /** borrowed-readonly — the reasoning lane's wire-facts consumer, the third sink the composition installs. */
     observeReasoningWireFacts: (facts: ReasoningWireFacts) => void;
+    /** borrowed-readonly — the notice sink and the leg's ids; the fourth sink's announcer is minted from them. */
+    notice: ExtraBodyDroppedSeatInput;
 }
 export interface RunBrainSinksResult {
     /** The subagent's human display name for its `task_progress` ticks, or undefined. */
     subagentName: string | undefined;
     /** Compose the three brain ALS sinks around a brain-driving call. */
     withBrainSinks: <T>(fn: () => Promise<T>) => Promise<T>;
+    withExtraBodyDroppedSink: <T>(fn: () => Promise<T>) => Promise<T>;
 }
 export declare function runBrainSinks(input: RunBrainSinksInput): RunBrainSinksResult;

package/dist/core/runner/run-brain-sinks.js

@@ -1,9 +1,10 @@
 import { runWithBrainTelemetry, runWithReasoningWireFacts, runWithStatusSink } from "../../brain/status-sink.js";
+import { createExtraBodyDroppedScope } from "./extra-body-dropped-seat.js";
 import { createSafeNotifier, observeThenableRejection } from "../safe-notify.js";
 import { emitTrace } from "../trace.js";
 import { inlineUntrusted } from "../untrusted-text.js";
 export function runBrainSinks(input) {
-    const { queue, internals, rs, ident, parentToolCallId, observeReasoningWireFacts } = input;
+    const { queue, internals, rs, ident, parentToolCallId, observeReasoningWireFacts, notice } = input;
     const subagentName = parentToolCallId !== undefined && internals?.agentName !== undefined ? inlineUntrusted(internals.agentName.slice(0, 320), 80) : undefined;
     const statusSinkNotifier = createSafeNotifier({
         onError: (f) => console.warn(`[sema-core] ${f.site}: run-internals status sink threw (contained; further failures counted, not re-disclosed): ${f.error.message}`),
@@ -22,6 +23,8 @@ export function runBrainSinks(input) {
             ...(s.maxRetries !== undefined ? { maxRetries: s.maxRetries } : {}),
             ...(s.errClass !== undefined ? { errClass: s.errClass } : {}),
             ...(s.errorStatus !== undefined ? { errorStatus: s.errorStatus } : {}),
+            ...(s.providerCondition !== undefined ? { providerCondition: s.providerCondition } : {}),
+            ...(s.providerConditionSource !== undefined ? { providerConditionSource: s.providerConditionSource } : {}),
             ...ident(),
         };
         Object.freeze(frame);
@@ -59,5 +62,5 @@ export function runBrainSinks(input) {
                         : { kind: "vision.placeholder", version: 1, taskId: rs.telemetry.taskId, count: t.count, ts: Date.now() });
     };
     const withBrainSinks = (fn) => runWithStatusSink(statusEmit, () => runWithBrainTelemetry(telemetryEmit, () => runWithReasoningWireFacts(observeReasoningWireFacts, fn)));
-    return { subagentName, withBrainSinks };
+    return { subagentName, withBrainSinks, withExtraBodyDroppedSink: createExtraBodyDroppedScope(notice) };
 }

package/dist/core/runner/run-harness-handlers.js

@@ -9,9 +9,10 @@ import { usageCostMicroUsd } from "./usage-accounting.js";
 import { advanceCadenceClock, reduceToolEnd } from "./turn-attachments.js";
 import { gatedCallIdOf } from "./park-commit.js";
 import { hasVerifiableStructureSignal } from "./grounding-signal.js";
-import { batchResponseDigest, toolEndBodyFrom } from "./tool-end-body.js";
+import { announceToolCall, batchResponseDigest, emitSettled } from "./tool-end-body.js";
 import { createResponseModelSeat } from "./response-model-seat.js";
 import { createToolCallIdFoldSeat } from "./tool-call-id-fold-seat.js";
+import { createFinishReasonSeat } from "./finish-reason-seat.js";
 import { createToolTurnIncompleteSeat } from "./tool-turn-repair-seat.js";
 import { wireOf } from "../tool-name-readings.js";
 import { rosterToolName } from "../tool-roster.js";
@@ -20,7 +21,13 @@ export function createHarnessHandlers(input) {
     const responseModelSeat = createResponseModelSeat(deps.runnerHooks.onNotice, { sessionId: prepared.sessionId, runId: prepared.runId });
     const toolCallIdFoldSeat = createToolCallIdFoldSeat(deps.runnerHooks.onNotice, { sessionId: prepared.sessionId, runId: prepared.runId });
     const toolTurnIncompleteSeat = createToolTurnIncompleteSeat(deps.runnerHooks.onNotice, { sessionId: prepared.sessionId, runId: prepared.runId });
+    const finishReasonSeat = createFinishReasonSeat(deps.runnerHooks.onNotice, { sessionId: prepared.sessionId, runId: prepared.runId });
     const { spec, queue, internals, ident, parentToolCallId, subagentName, pushContent, emitCommitted, startedToolCallIds, toolStartAt, toolProgress, writeFamilyOf, toolLabels, postToolBatchHook, batchArgs, internalsNotifier } = deps;
+    const frames = { push: (f) => pushContent({ ...f, ...ident() }), structured: prepared.structuredProjector };
+    const startOf = (e) => {
+        const label = toolLabels.get(e.toolName);
+        return { toolCallId: e.toolCallId, spelledName: e.toolName, wireName: rosterToolName(prepared.toolRosterDeltas.current, e.toolName), ...(label !== undefined ? { label } : {}), args: e.args };
+    };
     let lastWorkspaceCwd = prepared.cwdRef?.current;
     const announceWorkspaceMove = () => {
         const cwdNow = prepared.cwdRef?.current;
@@ -155,6 +162,7 @@ export function createHarnessHandlers(input) {
             rs.turn.turnResponseModel = responseModelSeat.observe(m);
             toolCallIdFoldSeat.observe(m);
             toolTurnIncompleteSeat.observe(m);
+            finishReasonSeat.observe(m);
         }
         if (m.role === "assistant") {
             const rep = m.repetition;
@@ -202,7 +210,6 @@ export function createHarnessHandlers(input) {
         const startAt = Date.now();
         toolStartAt.set(event.toolCallId, startAt);
         startedToolCallIds.add(event.toolCallId);
-        toolProgress.noteStart(event.toolCallId, event.toolName);
         batchArgs?.set(event.toolCallId, event.args);
         stats.toolCalls += 1;
         if (spec.finalVerification === true && !(rs.counters.finalVerifyInjections === 0 ? rs.counters.groundingSignalPreR9 : rs.counters.groundingSignalPostR9) && hasVerifiableStructureSignal(event.args)) {
@@ -213,19 +220,11 @@ export function createHarnessHandlers(input) {
         }
         const activityArg = primaryActivityArg(event.args);
         internalsNotifier.notify(() => observeThenableRejection(internals?.onActivity?.({ phase: "start", toolCallId: event.toolCallId, toolName: event.toolName, at: startAt, ...(activityArg !== undefined ? { arg: activityArg } : {}) }), internalsNotifier, "runtask.onActivity.start"), "runtask.onActivity.start");
-        pushContent({
-            type: "tool_start",
-            toolCallId: event.toolCallId,
-            toolName: event.toolName,
-            ...(toolLabels.get(event.toolName) !== undefined ? { label: toolLabels.get(event.toolName) } : {}),
-            args: event.args,
-            ...ident(),
-        });
+        announceToolCall(prepared.toolOccurrences, startOf(event), frames);
     };
     const onToolEnd = (event) => {
         const toolStarted = toolStartAt.get(event.toolCallId);
         toolStartAt.delete(event.toolCallId);
-        toolProgress.noteEnd(event.toolCallId);
         const toolNow = Date.now();
         if (!rs.counters.wroteThisRun && (prepared.toolEffects.get(wireOf("verify.wroteThisRun", { toolName: rosterToolName(prepared.toolRosterDeltas.current, event.toolName) })) ?? "write") !== "read") {
             rs.counters.wroteThisRun = true;
@@ -251,18 +250,6 @@ export function createHarnessHandlers(input) {
                 batchArgs?.delete(event.toolCallId);
             }
         }
-        emitTrace(rs.telemetry.tracer, () => ({
-            kind: "tool.call",
-            version: 1,
-            taskId: rs.telemetry.taskId,
-            name: event.toolName,
-            toolCallId: event.toolCallId,
-            turn: stats.turns + 1,
-            durationMs: toolStarted !== undefined ? toolNow - toolStarted : 0,
-            ok: !event.isError,
-            ts: toolNow,
-        }));
-        internalsNotifier.notify(() => observeThenableRejection(internals?.onActivity?.({ phase: "end", toolCallId: event.toolCallId, toolName: event.toolName, isError: event.isError, at: toolNow }), internalsNotifier, "runtask.onActivity.end"), "runtask.onActivity.end");
         if (prepared.lspDiagnostics && !event.isError) {
             const name = event.toolName;
             if (name === "Edit" || name === "Write" || name === "NotebookEdit") {
@@ -272,18 +259,24 @@ export function createHarnessHandlers(input) {
                     prepared.lspDiagnostics.nudge(p);
             }
         }
-        const gate = prepared.gateOutcomes.get(event.toolCallId);
-        if (gate !== undefined)
-            prepared.gateOutcomes.delete(event.toolCallId);
-        pushContent({
-            type: "tool_end",
-            toolCallId: event.toolCallId,
-            toolName: event.toolName,
-            ...(toolLabels.get(event.toolName) !== undefined ? { label: toolLabels.get(event.toolName) } : {}),
+        const settled = emitSettled(prepared.toolOccurrences, startOf(event), {
+            result: event.result,
             isError: event.isError,
-            ...toolEndBodyFrom(event.result, event.isError, prepared.structuredProjector, gate, prepared.abortController.signal.aborted ? gatedCallIdOf(prepared) : undefined),
-            ...ident(),
-        });
+            ...(event.notExecuted === true ? { notExecuted: true } : {}),
+            ...(() => { const id = prepared.abortController.signal.aborted ? gatedCallIdOf(prepared) : undefined; return id !== undefined ? { gatedCallIdOfRun: id } : {}; })(),
+        }, frames);
+        emitTrace(rs.telemetry.tracer, () => ({
+            kind: "tool.call",
+            version: 1,
+            taskId: rs.telemetry.taskId,
+            name: event.toolName,
+            toolCallId: event.toolCallId,
+            turn: stats.turns + 1,
+            durationMs: toolStarted !== undefined ? toolNow - toolStarted : 0,
+            ok: !settled.isError,
+            ts: toolNow,
+        }));
+        internalsNotifier.notify(() => observeThenableRejection(internals?.onActivity?.({ phase: "end", toolCallId: event.toolCallId, toolName: event.toolName, isError: settled.isError, at: toolNow }), internalsNotifier, "runtask.onActivity.end"), "runtask.onActivity.end");
         announceWorkspaceMove();
         if (spec.outputSchema && event.toolName === OUTPUT_TOOL_NAME) {
             if (event.isError) {

package/dist/core/runner/run-leg.d.ts

@@ -38,8 +38,6 @@ export interface RunLegInput<R> {
     resume: ResumeRun | undefined;
     /** borrowed-mutable — the run's mutable state: the limit flags and the platform terminal are written by the entrance gates. */
     rs: RunState;
-    /** borrowed-readonly — the trusted spawn-side fact the rejection boundary reads (a delegated child's bare refusal halts no batch). */
-    isDelegatedChild: boolean;
     /** borrowed-readonly — the API-boundary attribution snapshot of the objective's actor (the objective leg's speaker envelope). */
     entryActor: ActorAssertion | undefined;
     /** borrowed-readonly — the effective walltime window (undefined = unbounded): `<= 0` refuses the first turn. */

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

@@ -13,18 +13,18 @@ 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, policyCannotAnswer, policyRefusalMessage, refuseOutOfContractDecision } from "../tool-policy.js";
+import { advertisedWritableRootsSeat, exemptRootsSeat, humanRefusalSentence, policyCannotAnswer, policyRefusalMessage, refuseOutOfContractDecision } from "../tool-policy.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 "./assemble-result.js";
+import { errorCodeOf } from "./terminal-account.js";
 import { DEFAULT_PRECALL_OUTPUT_TOKENS, platformLimitTerminal } from "./clock-and-limits.js";
 import { mintOutputStyleReminder, owedPostureText } from "./compaction-restate.js";
 import { deepJsonEqual, resumeContinuation } from "./decide-continuation.js";
 import { chainCannotJudge } from "./call-hook-stations.js";
 import { settleExecutionRecord } from "./execution-record.js";
 import { holdPrompt } from "./prompt-block.js";
-import { mintGateOutcome } from "./gate-exit.js";
+import { frozenInputSnapshot } from "./gate-exit.js";
 import { withGateTimeout } from "../gate-bounded-await.js";
 import { resolveGitLegDelivery, wrapGitFrame } from "./git-leg-delivery.js";
 import { GIT_STATUS_ECHO_PREVIEW } from "./git-status-frame.js";
@@ -32,7 +32,7 @@ import { toImageContent } from "./image.js";
 import { maybeHumanRejectionHalt } from "./prepare-gate-stations.js";
 import { nextHumanInputSeq } from "./steer-admission.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
-import { toolEndBodyFrom, toolResultMsg } from "./tool-end-body.js";
+import { announceToolCall, emitSettled, toolResultMsg } from "./tool-end-body.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";
@@ -40,7 +40,7 @@ import { asThrownError, thrownMarksOf, thrownText } from "../thrown-value.js";
 import { ruleSourcePhrase } from "../rule-denial-sentence.js";
 import { wireOf } from "../tool-name-readings.js";
 export async function runLeg(input) {
-    const { spec, queue, prepared, resume, rs, isDelegatedChild, entryActor, effectiveTimeoutMs, timeout, pushContent, ident, emitCommitted, writeFamilyOf, startedToolCallIds, announceWorkspaceMove, withBrainSinks, flushGitMirror, loopLatch, notificationLane, unsubscribeTaskNotifications, unsubGitRetry, unsubBoundary, unsub, runner, next } = input;
+    const { spec, queue, prepared, resume, rs, entryActor, effectiveTimeoutMs, timeout, pushContent, ident, emitCommitted, writeFamilyOf, startedToolCallIds, announceWorkspaceMove, withBrainSinks, flushGitMirror, loopLatch, notificationLane, unsubscribeTaskNotifications, unsubGitRetry, unsubBoundary, unsub, runner, next } = input;
     let final;
     let threw;
     let abortedLive = false;
@@ -112,7 +112,7 @@ export async function runLeg(input) {
                 rs.limits.budgetAxis = "cost";
             }
             else {
-                let continuation = resumeContinuation(resume, prepared.reminderMark, prepared.fullShellReachable);
+                let continuation = resumeContinuation(resume, prepared.reminderMark, prepared.fullShellReachable, prepared.hookIdentity.isDelegatedChild);
                 const bgSnapshot = resume.cp.state.runningBackgroundTasks;
                 let orphanTasks = [];
                 if (bgSnapshot !== undefined && bgSnapshot.length > 0) {
@@ -239,7 +239,7 @@ export async function runLeg(input) {
                 }
                 const pending = resume.cp.pendingAction;
                 const rejectionHalt = pending.kind === "tool_approval" && resume.outcome.gate === "policy_ask"
-                    ? maybeHumanRejectionHalt({ gate: resume.outcome.gateOutcome, isDelegatedChild, toolName: pending.toolName, toolCallId: pending.toolCallId })
+                    ? maybeHumanRejectionHalt({ gate: resume.outcome.gateOutcome, isDelegatedChild: prepared.hookIdentity.isDelegatedChild, toolName: pending.toolName, toolCallId: pending.toolCallId })
                     : undefined;
                 if (rejectionHalt !== undefined && pending.kind === "tool_approval")
                     prepared.batchHaltRef.current = { rejectedToolCallId: pending.toolCallId };
@@ -572,27 +572,26 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     const resolvedArgs = humanRewrite !== undefined ? humanRewrite : pendingAction.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;
-    emit({ type: "tool_start", toolCallId: pendingAction.toolCallId, toolName: spelledName, ...pendingLabel, args: resolvedArgs });
-    const settleEnd = async (isError, result, gate = decidedGate) => {
-        prepared.toolProgressRef.current?.noteEnd(pendingAction.toolCallId);
-        emit({ type: "tool_end", toolCallId: pendingAction.toolCallId, toolName: spelledName, ...pendingLabel, isError, ...toolEndBodyFrom(result, isError, prepared.structuredProjector, gate) });
+    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) => {
+        if (refusedBy !== undefined)
+            occurrences.refuse(pendingAction.toolCallId, refusedBy);
+        const gate = emitSettled(occurrences, callStart, { result, isError }, { push: emit, structured: prepared.structuredProjector }).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 vetoed = (layer) => mintGateOutcome({
-        deniedBy: layer,
-        ...(outcome.gateOutcome?.settlement !== undefined && outcome.gateOutcome.origin !== undefined ? { settled: { settlement: outcome.gateOutcome.settlement, origin: outcome.gateOutcome.origin } } : {}),
-    });
     if (outcome.decision === "deny") {
         const settlementKind = outcome.gateOutcome?.settlement?.kind;
-        const defaultDenial = settlementKind === "park_sla_expired"
-            ? `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.`
-            : `The pending tool call "${pendingAction.toolName}" was denied by an approver.`;
         const reason = settlementKind === "policy_refused"
             ? policyRefusalMessage(pendingAction.toolName, undefined, decidersNote(outcome.reason))
-            : outcome.reason
-                ? delimitUntrusted("reviewer note", outcome.reason, REVIEWER_NOTE_MAX_BODY)
-                : defaultDenial;
+            : settlementKind === "park_sla_expired"
+                ? outcome.reason
+                    ? delimitUntrusted("reviewer note", outcome.reason, REVIEWER_NOTE_MAX_BODY)
+                    : `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));
         emitCommitted(eid, "toolResult", pendingAction.toolCallId);
@@ -608,18 +607,18 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     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 }, vetoed("hook"));
+        await settleEnd(true, { content: hookDenial }, "hook");
         emitCommitted(await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, hookDenial, true)), "toolResult", pendingAction.toolCallId);
         return;
     }
     const executedArgs = humanRewrite !== undefined ? resolvedArgs : screened !== undefined ? screened.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), ...(beltReading !== undefined ? { targetReading: 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 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 }, vetoed("policy"));
+        await settleEnd(true, { content: chainDenial }, "policy");
         emitCommitted(await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, chainDenial, true)), "toolResult", pendingAction.toolCallId);
         return;
     }
@@ -644,7 +643,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
                     ? " (the call as it would run requires a person's approval, and this decision was the deployment's policy)"
                     : " (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 }, vetoed("policy"));
+            await settleEnd(true, { content: editedDenial }, "policy");
             const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, editedDenial, true));
             emitCommitted(eid, "toolResult", pendingAction.toolCallId);
             return;
@@ -654,7 +653,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     const gateOrgGoverned = realApprovalOrgFact(gateRealApproval) !== undefined;
     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 }, vetoed("org"));
+        await settleEnd(true, { content: unwiredDenial }, "org");
         const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, unwiredDenial, true));
         emitCommitted(eid, "toolResult", pendingAction.toolCallId);
         return;
@@ -688,7 +687,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
                 ? ` Governance disclosures: ${inlineUntrusted(org.disclosures.join("; "), ORG_DISCLOSURE_MAX_CHARS)}.`
                 : "";
             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 }, vetoed("org"));
+            await settleEnd(true, { content: orgDenial }, "org");
             const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, orgDenial, true));
             emitCommitted(eid, "toolResult", pendingAction.toolCallId);
             return;
@@ -698,7 +697,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
         const narrowed = refuseOutOfContractDecision(await prepared.denyNarrowingPolicy.check(beltReq(), prepared.abortController.signal));
         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 }, vetoed("policy"));
+            await settleEnd(true, { content: narrowedDenial }, "policy");
             const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, narrowedDenial, true));
             emitCommitted(eid, "toolResult", pendingAction.toolCallId);
             return;
@@ -707,7 +706,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     const skillRefusal = skillRowRefusal(prepared.skillGrants, beltReq());
     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 }, vetoed("policy"));
+        await settleEnd(true, { content: skillDenial }, "policy");
         emitCommitted(await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, skillDenial, true)), "toolResult", pendingAction.toolCallId);
         return;
     }
@@ -730,7 +729,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
                     ? `a standing deny rule of yours (${disclosedRuleSet(read.hit?.rules ?? [])}) now refuses it`
                     : `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 }, vetoed("persisted_rule"));
+            await settleEnd(true, { content: ruleDenial }, "persisted_rule");
             const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, ruleDenial, true));
             emitCommitted(eid, "toolResult", pendingAction.toolCallId);
             return;
@@ -754,7 +753,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
             }
             if (!answered || verdict.disposition === "refuse" || (unseen && verdict.disposition !== "vouch")) {
                 const readDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: ${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, ...(verdict.details !== undefined ? { details: verdict.details } : {}) }, vetoed("read_boundary"));
+                await settleEnd(true, { content: readDenial, ...(verdict.details !== undefined ? { details: verdict.details } : {}) }, "read_boundary");
                 const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, readDenial, true));
                 emitCommitted(eid, "toolResult", pendingAction.toolCallId);
                 return;
@@ -765,7 +764,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     const grantRefusal = parkedSkillApprovalRefusal(pendingAction, executedArgs, prepared.skillSpecs, SKILL_TOOL_NAME, "execution");
     if (grantRefusal !== undefined) {
         const grantDenial = formatHookFeedback(grantRefusal, prepared.reminderMark);
-        await settleEnd(true, { content: grantDenial }, vetoed("policy"));
+        await settleEnd(true, { content: grantDenial }, "policy");
         emitCommitted(await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, grantDenial, true)), "toolResult", pendingAction.toolCallId);
         return;
     }
@@ -778,7 +777,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     const args = executedArgs;
     screened?.admit();
     onExecuteStart?.(pendingAction.toolCallId);
-    prepared.toolProgressRef.current?.noteStart(pendingAction.toolCallId, pendingAction.toolName);
+    occurrences.execute(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;

package/dist/core/runner/run-terminal-adoption.js

@@ -2,13 +2,14 @@ import { DEFAULT_COMPACTION_INSTRUCTIONS, maybeCompact } from "../auto-compactio
 import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
 import { appendInterruptionMarker, reconcileInterruptedSession } from "../session-reconcile.js";
 import { emitTrace } from "../trace.js";
-import { answerSettled, errorCodeOf } from "./assemble-result.js";
+import { answerSettled } from "./assemble-result.js";
+import { errorCodeOf } from "./terminal-account.js";
 import { awaitChargeWithSlowDisclosure, discloseUnevaluableWindow } from "./clock-and-limits.js";
 import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption, legCompactionSettings, legContextOverlayOption } from "./compaction-call-options.js";
 import { compactionHookOptions, recordCompactionReuse, seamCCompactionOptions } from "./compaction-seams.js";
 import { compactionRestateOptions } from "./compaction-restate.js";
 import { MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
-import { reconciledToolEndBody } from "./tool-end-body.js";
+import { emitSettled, reconciledEnd } from "./tool-end-body.js";
 import { asThrownError, thrownText } from "../thrown-value.js";
 export async function runTerminalAdoption(input) {
     const { spec, queue, prepared, rs, stats, ident, emitCommitted, startedToolCallIds, toolLabels, timeout, compactionBrain, compactionBreaker, windowSafetyOptions, undrainedUserAtEnd, userInputLostAtEnd, final, abortedLive, userInterruptedLive, runner, sessions, next } = input;
@@ -42,7 +43,7 @@ export async function runTerminalAdoption(input) {
             const report = await reconcileInterruptedSession(prepared.session, prepared.toolEffects, undefined, startedToolCallIds);
             orphansClosed = report.recovered.length;
             for (const orphan of report.recovered) {
-                queue.push({ type: "tool_end", toolCallId: orphan.toolCallId, toolName: orphan.toolName, ...(toolLabels.has(orphan.toolName) ? { label: toolLabels.get(orphan.toolName) } : {}), isError: true, ...reconciledToolEndBody(orphan, prepared.structuredProjector), ...ident() });
+                emitSettled(prepared.toolOccurrences, { toolCallId: orphan.toolCallId, spelledName: orphan.toolName, ...(toolLabels.has(orphan.toolName) ? { label: toolLabels.get(orphan.toolName) } : {}), args: orphan.args }, reconciledEnd(orphan), { push: (f) => queue.push({ ...f, ...ident() }), structured: prepared.structuredProjector });
                 emitCommitted(orphan.entryId, "toolResult", orphan.toolCallId);
             }
             reconcileComplete = true;