@sema-agent/core 5.8.0 → 5.9.0

package/dist/brain/request-params.d.ts

@@ -1,5 +1,6 @@
 export declare const OPENAI_RESERVED: ReadonlySet<string>;
 export declare const ANTHROPIC_RESERVED: ReadonlySet<string>;
+export declare const RESPONSES_RESERVED: ReadonlySet<string>;
 export declare function reservedFor(api: string): ReadonlySet<string>;
 export declare function applyExtraBody(body: Record<string, unknown>, extraBody: Record<string, unknown> | undefined, reserved: ReadonlySet<string>): Record<string, unknown>;
 export declare function stripAuthHeaders(headers: Record<string, string>): void;

package/dist/brain/request-params.js

@@ -25,7 +25,23 @@ export const ANTHROPIC_RESERVED = new Set([
     "output_config",
     "context_management",
 ]);
+export const RESPONSES_RESERVED = new Set([
+    "model",
+    "input",
+    "stream",
+    "instructions",
+    "tools",
+    "temperature",
+    "max_output_tokens",
+    "reasoning",
+    "store",
+    "previous_response_id",
+    "conversation",
+]);
+const RESPONSES_APIS = new Set(["openai-responses", "azure-openai-responses", "openai-chatgpt-responses"]);
 export function reservedFor(api) {
+    if (RESPONSES_APIS.has(api))
+        return RESPONSES_RESERVED;
     return api === "anthropic-messages" ? ANTHROPIC_RESERVED : OPENAI_RESERVED;
 }
 export function applyExtraBody(body, extraBody, reserved) {

package/dist/core/fs-write-gate-policy.js

@@ -1,9 +1,9 @@
 import { canonicalizeTarget, writeTargetPath } from "../tools/fs/safety.js";
-import { PATH_WRITE_TOOLS, isWithin } from "./runner/session-rule-policy.js";
+import { PATH_CONFINABLE_WRITE_TOOLS, isWithin } from "./runner/session-rule-policy.js";
 const ask = (message) => ({ action: "ask", message, decisionReason: "rule" });
 export function createFsWriteGatePolicy(opts) {
     const { env, rootPath, defaultWrite } = opts;
-    const gated = new Set([...PATH_WRITE_TOOLS, "NotebookEdit"]);
+    const gated = PATH_CONFINABLE_WRITE_TOOLS;
     const acceptDirs = opts.acceptDirs && opts.acceptDirs.length > 0 ? opts.acceptDirs : undefined;
     const exemptDirs = opts.exemptDirs && opts.exemptDirs.length > 0 ? opts.exemptDirs : undefined;
     return {

package/dist/core/lsp-diagnostics.d.ts

@@ -22,9 +22,10 @@ export declare class LspDiagnosticsRegistry {
     private readonly pending;
     private readonly delivered;
     publish(uri: string, diagnostics: LspDiagnostic[]): void;
-    fileEdited(uri: string): void;
+    fileEdited(runIdent: string, uri: string): void;
+    releaseRun(runIdent: string): void;
     isEmpty(): boolean;
-    drain(): LspFileDiagnostics[];
+    drain(runIdent: string): LspFileDiagnostics[];
 }
 export declare function formatDiagnosticsSummary(files: LspFileDiagnostics[]): string;
 export declare function formatDiagnosticsBlock(files: LspFileDiagnostics[]): string;

package/dist/core/lsp-diagnostics.js

@@ -16,30 +16,39 @@ function diagnosticKey(uri, d) {
 }
 export class LspDiagnosticsRegistry {
     pending = new Map();
-    delivered = new Set();
+    delivered = new Map();
     publish(uri, diagnostics) {
         if (diagnostics.length === 0)
             this.pending.delete(uri);
         else
             this.pending.set(uri, diagnostics);
     }
-    fileEdited(uri) {
+    fileEdited(runIdent, uri) {
+        const forRun = this.delivered.get(runIdent);
+        if (forRun === undefined)
+            return;
         const prefix = `${uri}|`;
-        for (const key of this.delivered) {
+        for (const key of forRun) {
             if (key.startsWith(prefix))
-                this.delivered.delete(key);
+                forRun.delete(key);
         }
+        if (forRun.size === 0)
+            this.delivered.delete(runIdent);
+    }
+    releaseRun(runIdent) {
+        this.delivered.delete(runIdent);
     }
     isEmpty() {
         return this.pending.size === 0;
     }
-    drain() {
+    drain(runIdent) {
         const out = [];
         const requeued = new Map();
+        let delivered = this.delivered.get(runIdent);
         let total = 0;
         for (const [uri, all] of this.pending) {
             const fresh = all
-                .filter((d) => !this.delivered.has(diagnosticKey(uri, d)))
+                .filter((d) => delivered?.has(diagnosticKey(uri, d)) !== true)
                 .sort((a, b) => (a.severity ?? 99) - (b.severity ?? 99));
             if (fresh.length === 0)
                 continue;
@@ -49,8 +58,12 @@ export class LspDiagnosticsRegistry {
                 requeued.set(uri, fresh.slice(take.length));
             if (take.length === 0)
                 continue;
+            if (delivered === undefined) {
+                delivered = new Set();
+                this.delivered.set(runIdent, delivered);
+            }
             for (const d of take)
-                this.delivered.add(diagnosticKey(uri, d));
+                delivered.add(diagnosticKey(uri, d));
             total += take.length;
             out.push({ uri, diagnostics: take });
         }

package/dist/core/runner/assemble-result.d.ts

@@ -59,6 +59,7 @@ export interface ResultFlags {
     unpricedSpend?: boolean;
     rewindNotes?: TaskResult["rewindNotes"];
     remoteEnvFailures?: TaskResult["remoteEnvFailures"];
+    retryAfterMs?: number;
     abortedForTimeout: boolean;
     abortedForTurns: boolean;
     abortedLive?: boolean;

package/dist/core/runner/assemble-result.js

@@ -1,5 +1,14 @@
 import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
 import { extractErrorCode, stripErrorCodePrefix } from "../../brain/errors.js";
+const SALVAGE_ELIGIBLE_TERMINALS = new Set([
+    "output.degenerate",
+    "limits.max_tokens_exceeded",
+    "limits.max_cost_exceeded",
+    "limits.max_turns_exceeded",
+    "limits.max_walltime_exceeded",
+    "env.lifetime_expired",
+    "usage.window_exhausted",
+]);
 export function errorCodeOf(err) {
     let cur = err;
     let fallback;
@@ -63,7 +72,6 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
         status = "failed";
         errorCode = "output.degenerate";
         errorMessage = final?.errorMessage;
-        salvagedOutput = text.trim() || undefined;
     }
     else if (flags.budgetHit) {
         status = "failed";
@@ -73,7 +81,6 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
             flags.budgetHit === "precall"
                 ? `the estimated cost of the first call already exceeds ${axisName}; the task was not started`
                 : `cumulative usage exceeded ${axisName}`;
-        salvagedOutput = text.trim() || undefined;
     }
     else if (flags.suspendLoop) {
         status = "failed";
@@ -90,8 +97,6 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
                 : flags.conflict
                     ? "conflict"
                     : errorCodeOf(flags.threw);
-        if (flags.abortedForTimeout || flags.abortedForTurns)
-            salvagedOutput = text.trim() || undefined;
     }
     else if (flags.blockedReason) {
         status = "blocked";
@@ -114,8 +119,6 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
         status = "failed";
         errorCode = flags.abortedForTimeout ? "limits.max_walltime_exceeded" : flags.abortedForTurns ? "limits.max_turns_exceeded" : undefined;
         errorMessage = final?.errorMessage ?? (flags.abortedForTurns ? "max turns exceeded" : "run aborted");
-        if (flags.abortedForTimeout || flags.abortedForTurns)
-            salvagedOutput = text.trim() || undefined;
     }
     else if (!final) {
         status = "failed";
@@ -139,9 +142,13 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
     else {
         status = "completed";
     }
+    if (errorCode !== undefined && SALVAGE_ELIGIBLE_TERMINALS.has(errorCode)) {
+        salvagedOutput = text.trim() || undefined;
+    }
+    const retryAfterMs = errorCode === "usage.window_exhausted" ? flags.retryAfterMs : undefined;
     const { compactionMicroUsd: _internalCompaction, ...publicStats } = stats;
     void _internalCompaction;
     if (flags.unpricedSpend)
         delete publicStats.costMicroUsd;
-    return { taskId, sessionId, status, ...(flags.model !== undefined ? { model: flags.model } : {}), result: result.trim(), salvagedOutput, blockedReason, errorMessage, errorCode, checkpointToken, checkpointGate, ...(workspaceRestoreMode !== undefined ? { workspaceRestoreMode } : {}), ...(flags.rewindNotes !== undefined && flags.rewindNotes.length > 0 ? { rewindNotes: flags.rewindNotes } : {}), ...(flags.remoteEnvFailures !== undefined && flags.remoteEnvFailures.length > 0 ? { remoteEnvFailures: flags.remoteEnvFailures } : {}), stats: publicStats };
+    return { taskId, sessionId, status, ...(flags.model !== undefined ? { model: flags.model } : {}), result: result.trim(), salvagedOutput, blockedReason, errorMessage, errorCode, ...(retryAfterMs !== undefined ? { retryAfterMs } : {}), checkpointToken, checkpointGate, ...(workspaceRestoreMode !== undefined ? { workspaceRestoreMode } : {}), ...(flags.rewindNotes !== undefined && flags.rewindNotes.length > 0 ? { rewindNotes: flags.rewindNotes } : {}), ...(flags.remoteEnvFailures !== undefined && flags.remoteEnvFailures.length > 0 ? { remoteEnvFailures: flags.remoteEnvFailures } : {}), stats: publicStats };
 }

package/dist/core/runner/prepare-task.d.ts

@@ -199,6 +199,7 @@ export interface Prepared {
     lspDiagnostics?: {
         registry: import("../lsp-diagnostics.js").LspDiagnosticsRegistry;
         nudge: (rawPath: string) => void;
+        runIdent: string;
     };
     planModeRef: {
         active: boolean;

package/dist/core/runner/prepare-task.js

@@ -17,7 +17,7 @@ import { createSubagentWorktreeHelper, forkGovernanceDenial } from "../../agents
 import { createAgentTranscriptTool, AGENT_TRANSCRIPT_TOOL_NAME } from "../../agents/agent-transcript-tool.js";
 import { createSendMessageTool, SEND_MESSAGE_TOOL_NAME } from "../../agents/send-message-tool.js";
 import { SubagentRetainLedger } from "../../agents/retain-ledger.js";
-import { combinePolicies, createTranscriptIntegrityPolicy, createUnverifiableDeletePolicy, refuseOutOfContractDecision, resolveAsk, toolPolicyNameSets } from "../tool-policy.js";
+import { askApproverIdentity, combinePolicies, createTranscriptIntegrityPolicy, createUnverifiableDeletePolicy, refuseOutOfContractDecision, resolveAsk, toolPolicyNameSets } from "../tool-policy.js";
 import { ActiveSkillScope, createActiveSkillScopePolicy } from "./active-skill-scope.js";
 import { CHANGED_FILES_MTIME_EPS_MS, fenceMcpServerInstructions, renderAgentListingDelta } from "./turn-attachments.js";
 import { inlineUntrusted } from "../untrusted-text.js";
@@ -944,6 +944,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             model: harnessRef.current?.getModel(),
             thinkingLevel: harnessRef.current?.getThinkingLevel(),
             principal: spec.principal,
+            ...(frozenOnAsk !== undefined ? { onAsk: frozenOnAsk } : {}),
             oneShot: spec.oneShot,
             clientContext: spec.clientContext,
             excludeTools: toolFaceSnapshot.exclude,
@@ -1562,11 +1563,12 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const lspDiagnostics = spec.lspDiagnostics !== false && lspManager?.diagnostics !== undefined && handsEnabled && spec.handsReadOnly !== true
             ? lspManager.diagnostics
             : undefined;
+        const lspRunIdent = sessionId;
         const nudgeLspOnEdit = lspDiagnostics
             ? (rawPath) => {
                 const baseDir = handsCwdRef?.current ?? taskRootPath;
                 const filePath = resolveLspPath(rawPath, baseDir);
-                lspDiagnostics.fileEdited(pathToUri(filePath));
+                lspDiagnostics.fileEdited(lspRunIdent, pathToUri(filePath));
                 void lspManager
                     .sessionFor(filePath, undefined, executionEnv)
                     .then((session) => session?.notifyFileChanged?.(filePath))
@@ -2203,6 +2205,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             ? { legDate: envFacts.date, today: () => formatLocalDate(new Date(), tzValid ? userTz : undefined) }
             : undefined;
         const harness = new AgentHarness({
+            abortResultDetails: () => suspendRef.token !== undefined || reviewRef.token !== undefined ? { code: "gate.parked" } : undefined,
             ...(spec.limits?.maxOutputTokens !== undefined && spec.limits.maxOutputTokens > 0
                 ? { maxOutputTokens: spec.limits.maxOutputTokens }
                 : {}),
@@ -2774,7 +2777,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 }
                 if (decision.decisionReason === undefined || decision.decisionReason === "rule") {
                     const grant = inheritedAskGrants.get(req.toolCallId);
-                    if (grant !== undefined && grant.approver === onAsk && grant.argsJson === askGrantShapeOf(req.args)) {
+                    if (grant !== undefined && askApproverIdentity(grant.approver) === askApproverIdentity(onAsk) && grant.argsJson === askGrantShapeOf(req.args)) {
                         inheritedAskGrants.delete(req.toolCallId);
                         humanReviewRef.count += 1;
                         humanReviewRef.totalWaitMs += grant.waitMs;
@@ -3599,7 +3602,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             : undefined;
         overheadState.promptChars = systemPrompt.length;
         const preparedHolder = {};
-        const buildPrepared = () => ({ harness, session, sessionId, taskRootPath, model, thinking, compModel, mcp: mcp, ...(a2a !== undefined && a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), denyNarrowingPolicy, ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), releaseSignal, cacheBreakDetector, cacheFingerprint, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), ownedEnv, suspendRef, reviewRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, brainCallGuardrailRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, promptOverheadTokens, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, listBackgroundTasks, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
+        const buildPrepared = () => ({ harness, session, sessionId, taskRootPath, model, thinking, compModel, mcp: mcp, ...(a2a !== undefined && a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), denyNarrowingPolicy, ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), releaseSignal, cacheBreakDetector, cacheFingerprint, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), ownedEnv, suspendRef, reviewRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, brainCallGuardrailRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, promptOverheadTokens, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, listBackgroundTasks, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
         const prepared = buildPrepared();
         preparedHolder.current = prepared;
         return prepared;

package/dist/core/runner/runtask.js

@@ -113,6 +113,16 @@ 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 } : {}),
+    };
+}
 function deepJsonEqual(a, b) {
     if (a === b)
         return true;
@@ -380,7 +390,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);
@@ -1049,16 +1059,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();
@@ -2446,7 +2447,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 +2639,7 @@ export class Runner {
         }
         finally {
             timeout.clear();
+            prepared.lspDiagnostics?.registry.releaseRun(prepared.lspDiagnostics.runIdent);
             prepared.abortController.abort();
             prepared.releaseSignal();
             try {
@@ -2779,6 +2781,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,
@@ -3366,7 +3369,7 @@ 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 });
+                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, ...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 +3383,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 +3394,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 +3404,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 +3424,14 @@ 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)}`;
+            emitEnd(true, { content: execError });
+            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-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/task-registry-shared.d.ts

@@ -40,7 +40,6 @@ export interface SemaTaskHandle {
     createdAt: number;
     updatedAt: number;
     outputFile?: string;
-    outputOffset?: number;
     completionId?: string;
 }
 export declare function mintCompletionId(target: {

package/dist/core/tool-policy.d.ts

@@ -70,6 +70,11 @@ export declare function createTranscriptIntegrityPolicy(opts?: {
     readAllow?: readonly string[];
     tools?: string[];
 }): ToolPolicy;
+export interface AskDelegationProvenance {
+    readonly parentToolCallId: string;
+    readonly depth: number;
+    readonly agentName?: string;
+}
 export interface AskRequest {
     toolName: string;
     toolCallId: string;
@@ -81,12 +86,15 @@ export interface AskRequest {
     readonly fromSubagent?: true;
     readonly sourceAgentName?: string;
     readonly requiresRealApproval?: boolean;
+    readonly delegation?: AskDelegationProvenance;
 }
 export type OnAsk = "deny" | "allow" | ((req: AskRequest, signal?: AbortSignal) => AskOutcome | Promise<AskOutcome>);
 export type AskOutcome = boolean | "unavailable" | {
     allow: boolean;
     updatedInput?: unknown;
 };
+export declare function withDelegationProvenance(onAsk: OnAsk, delegation: AskDelegationProvenance): OnAsk;
+export declare function askApproverIdentity(onAsk: unknown): unknown;
 export type ResolvedAsk = PermissionResult & {
     approverUnavailable?: true;
     presentedInput?: unknown;

package/dist/core/tool-policy.js

@@ -516,6 +516,17 @@ export function createTranscriptIntegrityPolicy(opts) {
         },
     };
 }
+const delegatedApproverRoot = new WeakMap();
+export function withDelegationProvenance(onAsk, delegation) {
+    if (typeof onAsk !== "function")
+        return onAsk;
+    const wrapper = (req, signal) => req.delegation !== undefined ? onAsk(req, signal) : onAsk({ ...req, delegation }, signal);
+    delegatedApproverRoot.set(wrapper, askApproverIdentity(onAsk));
+    return wrapper;
+}
+export function askApproverIdentity(onAsk) {
+    return typeof onAsk === "function" ? (delegatedApproverRoot.get(onAsk) ?? onAsk) : onAsk;
+}
 function tryCloneArgs(v) {
     try {
         const value = structuredClone(v);

package/dist/core/trace.d.ts

@@ -134,8 +134,6 @@ export type TraceEvent = {
     firstTokenMs?: number;
     callStartedAt?: number;
     costMicroUsd?: number;
-    callCap?: number;
-    capThinkingSkipped?: boolean;
     stopReason?: string;
     ts: number;
 } | {

package/dist/core/types.d.ts

@@ -98,6 +98,7 @@ export interface ToolExecuteContext {
     model?: Model;
     thinkingLevel?: ThinkingLevel;
     principal?: string;
+    onAsk?: import("./tool-policy.js").OnAsk;
     oneShot?: boolean;
     clientContext?: TaskSpec["clientContext"];
     excludeTools?: readonly string[];
@@ -410,6 +411,7 @@ export interface TaskResult {
     remoteEnvFailures?: RemoteEnvFailureNote[];
     errorMessage?: string;
     errorCode?: string;
+    retryAfterMs?: number;
     degraded?: {
         from: string;
         to: string;
@@ -523,6 +525,7 @@ export type TaskEvent = ({
     isError: boolean;
     output?: unknown;
     structured?: unknown;
+    errorCode?: string;
     truncated?: boolean;
     totalChars?: number;
 } & TaskEventIdentity) | ({

package/dist/engine/harness/agent-harness.d.ts

@@ -50,6 +50,7 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
     private maxOutputTokens?;
     private maxOutputTokensPerCall?;
     private stallTimeoutsPerCall?;
+    private abortResultDetails?;
     private loopTrace?;
     private resilience?;
     private maxToolConcurrency?;

package/dist/engine/harness/agent-harness.js

@@ -186,6 +186,7 @@ export class AgentHarness {
     maxOutputTokens;
     maxOutputTokensPerCall;
     stallTimeoutsPerCall;
+    abortResultDetails;
     loopTrace;
     resilience;
     maxToolConcurrency;
@@ -216,6 +217,7 @@ export class AgentHarness {
         this.maxOutputTokens = options.maxOutputTokens;
         this.maxOutputTokensPerCall = options.maxOutputTokensPerCall;
         this.stallTimeoutsPerCall = options.stallTimeoutsPerCall;
+        this.abortResultDetails = options.abortResultDetails;
         this.loopTrace = options.loopTrace;
         this.resilience = options.resilience;
         this.maxToolConcurrency = options.maxToolConcurrency;
@@ -440,6 +442,7 @@ export class AgentHarness {
             ...(this.maxOutputTokens !== undefined ? { maxTokens: this.maxOutputTokens } : {}),
             ...(this.maxOutputTokensPerCall !== undefined ? { maxTokensPerCall: this.maxOutputTokensPerCall } : {}),
             ...(this.stallTimeoutsPerCall !== undefined ? { stallTimeoutsPerCall: this.stallTimeoutsPerCall } : {}),
+            ...(this.abortResultDetails !== undefined ? { abortResultDetails: this.abortResultDetails } : {}),
             ...(this.resilience !== undefined ? { resilience: this.resilience } : {}),
             ...(this.maxToolConcurrency !== undefined ? { maxToolConcurrency: this.maxToolConcurrency } : {}),
             ...(this.streamingToolExecution === true && (this.getHandlers("tool_call")?.size ?? 0) === 0

package/dist/engine/harness/types.d.ts

@@ -542,6 +542,7 @@ export interface AgentHarnessOptions<TSkill extends Skill = Skill, TPromptTempla
     maxOutputTokens?: number;
     maxOutputTokensPerCall?: () => number | undefined;
     stallTimeoutsPerCall?: () => import("../llm/types.js").StallTimeouts | undefined;
+    abortResultDetails?: () => Record<string, unknown> | undefined;
     loopTrace?: (step: import("../loop/agent-loop.js").LoopStep) => void;
     resilience?: import("../llm/types.js").ResilienceOptions;
     maxToolConcurrency?: number;