@sema-agent/core 5.9.0 → 5.10.0

package/dist/core/memory-recall.js

@@ -30,6 +30,11 @@ export const RECALL_CAVEAT = "These notes were recalled as relevant, but they ar
     "- If the user is about to act on your recommendation (not just asking about history), verify first.\n" +
     "- If a note names a file, check the file exists; if it names a function or symbol, grep for it; if it names a flag or value, read the current source.\n" +
     "- Memory is a snapshot from when it was written, not a live view — prefer `git log` or reading the code over recalling the snapshot.";
+function isNewerNote(candidate, incumbent) {
+    if (candidate.timestampMissing || incumbent.timestampMissing)
+        return false;
+    return candidate.mtimeMs > incumbent.mtimeMs;
+}
 export function resolveLinkedIds(headers, selected, max) {
     if (max <= 0 || selected.length === 0)
         return [];
@@ -38,7 +43,7 @@ export function resolveLinkedIds(headers, selected, max) {
         if (!h.name)
             continue;
         const prev = byName.get(h.name);
-        if (!prev || h.mtimeMs > prev.mtimeMs)
+        if (!prev || isNewerNote(h, prev))
             byName.set(h.name, h);
     }
     const selectedIds = new Set(selected.map((r) => r.id));
@@ -100,8 +105,8 @@ export function validateSelectedIds(headers, ids, max) {
 export function composeSelectiveBody(manifestText, selected, nowMs, linked = [], recallable = true) {
     const renderNote = (r, label) => {
         const ageMs = nowMs - r.mtimeMs;
-        const verify = ageMs > ONE_DAY_MS ? " — verify it's still current" : "";
-        const stale = ` (written ${formatMemoryAge(ageMs)}${verify})`;
+        const verify = r.timestampMissing || ageMs > ONE_DAY_MS ? " — verify it's still current" : "";
+        const stale = r.timestampMissing ? ` (write time unknown${verify})` : ` (written ${formatMemoryAge(ageMs)}${verify})`;
         const prefix = label ? `${sanitizeUntrustedText(label, ["user_memory"])} ` : "";
         return `- ${prefix}${sanitizeUntrustedText(r.text, ["user_memory"])}${stale}`;
     };

package/dist/core/memory.d.ts

@@ -40,6 +40,7 @@ export interface MemoryNoteHeader {
     id: string;
     description: string;
     mtimeMs: number;
+    timestampMissing?: true;
     name?: string;
     type?: string;
     consolidationGenerated?: boolean;
@@ -84,6 +85,10 @@ export declare class InMemoryMemoryStore implements MemoryStore {
 export declare function expandLexicalTerms(term: string): string[];
 export declare function lexicalSearchMatch(query: string, text: string): boolean;
 export declare function firstSentence(text: string): string;
+export declare function parseNoteTimestamp(ts: unknown): {
+    mtimeMs: number;
+    timestampMissing?: true;
+};
 export interface NormalizedMemorySpec {
     scopes: string[];
     writeScope: string | null;

package/dist/core/memory.js

@@ -268,7 +268,7 @@ export class InMemoryMemoryStore {
         return entries.map((e) => ({
             id: e.id,
             description: e.description ?? firstSentence(e.text),
-            mtimeMs: mtimeMsOf(e.ts),
+            ...parseNoteTimestamp(e.ts),
             ...(e.name ? { name: e.name } : {}),
             ...(e.type ? { type: e.type } : {}),
             ...(e.consolidationGenerated ? { consolidationGenerated: true } : {}),
@@ -291,7 +291,7 @@ export class InMemoryMemoryStore {
             id: e.id,
             text: e.text,
             description: e.description ?? firstSentence(e.text),
-            mtimeMs: mtimeMsOf(e.ts),
+            ...parseNoteTimestamp(e.ts),
             ...(e.name ? { name: e.name } : {}),
             ...(e.type ? { type: e.type } : {}),
             ...(e.consolidationGenerated ? { consolidationGenerated: true } : {}),
@@ -347,9 +347,11 @@ export function firstSentence(text) {
     const cut = dot >= 0 && dot < 160 ? dot + 1 : Math.min(t.length, 120);
     return t.slice(0, cut).trim();
 }
-function mtimeMsOf(ts) {
+export function parseNoteTimestamp(ts) {
+    if (typeof ts !== "string" || ts.trim() === "")
+        return { mtimeMs: 0, timestampMissing: true };
     const ms = Date.parse(`${ts.replace(" ", "T")}:00Z`);
-    return Number.isFinite(ms) ? ms : 0;
+    return Number.isFinite(ms) ? { mtimeMs: ms } : { mtimeMs: 0, timestampMissing: true };
 }
 export function normalizeMemorySpec(input) {
     if (!input)

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

@@ -9,6 +9,7 @@ import { SubagentRetainLedger } from "../../agents/retain-ledger.js";
 import type { OnAsk, ToolPolicy } from "../tool-policy.js";
 import { type ActiveSkillFrame } from "./active-skill-scope.js";
 import type { SessionPermissionRules } from "../session-policy-store.js";
+import { type RecoveredOrphan } from "../session-reconcile.js";
 import { CacheBreakDetector, type ToolFingerprintInput } from "../cache-break-detector.js";
 import { type BrainCallGuardrailRef } from "../../brain/timeout.js";
 import { type OutputRef, type BlockedRef, type SkillListingEntry } from "./synthetic-tools.js";
@@ -18,7 +19,7 @@ import type { TaskNotificationPayload } from "../task-notification.js";
 import { type CwdRef } from "../../tools/fs/index.js";
 import { type WorkflowSizeGuideline } from "../../orchestration/workflow-size-guideline.js";
 import type { Runner } from "./runtask.js";
-import { type CheckpointGate, type CheckpointState, type CheckpointToken, type ResourceLedger, type PlatformLimitReason, type ResourceLimitReason } from "../checkpoint-store.js";
+import { type CheckpointGate, type CheckpointState, type CheckpointStore, type CheckpointToken, type ResourceLedger, type PlatformLimitReason, type ResourceLimitReason } from "../checkpoint-store.js";
 import type { ActiveWorktreeSession, AgentMessage, AgentTool, ExecutionEnv } from "../../internal/harness.js";
 import type { NestedUsageAccum, RunnerDeps, TaskEvent, TaskLimits, TaskResult, TaskSpec, ToolActivity, ToolEffect } from "../types.js";
 import type { RepairBundle } from "../../agents/repair-loop.js";
@@ -42,6 +43,11 @@ export declare function checkpointScopeOf(spec: {
     };
     principal?: string;
 }): string;
+export declare function resolveCheckpointStore(spec: {
+    checkpointStore?: CheckpointStore | null;
+}, deps: {
+    checkpointStore?: CheckpointStore;
+}): CheckpointStore | undefined;
 export interface Prepared {
     harness: AgentHarness;
     session: StoredSession;
@@ -187,6 +193,7 @@ export interface Prepared {
     now: () => number;
     tools: AgentTool[];
     toolEffects: Map<string, ToolEffect>;
+    wakeRecovered: RecoveredOrphan[];
     promptOverheadTokens: number;
     readTaskFile?: (path: string) => Promise<string | null>;
     recentlyReadFiles?: () => string[];

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

@@ -57,7 +57,7 @@ import { hasBackgroundShell, sweepBackgroundShells } from "../background-shell.j
 import { createTaskOutputTool, createTaskStopTool, defaultTaskRegistry } from "../task-registry.js";
 import { createMonitorTool } from "../../tools/monitor.js";
 import { createWorktreeTools } from "../../tools/worktree.js";
-import { applyCompactionToReadFileState, bashReversibilityProbe, createHandsToolkit, isReadDedupStubResult, seedReadFileStateFromContext, HAND_TOOL_EFFECTS, pdfModelCapabilitiesOf } from "../../tools/fs/index.js";
+import { applyCompactionToReadFileState, bashReversibilityProbe, createHandsToolkit, isReadDedupStubResult, seedReadFileStateFromContext, seedReadFileStateFromTranscript, HAND_TOOL_EFFECTS, pdfModelCapabilitiesOf } from "../../tools/fs/index.js";
 import { decodeTextBytes } from "../../tools/fs/encoding.js";
 import { ASK_USER_QUESTION_TOOL_NAME, createAskUserQuestionTool } from "../ask-question.js";
 import { createSchedulerTools } from "../../tools/scheduler-tools.js";
@@ -67,6 +67,7 @@ import { createRunWorkflowTool, RUN_WORKFLOW_TOOL_NAME } from "../../orchestrati
 import { resolveWorkflowSizeGuideline } from "../../orchestration/workflow-size-guideline.js";
 import { createLspTool, gitCheckIgnoreFilter, resolveLspPath } from "../lsp.js";
 import { resolveKey } from "../../tools/fs/safety.js";
+import { wholeFileRecordsFromTranscript } from "./session-file-state-replay.js";
 import { BINDING_CHECKPOINT_VERSION, mintCheckpointToken, RESOURCE_CHECKPOINT_VERSION, TOKEN_CHECKPOINT_VERSION, buildRiskDescriptor, debitLedger, remainingBudgetMicroUsd, } from "../checkpoint-store.js";
 import { boundInputHashOf } from "../canonical-json.js";
 import { GLOBAL_USAGE_KEY, resolveUsageWindows, usageRetryAfterMs } from "../usage-window-store.js";
@@ -171,6 +172,11 @@ export const DEFAULT_IRREVERSIBLE_SCOPE = "irreversible";
 export function checkpointScopeOf(spec) {
     return spec.durableApproval?.scope || spec.principal || DEFAULT_IRREVERSIBLE_SCOPE;
 }
+export function resolveCheckpointStore(spec, deps) {
+    if (spec.checkpointStore === null)
+        return undefined;
+    return spec.checkpointStore ?? deps.checkpointStore;
+}
 export function isFableFamilyModelId(id) {
     const tail = id.toLowerCase().split("/").pop() ?? "";
     return /^claude-fable-\d/.test(tail) || /^claude-mythos-5(?!\d)/.test(tail);
@@ -319,6 +325,20 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         throw e;
     }
     resolveTaskLimits(spec.limits);
+    if (spec.resourceSuspend !== undefined) {
+        const rsus = spec.resourceSuspend;
+        if (typeof rsus.scope !== "string" || rsus.scope === "") {
+            throw limitConfigError("config.limit_invalid", `TaskSpec.resourceSuspend.scope must be a non-empty string (got ${String(rsus.scope)}) — it is the multi-tenant isolation key every resource checkpoint is filed under.`);
+        }
+        for (const key of ["totalBudgetUsd", "totalTokens", "maxSlices", "ttlMs"]) {
+            const value = rsus[key];
+            if (value === undefined)
+                continue;
+            if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+                throw limitConfigError("config.limit_invalid", `TaskSpec.resourceSuspend.${key} must be a finite, non-negative number (got ${String(value)}) — an unevaluable allocation is not an allocation, and a NaN here blinds even the validated per-slice window.`);
+            }
+        }
+    }
     const usageWindows = resolveUsageWindows(deps.usageWindows);
     const brainCallGuardrailRef = {};
     const brainCallGuardrailMs = resolveBrainCallGuardrailMs(spec.limits?.brainCallGuardrailMs ?? deps.brainCallGuardrailMs);
@@ -411,6 +431,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
     let acquired;
     let session;
     let conflictRef;
+    let wakeRecovered = [];
     let resumeAtBeforeParentId = null;
     for (let attempt = 0;; attempt++) {
         try {
@@ -487,7 +508,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 }
                 await session.getStorage().setLeafId(spec.resumeAtMode === "before" ? entry.parentId : spec.resumeAt);
             }
-            await reconcileInterruptedSession(session, toolEffects, resume?.suspendedBatch);
+            wakeRecovered = (await reconcileInterruptedSession(session, toolEffects, resume?.suspendedBatch)).recovered;
             break;
         }
         catch (err) {
@@ -910,6 +931,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const effectiveShellGate = inheritedShellGate !== undefined && shellGateRank[inheritedShellGate] > shellGateRank[specShellGate] ? inheritedShellGate : specShellGate;
         const ownSessionRulesRef = {};
         const frozenOnAsk = spec.onAsk ?? deps.onAsk;
+        const frozenOnQuestion = spec.onQuestion ?? deps.onQuestion;
         const inheritedGateForChildren = () => {
             const ancestorRules = [
                 ...(inheritedAncestorRules ?? []),
@@ -945,6 +967,9 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             thinkingLevel: harnessRef.current?.getThinkingLevel(),
             principal: spec.principal,
             ...(frozenOnAsk !== undefined ? { onAsk: frozenOnAsk } : {}),
+            ...(frozenOnQuestion !== undefined ? { onQuestion: frozenOnQuestion } : {}),
+            ...(spec.handsReadOnly === true ? { handsReadOnly: true } : {}),
+            ...(spec.interactiveTools === false ? { interactiveTools: false } : {}),
             oneShot: spec.oneShot,
             clientContext: spec.clientContext,
             excludeTools: toolFaceSnapshot.exclude,
@@ -961,6 +986,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             inheritedGateForChildren,
             ...(autoModeDecider ? { autoModeReview: { decider: autoModeDecider } } : {}),
             ...(spec.durableApproval !== undefined ? { durableApprovalForChildren: { ...spec.durableApproval } } : {}),
+            ...(spec.checkpointStore === null ? { checkpointStoreDisabledForChildren: true } : {}),
             taskId: hostTaskId,
             ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}),
             ...(internals?.parentSessionId !== undefined ? { parentSessionId: internals.parentSessionId } : {}),
@@ -1014,7 +1040,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             tools.push(createReportFindingsTool());
         }
         if (spec.enablePlanMode === true && spec.interactiveTools !== false) {
-            const planReviewFace = (spec.checkpointStore ?? deps.checkpointStore) !== undefined;
+            const planReviewFace = resolveCheckpointStore(spec, deps) !== undefined;
             if (spec.interactiveTools === true || planReviewFace) {
                 tools.push(defineTool(createPresentPlanTool(requestReview)));
                 if (planReviewFace) {
@@ -1352,6 +1378,14 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             }
             const readFileState = new Map((resume?.seed.readFileState ?? []).map(([k, v]) => [rebaseRestoredPath(k), v]));
             readFileStateForCheckpoint = readFileState;
+            if (resume === undefined && spec.sessionId !== undefined) {
+                const prior = await session.buildContext().catch(() => undefined);
+                for (const rec of wholeFileRecordsFromTranscript(prior?.messages ?? [])) {
+                    const rk = await resolveKey(executionEnv, rootCanonical, rec.path, undefined, undefined, additionalRootsCanonical);
+                    if (rk.ok)
+                        seedReadFileStateFromTranscript(readFileState, rk.key, rec.content, rec.at);
+                }
+            }
             seedContextFiles = async (files) => {
                 for (const f of files) {
                     const rk = await resolveKey(executionEnv, rootCanonical, f.path, undefined, undefined, additionalRootsCanonical);
@@ -1533,8 +1567,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         }
         if (offloadStore)
             tools.push(createReadToolResultTool(offloadStore));
-        const onQuestion = spec.onQuestion ?? deps.onQuestion;
-        const durableQuestionFace = (spec.checkpointStore ?? deps.checkpointStore) !== undefined &&
+        const onQuestion = frozenOnQuestion;
+        const durableQuestionFace = resolveCheckpointStore(spec, deps) !== undefined &&
             (spec.durableApproval !== undefined || runtimeCaps?.forceDurableGate === true);
         if (spec.interactiveTools === true || (spec.interactiveTools !== false && (onQuestion !== undefined || durableQuestionFace)))
             tools.push(createAskUserQuestionTool(onQuestion, { principal: spec.principal, sourceTaskId: sessionId }));
@@ -2462,7 +2496,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     if (creq.toolName === ASK_USER_QUESTION_TOOL_NAME)
                         return first;
                     if (pc.durableMandate === true) {
-                        if ((spec.checkpointStore ?? deps.checkpointStore) !== undefined &&
+                        if (resolveCheckpointStore(spec, deps) !== undefined &&
                             (spec.durableApproval !== undefined || runtimeCaps?.forceDurableGate === true) &&
                             markInheritedUnavailable(creq.toolCallId)) {
                             return first;
@@ -2518,7 +2552,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     if (creq.toolName === ASK_USER_QUESTION_TOOL_NAME)
                         return decision;
                     if (pc.durableMandate === true) {
-                        if ((spec.checkpointStore ?? deps.checkpointStore) !== undefined &&
+                        if (resolveCheckpointStore(spec, deps) !== undefined &&
                             (spec.durableApproval !== undefined || runtimeCaps?.forceDurableGate === true) &&
                             markInheritedUnavailable(creq.toolCallId)) {
                             return decision;
@@ -2678,13 +2712,13 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const blockedTracked = Boolean(hooks?.postToolUse || hooks?.preToolUse || hooks?.postToolUseFailure || hooks?.postToolBatch);
         const restoreSurfaceGap = ownedEnv !== undefined && isRemoteExecutionEnv(ownedEnv) && ownedEnv.capabilities.suspendable ? missingRestoreSurface(ownedEnv) : [];
         const incompleteSuspendAdapter = restoreSurfaceGap.length > 0 ? restoreSurfaceGap : undefined;
-        const durableSuspendInfraReady = (spec.checkpointStore ?? deps.checkpointStore) !== undefined &&
+        const durableSuspendInfraReady = resolveCheckpointStore(spec, deps) !== undefined &&
             !(offloadStore !== undefined && isVolatileOffloadStore(offloadStore)) &&
             (ownedEnv === undefined || isRemoteExecutionEnv(ownedEnv)) &&
             incompleteSuspendAdapter === undefined;
         const resourceSuspendEligible = spec.resourceSuspend !== undefined && durableSuspendInfraReady;
         if (spec.resourceSuspend !== undefined && !resourceSuspendEligible) {
-            const why = (spec.checkpointStore ?? deps.checkpointStore) === undefined
+            const why = resolveCheckpointStore(spec, deps) === undefined
                 ? "no CheckpointStore is wired"
                 : offloadStore !== undefined && isVolatileOffloadStore(offloadStore)
                     ? "tool-result offload uses the in-memory store (a resume needs durable results)"
@@ -2842,7 +2876,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 catch {
                 }
             };
-            const checkpointStore = spec.checkpointStore ?? deps.checkpointStore;
+            const checkpointStore = resolveCheckpointStore(spec, deps);
             const durableApproval = spec.durableApproval ??
                 (runtimeCaps?.forceDurableGate ? { scope: spec.principal || DEFAULT_IRREVERSIBLE_SCOPE } : undefined);
             const inFlightSpendMicroUsd = () => {
@@ -3602,7 +3636,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, 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 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, wakeRecovered, 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.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";
@@ -123,6 +123,9 @@ function toolEndBodyFrom(result, isError) {
         ...(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;
@@ -240,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.`
@@ -267,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));
@@ -286,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) };
@@ -923,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,
@@ -1313,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");
             }
         })();
@@ -1501,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 = {
@@ -1516,6 +1587,7 @@ export class Runner {
                                 if (manualCompactRef.waiters.length === 0) {
                                     manualCompactRef.requested = false;
                                 }
+                                manualCompactRef.emitMooted?.("cancelled");
                                 entry.resolve("mooted");
                             }
                         };
@@ -1649,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;
@@ -1667,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);
                     });
@@ -1716,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;
@@ -2064,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) {
@@ -2114,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 = [];
@@ -2660,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 });
@@ -2675,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);
                 }
             }
@@ -2873,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,
@@ -2929,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") {
@@ -3117,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)");
         }
@@ -3352,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);
+                        }
                     }
                 }
             }
@@ -3369,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, ...toolEndBodyFrom({ content: formatHookFeedback(DEFERRED_REISSUE) }, 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);
             }
@@ -3425,7 +3518,19 @@ export class Runner {
         }
         catch (err) {
             const execError = `Error: ${err instanceof Error ? err.message : String(err)}`;
-            emitEnd(true, { content: execError });
+            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;