@sema-agent/core 5.8.0 → 5.10.0

package/dist/core/runner/runtask.d.ts

@@ -4,6 +4,7 @@ import type { RunInternals } from "./prepare-task.js";
 import { type TaskOutcome } from "../task-outcome.js";
 import { type SideQuerySpec, type SideQueryResult } from "../side-query.js";
 import type { SessionStore } from "../session.js";
+import { type RecoveredOrphan } from "../session-reconcile.js";
 import type { AgentDefinition, RunnerDeps, TaskEvent, TaskResult, TaskSpec, TaskStream } from "../types.js";
 export type ResumeTaskConfig = Omit<TaskSpec, "objective" | "sessionId">;
 interface ResumeRun {
@@ -19,6 +20,17 @@ interface ResumeRun {
     onEnvRestoreFailed?: (reason: ReopenReason) => Promise<void>;
     decisionDelivered?: boolean;
 }
+declare function toolEndBodyFrom(result: unknown, isError: boolean): {
+    output?: unknown;
+    truncated?: boolean;
+    totalChars?: number;
+    structured?: unknown;
+    errorCode?: string;
+};
+export declare function reconciledToolEndBody(orphan: Pick<RecoveredOrphan, "text" | "errorKind">): ReturnType<typeof toolEndBodyFrom>;
+export declare const GOVERNANCE_READ_STALLED: unique symbol;
+export declare function awaitChargeWithSlowDisclosure<T>(charge: Promise<T>, onSlow: () => void, discloseAfterMs?: number): Promise<T>;
+export declare function raceUntilDeadline<T>(p: Promise<T>, deadline: number): Promise<T | typeof GOVERNANCE_READ_STALLED>;
 export declare class Runner {
     private deps;
     readonly sessions: SessionStore;

package/dist/core/runner/runtask.js

@@ -24,7 +24,7 @@ import { cacheFamilyOf, usageCostMicroUsd } from "./usage-accounting.js";
 import { assembleResult, errorCodeOf } from "./assemble-result.js";
 import { ATTACHMENT_BYTE_CAP, CHANGED_FILES_MAX, AGENT_LISTING_REMOVED_HEADER, SKILLS_LISTING_DELTA_HEADER, SKILLS_LISTING_REMOVED_HEADER, advanceCadenceClock, agentListingDeltaHeader, agentListingInitialHeader, replayAnnouncedListing, replayAnnouncedModels, clipToBytes, collectDateChange, collectDueAttachments, collectInstructionsChange, commitAgentListing, commitInstructionsChange, commitSkillsListing, createAttachmentState, rebaseCadenceWindows, reduceToolEnd, renderAgentListingDelta, renderMcpDroppedTools, renderMcpInstructionsDelta, renderOrphanedBackgroundTasks, selectMcpDroppedBatch, renderSkillsListingDelta, renderToolsDelta, stampWriteAnchor } from "./turn-attachments.js";
 import { buildWorkingFileAttachments, centerAdoptionOption, emitInputTruncated } from "./compaction-call-options.js";
-import { prepareTask } from "./prepare-task.js";
+import { prepareTask, resolveCheckpointStore } from "./prepare-task.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
 import { TOOL_SEARCH_NAME } from "./tool-disclosure.js";
 import { hasVerifiableStructureSignal } from "./grounding-signal.js";
@@ -113,6 +113,19 @@ function resumeDecisionWasNegative(resume) {
 }
 const DEFERRED_REISSUE = "[DEFERRED] This tool call shared a batch with a call that suspended for durable approval, so it was " +
     "NOT executed on resume. If you still need it, issue it again now.";
+function toolEndBodyFrom(result, isError) {
+    const o = toolOutputFrom(result);
+    const st = structuredFrom(result);
+    const code = isError ? result?.details?.code : undefined;
+    return {
+        ...(o !== undefined ? { output: o.output, ...(o.truncated ? { truncated: true } : {}), ...(o.totalChars !== undefined ? { totalChars: o.totalChars } : {}) } : {}),
+        ...(st !== undefined ? { structured: st } : {}),
+        ...(typeof code === "string" ? { errorCode: code } : {}),
+    };
+}
+export function reconciledToolEndBody(orphan) {
+    return toolEndBodyFrom({ content: orphan.text, details: { code: orphan.errorKind } }, true);
+}
 function deepJsonEqual(a, b) {
     if (a === b)
         return true;
@@ -230,6 +243,42 @@ function resumeContinuation(resume) {
         `conversation above. Do NOT restart the task or re-run any tool you already ran; continue from this ` +
         `exact point, building on the existing results, and finish the remaining work.`);
 }
+const ENV_DUE_GOVERNANCE_READ_BUDGET_MS = 5_000;
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+const DEADLINE_TICK = Symbol("deadline-tick");
+export const GOVERNANCE_READ_STALLED = Symbol("governance-read-stalled");
+const CHARGE_SETTLE_DISCLOSE_MS = 10_000;
+export async function awaitChargeWithSlowDisclosure(charge, onSlow, discloseAfterMs = CHARGE_SETTLE_DISCLOSE_MS) {
+    let timer = setTimeout(() => {
+        timer = undefined;
+        try {
+            onSlow();
+        }
+        catch {
+        }
+    }, discloseAfterMs);
+    try {
+        return await charge;
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+export async function raceUntilDeadline(p, deadline) {
+    for (let firstPass = true;; firstPass = false) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0 && !firstPass)
+            return GOVERNANCE_READ_STALLED;
+        let timer;
+        const tick = new Promise((res) => {
+            timer = setTimeout(() => res(DEADLINE_TICK), Math.max(0, Math.min(remaining, MAX_TIMER_DELAY_MS)));
+        });
+        const out = await Promise.race([p, tick]).finally(() => clearTimeout(timer));
+        if (out !== DEADLINE_TICK)
+            return out;
+    }
+}
 function platformLimitTerminal(reason, retryAfterMs, moment = "turn_boundary") {
     const message = moment === "entry"
         ? `a deployment usage window is exhausted (RunnerDeps.usageWindows), so the task was refused before its first model call — nothing ran and nothing was spent. There is no checkpoint to suspend into at this point, so the caller re-submits after the window frees, in ${String(retryAfterMs ?? 0)}ms.`
@@ -257,17 +306,39 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
         let platformRetryAfterMs;
         const preemptWillSuspend = preemptHit && prepared.suspendForResource !== undefined;
         if (!preemptWillSuspend && prepared.suspendRef.token === undefined && !prepared.abortController.signal.aborted) {
-            if (prepared.envLifetimeSuspendAt !== undefined && Date.now() >= prepared.envLifetimeSuspendAt) {
-                platformCause = "env_lifetime";
-            }
-            else if (prepared.usageGovernance !== undefined) {
+            const ledgerReadDeadline = prepared.envLifetimeSuspendAt !== undefined ? prepared.envLifetimeSuspendAt + ENV_DUE_GOVERNANCE_READ_BUDGET_MS : undefined;
+            if (prepared.usageGovernance !== undefined) {
                 const governance = prepared.usageGovernance;
                 try {
                     const at = Date.now();
-                    await governance.commit(stats.tokens, at);
-                    platformRetryAfterMs = await governance.check(at);
-                    if (platformRetryAfterMs !== undefined)
-                        platformCause = "usage_window";
+                    await awaitChargeWithSlowDisclosure(governance.commit(stats.tokens, at), () => runnerHooks.onError?.(new Error("the usage ledger CHARGE has not settled after 10s — still waiting (a charge is never abandoned: walking away would double-charge on the end-of-task flush). A wedged ledger store wedges this boundary, now visibly."), { phase: "config", sessionId: prepared.sessionId }));
+                    const windowRead = governance.check(at);
+                    let answer;
+                    if (ledgerReadDeadline !== undefined) {
+                        answer = await raceUntilDeadline(windowRead, ledgerReadDeadline);
+                        if (answer === GOVERNANCE_READ_STALLED) {
+                            void windowRead.catch((lateErr) => {
+                                try {
+                                    runnerHooks.onError?.(lateErr instanceof Error ? lateErr : new Error(String(lateErr)), { phase: "config", sessionId: prepared.sessionId });
+                                }
+                                catch {
+                                }
+                            });
+                            try {
+                                runnerHooks.onError?.(new Error("the usage ledger did not answer before the execution environment's suspend deadline — stopping for the environment, the cause this run can still prove. The window state for this boundary is UNKNOWN and was not enforced."), { phase: "config", sessionId: prepared.sessionId });
+                            }
+                            catch {
+                            }
+                        }
+                    }
+                    else {
+                        answer = await windowRead;
+                    }
+                    if (answer !== GOVERNANCE_READ_STALLED) {
+                        platformRetryAfterMs = answer;
+                        if (platformRetryAfterMs !== undefined)
+                            platformCause = "usage_window";
+                    }
                 }
                 catch (govErr) {
                     rs.limits.platformTerminal = govErr instanceof Error ? govErr : new Error(String(govErr));
@@ -276,6 +347,9 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                     return undefined;
                 }
             }
+            if (platformCause === undefined && prepared.envLifetimeSuspendAt !== undefined && Date.now() >= prepared.envLifetimeSuspendAt) {
+                platformCause = "env_lifetime";
+            }
         }
         if (platformCause !== undefined) {
             const platformSpend = { costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) };
@@ -380,7 +454,7 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
             emitTrace(rs.telemetry.tracer, () => ({ kind: "review.dropped", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
         }
         if (prepared.lspDiagnostics && !prepared.lspDiagnostics.registry.isEmpty() && !prepared.abortController.signal.aborted) {
-            const files = prepared.lspDiagnostics.registry.drain();
+            const files = prepared.lspDiagnostics.registry.drain(prepared.lspDiagnostics.runIdent);
             if (files.length > 0) {
                 queue.push({ type: "diagnostics", files, isNew: true, ...ident() });
                 const block = formatDiagnosticsBlock(files);
@@ -913,7 +987,8 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
                     : {}),
                 ts: callEndAt,
             }));
-            if (prepared.cacheBreakDetector && prepared.cacheFingerprint) {
+            const cacheRowUnknown = m.usageMissing === true || m.stopReason === "aborted";
+            if (prepared.cacheBreakDetector && prepared.cacheFingerprint && !cacheRowUnknown) {
                 const finding = prepared.cacheBreakDetector.observe({
                     turn: stats.turns + 1,
                     systemPrompt: prepared.cacheFingerprint.systemPrompt,
@@ -1049,16 +1124,7 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
             toolName: event.toolName,
             ...(toolLabels.get(event.toolName) !== undefined ? { label: toolLabels.get(event.toolName) } : {}),
             isError: event.isError,
-            ...(() => {
-                const o = toolOutputFrom(event.result);
-                return o !== undefined
-                    ? { output: o.output, ...(o.truncated ? { truncated: true } : {}), ...(o.totalChars !== undefined ? { totalChars: o.totalChars } : {}) }
-                    : {};
-            })(),
-            ...(() => {
-                const st = structuredFrom(event.result);
-                return st !== undefined ? { structured: st } : {};
-            })(),
+            ...toolEndBodyFrom(event.result, event.isError),
             ...ident(),
         });
         announceWorkspaceMove();
@@ -1312,6 +1378,10 @@ export class Runner {
             finally {
                 releaseLock?.();
                 publishReady(handle);
+                manualCompactRef.closed = true;
+                if (manualCompactRef.waiters.length > 0)
+                    manualCompactRef.emitMooted?.("task_ending");
+                manualCompactRef.emitMooted = undefined;
                 drainManualCompactWaiters("mooted");
             }
         })();
@@ -1500,6 +1570,8 @@ export class Runner {
                     throw steeringError("the task is not running");
                 if (opts?.signal?.aborted)
                     return "mooted";
+                if (manualCompactRef.closed)
+                    return "mooted";
                 return new Promise((resolve) => {
                     const signal = opts?.signal;
                     const entry = {
@@ -1515,6 +1587,7 @@ export class Runner {
                                 if (manualCompactRef.waiters.length === 0) {
                                     manualCompactRef.requested = false;
                                 }
+                                manualCompactRef.emitMooted?.("cancelled");
                                 entry.resolve("mooted");
                             }
                         };
@@ -1648,6 +1721,13 @@ export class Runner {
         }, this);
         notificationHarness = prepared.harness;
         notificationSessionId = prepared.sessionId;
+        const runSourceTaskId = spec.taskId ?? prepared.sessionId;
+        const parentToolCallId = internals?.parentToolCallId;
+        const ident = () => parentToolCallId !== undefined ? { eventId: uuidv7(), parentToolCallId, sourceTaskId: runSourceTaskId } : { eventId: uuidv7() };
+        notificationIdent = ident;
+        manualCompactRef.emitMooted = (reason) => {
+            queue.push({ type: "compaction_outcome", outcome: "mooted", trigger: "manual", reason, ...ident() });
+        };
         prepared.harness.onUndrainedEngineNotes = (payloads) => {
             if (notificationSessionId === undefined)
                 return;
@@ -1666,7 +1746,7 @@ export class Runner {
             if (pendingIdle !== undefined) {
                 for (const payload of discloseDroppedPending(pendingIdle)) {
                     deliveredAtTurnOpen.add(taskNotificationDedupKey(payload));
-                    queue.push({ type: "task_notification", notification: payload });
+                    queue.push({ type: "task_notification", notification: payload, ...ident() });
                     void prepared.harness.nextTurn(renderTaskNotificationXml(payload), { provenance: "engine-note", enginePayload: payload }).catch(() => {
                         this.pendingSessionNotifications.pend(prepared.sessionId, payload);
                     });
@@ -1715,7 +1795,7 @@ export class Runner {
         rs.limits.outputRetryCap = resolveOutputRetries(spec.outputRetries);
         rs.limits.effectiveMaxTurns = resolveMaxTurns(spec.limits);
         rs.telemetry.tracer = spec.tracer ?? this.deps.tracer;
-        rs.telemetry.taskId = spec.taskId ?? prepared.sessionId;
+        rs.telemetry.taskId = runSourceTaskId;
         if (taskIdRef) {
             taskIdRef.current = rs.telemetry.taskId;
             taskIdRef.sessionId = prepared.sessionId;
@@ -2063,9 +2143,6 @@ export class Runner {
         const walltimeMonotonicDeadline = effectiveTimeoutMs !== undefined ? rs.telemetry.taskStartMonotonic + effectiveTimeoutMs : undefined;
         rs.counters.walltimeSyncBackstopFired = false;
         const timeout = startTimeout(prepared.harness, prepared.abortController, walltimeMonotonicDeadline !== undefined ? walltimeMonotonicDeadline - performance.now() : undefined, prepared.suspendForResource !== undefined);
-        const parentToolCallId = internals?.parentToolCallId;
-        const ident = () => parentToolCallId !== undefined ? { eventId: uuidv7(), parentToolCallId, sourceTaskId: rs.telemetry.taskId } : { eventId: uuidv7() };
-        notificationIdent = ident;
         const pushContent = (e) => {
             queue.push(e);
             if (parentToolCallId !== undefined && internals?.onForwardEvent) {
@@ -2113,6 +2190,10 @@ export class Runner {
         };
         const withBrainSinks = (fn) => runWithStatusSink(statusEmit, () => runWithBrainTelemetry(telemetryEmit, fn));
         const toolLabels = new Map(prepared.tools.flatMap((t) => (t.label !== undefined && t.label !== t.name ? [[t.name, t.label]] : [])));
+        for (const orphan of prepared.wakeRecovered) {
+            queue.push({ type: "tool_end", toolCallId: orphan.toolCallId, toolName: orphan.toolName, ...(toolLabels.has(orphan.toolName) ? { label: toolLabels.get(orphan.toolName) } : {}), isError: true, ...reconciledToolEndBody(orphan), ...ident() });
+            emitCommitted(orphan.entryId, "toolResult", orphan.toolCallId);
+        }
         const postToolBatchHook = (spec.hooks ?? this.deps.hooks)?.postToolBatch;
         const batchArgs = postToolBatchHook ? new Map() : undefined;
         rs.turn.toolBatch = [];
@@ -2446,7 +2527,7 @@ export class Runner {
             if (resume) {
                 const walltimeExhaustedResume = effectiveTimeoutMs !== undefined && effectiveTimeoutMs <= 0;
                 if (!walltimeExhaustedResume && resume.outcome.gate !== "wake") {
-                    await this.applyResumeDecision(prepared, resume, (e) => queue.push(e), emitCommitted, (toolName, details) => {
+                    await this.applyResumeDecision(prepared, resume, (e) => pushContent({ ...e, ...ident() }), emitCommitted, (toolName, details) => {
                         if (rs.attach.attachState === undefined)
                             return;
                         const family = writeFamilyOf(toolName);
@@ -2638,6 +2719,7 @@ export class Runner {
         }
         finally {
             timeout.clear();
+            prepared.lspDiagnostics?.registry.releaseRun(prepared.lspDiagnostics.runIdent);
             prepared.abortController.abort();
             prepared.releaseSignal();
             try {
@@ -2658,7 +2740,7 @@ export class Runner {
         }
         if (prepared.usageGovernance !== undefined) {
             try {
-                await prepared.usageGovernance.commit(stats.tokens, Date.now());
+                await awaitChargeWithSlowDisclosure(prepared.usageGovernance.commit(stats.tokens, Date.now()), () => this.deps.onError?.(new Error("the usage ledger's FINAL charge has not settled after 10s — still waiting (a charge is never abandoned: walking away would double-charge on a later flush). A wedged ledger store wedges this teardown, now visibly."), { phase: "config", sessionId: prepared.sessionId }));
             }
             catch (flushErr) {
                 this.deps.onError?.(flushErr, { phase: "config", sessionId: prepared.sessionId });
@@ -2673,7 +2755,7 @@ export class Runner {
             try {
                 const report = await reconcileInterruptedSession(prepared.session, prepared.toolEffects, undefined, startedToolCallIds);
                 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, ...ident() });
+                    queue.push({ type: "tool_end", toolCallId: orphan.toolCallId, toolName: orphan.toolName, ...(toolLabels.has(orphan.toolName) ? { label: toolLabels.get(orphan.toolName) } : {}), isError: true, ...reconciledToolEndBody(orphan), ...ident() });
                     emitCommitted(orphan.entryId, "toolResult", orphan.toolCallId);
                 }
             }
@@ -2779,6 +2861,7 @@ export class Runner {
                 unpricedSpend: rs.telemetry.unpricedSpend,
                 rewindNotes: prepared.rewindNotes,
                 remoteEnvFailures: prepared.remoteEnvFailures,
+                retryAfterMs: rs.limits.platformTerminal?.retryAfterMs,
                 abortedForTimeout: timeout.fired,
                 abortedForTurns: rs.limits.turnsExceeded,
                 abortedLive,
@@ -2870,7 +2953,7 @@ export class Runner {
             const committedToken = prepared.suspendRef.token ?? prepared.reviewRef.token;
             const committedScope = prepared.suspendRef.scope ?? prepared.reviewRef.scope;
             if (committedToken !== undefined) {
-                const store = spec.checkpointStore ?? this.deps.checkpointStore;
+                const store = resolveCheckpointStore(spec, this.deps);
                 if (store && committedScope !== undefined) {
                     onSuspend({
                         env: prepared.ownedEnv,
@@ -2926,6 +3009,11 @@ export class Runner {
                 catch {
                 }
             }
+            if (manualCompactRef.waiters.length > 0) {
+                queue.push({ type: "compaction_outcome", outcome: "mooted", trigger: "manual", reason: "task_ending", ...ident() });
+                drainManualCompact("mooted");
+            }
+            manualCompactRef.emitMooted = undefined;
             queue.push({ type: "done", result });
             queue.close();
             if (spec.rewindFiles && result.status === "completed") {
@@ -3114,7 +3202,7 @@ export class Runner {
         return stream.result();
     }
     async resumeStream(token, outcome, taskConfig, internals) {
-        const store = taskConfig.checkpointStore ?? this.deps.checkpointStore;
+        const store = resolveCheckpointStore(taskConfig, this.deps);
         if (!store) {
             throw new CheckpointError("checkpoint.not_found", "no CheckpointStore wired — cannot resume (set RunnerDeps.checkpointStore or taskConfig.checkpointStore)");
         }
@@ -3349,13 +3437,16 @@ export class Runner {
         const completed = new Set(pendingAction.completedCallIds);
         const deferredIds = pendingAction.batchToolCallIds.filter((id) => id !== pendingAction.toolCallId && !completed.has(id));
         const names = new Map();
+        const deferredArgs = new Map();
         if (deferredIds.length > 0) {
             const { messages } = await prepared.session.buildContext();
             for (const m of messages) {
                 if (m.role === "assistant") {
                     for (const c of m.content) {
-                        if (c.type === "toolCall")
+                        if (c.type === "toolCall") {
                             names.set(c.id, c.name);
+                            deferredArgs.set(c.id, c.arguments);
+                        }
                     }
                 }
             }
@@ -3366,7 +3457,12 @@ export class Runner {
             }
             else if (!completed.has(id)) {
                 const name = names.get(id) ?? "unknown";
-                emit({ type: "tool_end", toolCallId: id, toolName: name, ...((() => { const l = prepared.tools.find((t) => t.name === name)?.label; return l !== undefined && l !== name ? { label: l } : {}; })()), isError: true });
+                const displayLabel = (() => {
+                    const l = prepared.tools.find((t) => t.name === name)?.label;
+                    return l !== undefined && l !== name ? { label: l } : {};
+                })();
+                emit({ type: "tool_start", toolCallId: id, toolName: name, ...displayLabel, args: deferredArgs.get(id) ?? {} });
+                emit({ type: "tool_end", toolCallId: id, toolName: name, ...displayLabel, isError: true, ...toolEndBodyFrom({ content: formatHookFeedback(DEFERRED_REISSUE) }, true) });
                 const eid = await prepared.session.appendMessage(toolResultMsg(id, name, formatHookFeedback(DEFERRED_REISSUE), true));
                 emitCommitted(eid, "toolResult", id);
             }
@@ -3380,10 +3476,10 @@ export class Runner {
         const resolvedArgs = pendingAction.toolName === ASK_USER_QUESTION_TOOL_NAME ? pendingAction.args : (outcome.updatedInput ?? pendingAction.args);
         const pendingLabel = (() => { const l = prepared.tools.find((t) => t.name === pendingAction.toolName)?.label; return l !== undefined && l !== pendingAction.toolName ? { label: l } : {}; })();
         emit({ type: "tool_start", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, args: resolvedArgs });
-        const emitEnd = (isError) => emit({ type: "tool_end", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, isError });
+        const emitEnd = (isError, result) => emit({ type: "tool_end", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, isError, ...toolEndBodyFrom(result, isError) });
         if (outcome.decision === "deny") {
-            emitEnd(true);
             const reason = outcome.reason ? delimitUntrusted("reviewer note", outcome.reason) : `The pending tool call "${pendingAction.toolName}" was denied by an approver.`;
+            emitEnd(true, { content: formatHookFeedback(reason) });
             const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, formatHookFeedback(reason), true));
             emitCommitted(eid, "toolResult", pendingAction.toolCallId);
             return;
@@ -3391,8 +3487,9 @@ export class Runner {
         if (outcome.decision === "allow" && outcome.updatedInput !== undefined && prepared.basePolicyForResumeEdit) {
             const rechecked = refuseOutOfContractDecision(await prepared.basePolicyForResumeEdit.check({ toolName: pendingAction.toolName, args: resolvedArgs, toolCallId: pendingAction.toolCallId }, prepared.abortController.signal));
             if (rechecked.action === "deny") {
-                emitEnd(true);
-                const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, formatHookFeedback(`The approver EDITED this call's input; the edited call is denied by the deployment's tool policy and was not executed${rechecked.message ? `: ${rechecked.message}` : ""}.`), true));
+                const editedDenial = formatHookFeedback(`The approver EDITED this call's input; the edited call is denied by the deployment's tool policy and was not executed${rechecked.message ? `: ${rechecked.message}` : ""}.`);
+                emitEnd(true, { content: editedDenial });
+                const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, editedDenial, true));
                 emitCommitted(eid, "toolResult", pendingAction.toolCallId);
                 return;
             }
@@ -3400,8 +3497,9 @@ export class Runner {
         if (prepared.denyNarrowingPolicy) {
             const narrowed = refuseOutOfContractDecision(await prepared.denyNarrowingPolicy.check({ toolName: pendingAction.toolName, args: resolvedArgs, toolCallId: pendingAction.toolCallId }, prepared.abortController.signal));
             if (narrowed.action === "deny") {
-                emitEnd(true);
-                const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, formatHookFeedback(`The approved tool call "${pendingAction.toolName}" is now denied by a session rule and was not executed${narrowed.message ? `: ${narrowed.message}` : ""}.`), true));
+                const narrowedDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" is now denied by a session rule and was not executed${narrowed.message ? `: ${narrowed.message}` : ""}.`);
+                emitEnd(true, { content: narrowedDenial });
+                const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, narrowedDenial, true));
                 emitCommitted(eid, "toolResult", pendingAction.toolCallId);
                 return;
             }
@@ -3419,13 +3517,26 @@ export class Runner {
             res = await tool.execute(pendingAction.toolCallId, args, prepared.abortController.signal);
         }
         catch (err) {
-            emitEnd(true);
-            const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, `Error: ${err instanceof Error ? err.message : String(err)}`, true));
+            const execError = `Error: ${err instanceof Error ? err.message : String(err)}`;
+            const marks = (() => {
+                if (err === null || typeof err !== "object")
+                    return undefined;
+                const src = err;
+                let d;
+                if (src.details !== null && typeof src.details === "object" && !Array.isArray(src.details)) {
+                    d = { ...src.details };
+                }
+                if (typeof src.errorKind === "string")
+                    d = { ...(d ?? {}), errorKind: src.errorKind };
+                return d;
+            })();
+            emitEnd(true, { content: execError, ...(marks !== undefined ? { details: marks } : {}) });
+            const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, execError, true));
             emitCommitted(eid, "toolResult", pendingAction.toolCallId);
             return;
         }
         const executedIsError = res.isError === true;
-        emitEnd(executedIsError);
+        emitEnd(executedIsError, res);
         onResolvedToolSuccess?.(pendingAction.toolName, executedIsError ? undefined : res.details);
         const eid = await prepared.session.appendMessage({
             role: "toolResult",

package/dist/core/runner/session-file-state-replay.d.ts

@@ -0,0 +1,7 @@
+import type { AgentMessage } from "../../internal/harness.js";
+export interface TranscriptFileRecord {
+    path: string;
+    content: string;
+    at: number;
+}
+export declare function wholeFileRecordsFromTranscript(messages: readonly AgentMessage[]): TranscriptFileRecord[];

package/dist/core/runner/session-file-state-replay.js

@@ -0,0 +1,56 @@
+import { isAbsolutePathForm } from "../../tools/fs/safety.js";
+const READ_TOOL = "Read";
+const WRITE_TOOL = "Write";
+const RETRACTING_RESULTS = [
+    { toolName: "Edit", type: "edit", pathField: "filePath" },
+    { toolName: "NotebookEdit", type: "notebook-edit", pathField: "notebookPath" },
+];
+function cardOf(details) {
+    if (typeof details !== "object" || details === null)
+        return undefined;
+    const rest = details;
+    return typeof rest.type === "string" ? { type: rest.type, rest } : undefined;
+}
+function wholeFileFromReadCard(rest) {
+    const file = rest.file;
+    if (typeof file !== "object" || file === null)
+        return undefined;
+    const f = file;
+    if (typeof f.content !== "string" || f.truncatedByTokenCap === true)
+        return undefined;
+    if (f.startLine !== 1 || typeof f.numLines !== "number" || f.numLines !== f.totalLines)
+        return undefined;
+    return f.content;
+}
+export function wholeFileRecordsFromTranscript(messages) {
+    const byPath = new Map();
+    for (const m of messages) {
+        if (m.role !== "toolResult" || m.isError)
+            continue;
+        const card = cardOf(m.details);
+        if (card === undefined)
+            continue;
+        const { type, rest } = card;
+        const retracts = RETRACTING_RESULTS.find((r) => r.toolName === m.toolName && r.type === type);
+        if (retracts !== undefined) {
+            const changed = rest[retracts.pathField];
+            if (typeof changed === "string")
+                byPath.delete(changed);
+            continue;
+        }
+        const isRead = m.toolName === READ_TOOL && type === "text";
+        const isWrite = m.toolName === WRITE_TOOL && (type === "create" || type === "update");
+        if (!isRead && !isWrite)
+            continue;
+        const nested = rest.file;
+        const holder = isRead ? (typeof nested === "object" && nested !== null ? nested : undefined) : rest;
+        const filePath = holder?.filePath;
+        if (typeof filePath !== "string" || !isAbsolutePathForm(filePath))
+            continue;
+        const content = isRead ? wholeFileFromReadCard(rest) : typeof rest.content === "string" ? rest.content : undefined;
+        if (content === undefined)
+            continue;
+        byPath.set(filePath, { path: filePath, content, at: m.timestamp });
+    }
+    return [...byPath.values()];
+}

package/dist/core/runner/session-rule-policy.d.ts

@@ -3,6 +3,7 @@ import type { ToolEffect } from "../types.js";
 import { type NamedToolPolicy } from "../tool-policy.js";
 import type { SessionPermissionRules } from "../session-policy-store.js";
 export declare const PATH_WRITE_TOOLS: ReadonlySet<string>;
+export declare const PATH_CONFINABLE_WRITE_TOOLS: ReadonlySet<string>;
 export declare function isWithin(root: string, p: string): boolean;
 export declare function createSessionRulePolicy(rules: SessionPermissionRules, opts: {
     env: ExecutionEnv;

package/dist/core/runner/session-rule-policy.js

@@ -1,7 +1,8 @@
-import { canonicalizeTarget, fileArgPath } from "../../tools/fs/safety.js";
+import { canonicalizeTarget, writeTargetPath } from "../../tools/fs/safety.js";
 import { isWinFormPath } from "../../tools/fs/safety.js";
 import { createCoarseCommandNamePolicy } from "../tool-policy.js";
 export const PATH_WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit"]);
+export const PATH_CONFINABLE_WRITE_TOOLS = new Set([...PATH_WRITE_TOOLS, "NotebookEdit"]);
 export function isWithin(root, p) {
     if (!root)
         return false;
@@ -46,14 +47,14 @@ export function createSessionRulePolicy(rules, opts) {
                     return d;
             }
             if (allowDirs) {
-                if (!PATH_WRITE_TOOLS.has(toolName)) {
+                if (!PATH_CONFINABLE_WRITE_TOOLS.has(toolName)) {
                     const eff = toolEffects?.get(toolName) ?? "write";
                     if (eff !== "read") {
                         return deny(`write-capable tool "${req.toolName}" denied: session rule confines writes to allowDirs but this tool cannot be path-confined`);
                     }
                 }
                 else {
-                    const path = fileArgPath(req.args);
+                    const path = writeTargetPath(toolName, req.args);
                     if (typeof path !== "string" || path.length === 0) {
                         return deny(`write tool "${req.toolName}" denied: session rule confines writes to allowDirs but the call has no resolvable path`);
                     }

package/dist/core/runner/synthetic-tools.js

@@ -78,7 +78,7 @@ export function createReportFindingsTool() {
             const count = findings.length;
             return {
                 content: count === 0 ? "No findings reported." : `${count} finding${count === 1 ? "" : "s"} reported.`,
-                details: { count, ...(level !== undefined ? { level } : {}), findings },
+                details: { type: "report-findings", count, ...(level !== undefined ? { level } : {}), findings },
             };
         },
     });

package/dist/core/runner/tool-output-projection.js

@@ -57,11 +57,12 @@ export const toolOutputFrom = (result) => {
     return { output: raw, truncated: true, totalChars };
 };
 const CC_DETAIL_TYPES = new Set([
-    "edit", "multiedit", "create", "update", "bash", "notebook-edit", "notebook", "file_unchanged", "worktree", "text", "grep", "glob", "mcp",
-    "agent", "task", "task-list", "task-output", "memory-saved", "workflow-run",
+    "edit", "create", "update", "bash", "notebook-edit", "notebook", "file_unchanged", "worktree", "text", "grep", "glob", "mcp",
+    "agent", "task", "task-list", "task-output", "workflow-run",
     "web-fetch", "web-search", "todo", "cron-create", "cron-delete", "cron-list", "image",
-    "task-stop", "tool-search", "memory-recall", "repo-map", "fork", "enter-plan-mode", "exit-plan-mode",
-    "monitor-start", "path_not_in_root",
+    "task-stop", "tool-search", "repo-map", "fork", "enter-plan-mode", "exit-plan-mode",
+    "monitor-start", "path_not_in_root", "readonly_out_of_root",
+    "report-findings", "schedule-wakeup", "send-message", "agent-transcript", "a2a", "document",
 ]);
 export const structuredFrom = (result) => {
     const details = result !== null && typeof result === "object" ? result.details : undefined;

package/dist/core/session-reconcile.d.ts

@@ -6,10 +6,14 @@ export interface OrphanToolCall {
     toolName: string;
     kind?: "result";
 }
+export type ReconciledErrorKind = "interrupted_never_started" | "interrupted_outcome_unknown";
+export type RecoveredOrphan = OrphanToolCall & {
+    entryId: string;
+    text: string;
+    errorKind: ReconciledErrorKind;
+};
 export interface ReconcileReport {
-    recovered: Array<OrphanToolCall & {
-        entryId: string;
-    }>;
+    recovered: RecoveredOrphan[];
 }
 export declare function findOrphanToolCalls(messages: AgentMessage[], suspendedBatch?: ReadonlySet<string>): OrphanToolCall[];
 export declare function reconcileInterruptedSession(session: Session, toolEffects?: Map<string, ToolEffect>, suspendedBatch?: ReadonlySet<string>, startedToolCallIds?: ReadonlySet<string>): Promise<ReconcileReport>;

package/dist/core/session-reconcile.js

@@ -75,16 +75,17 @@ export async function reconcileInterruptedSession(session, toolEffects, suspende
         const effectText = effect === "read" ? INTERRUPTED_SAFE : effect === "idempotent" ? INTERRUPTED_IDEMPOTENT : INTERRUPTED_UNKNOWN;
         const neverStarted = startedToolCallIds !== undefined && !startedToolCallIds.has(orphan.toolCallId);
         const text = neverStarted ? INTERRUPTED_NEVER_STARTED : effectText;
+        const errorKind = neverStarted ? "interrupted_never_started" : "interrupted_outcome_unknown";
         const entryId = await session.appendMessage({
             role: "toolResult",
             toolCallId: orphan.toolCallId,
             toolName: orphan.toolName,
             content: [{ type: "text", text }],
-            details: { errorKind: neverStarted ? "interrupted_never_started" : "interrupted_outcome_unknown" },
+            details: { errorKind },
             isError: true,
             timestamp: Date.now(),
         });
-        recovered.push({ ...orphan, entryId });
+        recovered.push({ ...orphan, entryId, text, errorKind });
     }
     return { recovered };
 }

package/dist/core/strategy-store.d.ts

@@ -14,8 +14,8 @@ export interface StrategyStore {
     prune?(scope: string, maxSize: number): Promise<void> | void;
 }
 export declare class InMemoryStrategyStore implements StrategyStore {
-    private readonly maxPerScope;
     private byScope;
+    private readonly maxPerScope;
     constructor(maxPerScope?: number);
     save(s: StoredStrategy): void;
     find(scope: string, query: string, limit: number): StoredStrategy[];