@sema-agent/core 2.10.0 → 2.12.0

package/dist/agents/send-message-tool.js

@@ -8,6 +8,9 @@ import { createSubagentResume } from "./subagent.js";
 export const SEND_MESSAGE_TOOL_NAME = "SendMessage";
 let uplinkSeqGlobal = Date.now();
 const UPLINK_RESULT_MAX = 8000;
+function clipCarrierMessage(text) {
+    return text.length > UPLINK_RESULT_MAX ? `${text.slice(0, UPLINK_RESULT_MAX)}\n[message truncated: ${text.length} chars total]` : text;
+}
 export const SEND_MESSAGE_SUMMARY_MAX = 200;
 export function clipSendMessageSummary(raw) {
     return raw.length > SEND_MESSAGE_SUMMARY_MAX
@@ -89,6 +92,7 @@ export function createSendMessageTool(opts) {
                     isError: true,
                 };
             }
+            const summary = clipSendMessageSummary(summaryArg);
             const senderId = ctx.taskId ?? opts.owner;
             const [parentTaskId, parentSessionId] = ctx.parentTaskId !== undefined ? [ctx.parentTaskId, ctx.parentSessionId] : [opts.parentTaskId, opts.parentSessionId];
             const senderName = ctx.spawnedAgentName ?? opts.senderName;
@@ -102,14 +106,12 @@ export function createSendMessageTool(opts) {
             }
             if (normalizeAgentName(to) === "main") {
                 if (opts.uplink && senderId !== undefined) {
-                    const uplinkSummaryRaw = typeof a.summary === "string" && a.summary.trim() !== "" ? clipSendMessageSummary(a.summary.trim()) : message.slice(0, 80);
-                    const fromLabel = senderName ?? senderId;
                     try {
                         opts.uplink({
                             task_id: senderId,
                             task_type: "background_agent",
                             status: "event",
-                            summary: `message from ${fromLabel}: ${uplinkSummaryRaw}`,
+                            summary: `message from ${senderLabel}: ${summary}`,
                             result: message.length > UPLINK_RESULT_MAX ? `${message.slice(0, UPLINK_RESULT_MAX)}\n[uplink truncated: ${message.length} chars total — read the agent's transcript for the rest]` : message,
                             seq: ++uplinkSeqGlobal,
                         }, { priority: "next" });
@@ -270,11 +272,9 @@ export function createSendMessageTool(opts) {
                             isError: true,
                         };
                     }
-                    const clipped = message.length > UPLINK_RESULT_MAX ? `${message.slice(0, UPLINK_RESULT_MAX)}\n[message truncated: ${message.length} chars total]` : message;
-                    const t3Summary = typeof a.summary === "string" && a.summary.trim() !== "" ? clipSendMessageSummary(a.summary.trim()) : undefined;
-                    const t3From = senderLabel;
+                    const clipped = clipCarrierMessage(message);
                     try {
-                        await opts.mailbox.append(scope, handle, { from: t3From, content: t3Summary !== undefined ? `[${t3Summary}] ${clipped}` : clipped, sentAt: now });
+                        await opts.mailbox.append(scope, handle, { from: senderLabel, content: `[${summary}] ${clipped}`, sentAt: now });
                     }
                     catch (e) {
                         await rollback();
@@ -418,17 +418,13 @@ export function createSendMessageTool(opts) {
             }
             if (row.status === "running" || row.status === "pending") {
                 return await withTargetLane(targetLaneKey(access.scope, targetId), async () => {
-                    const s2Summary = typeof a.summary === "string" && a.summary.trim() !== "" ? clipSendMessageSummary(a.summary.trim()) : undefined;
-                    const fromLabel = senderLabel;
-                    const s2Clipped = message.length > UPLINK_RESULT_MAX
-                        ? `${message.slice(0, UPLINK_RESULT_MAX)}\n[message truncated: ${message.length} chars total]`
-                        : message;
-                    const teammateXml = frameTeammateMessage({ from: fromLabel, ...(s2Summary !== undefined ? { summary: s2Summary } : {}), text: s2Clipped });
+                    const s2Clipped = clipCarrierMessage(message);
+                    const teammateXml = frameTeammateMessage({ from: senderLabel, summary, text: s2Clipped });
                     const delivered = await opts.registry.deliverToRunningAgent(targetId, resolvedAccess, {
                         task_id: senderLabel,
                         task_type: "background_agent",
                         status: "event",
-                        summary: `message from ${fromLabel}${s2Summary !== undefined ? `: ${s2Summary}` : ""}`,
+                        summary: `message from ${senderLabel}: ${summary}`,
                         result: teammateXml,
                         seq: ++uplinkSeqGlobal,
                     }, { priority: "next" });
@@ -440,7 +436,7 @@ export function createSendMessageTool(opts) {
                                 : `Message queued for delivery to ${who} at its next turn. If it finishes before reading it, the message may not survive — you will be notified of its completion either way; resend then if it went unanswered. Continue with other work; do not poll.`;
                         return {
                             content: receiptText,
-                            details: { type: "send-message", status: "delivered_running", disposition: delivered.disposition, to, task_id: targetId, ...(s2Summary !== undefined ? { summary: s2Summary } : {}) },
+                            details: { type: "send-message", status: "delivered_running", disposition: delivered.disposition, to, task_id: targetId, summary },
                         };
                     }
                     if (delivered.reason === "no_channel") {
@@ -531,16 +527,15 @@ export function createSendMessageTool(opts) {
                     ...(row.rootSessionId !== undefined ? { rowRootSessionId: row.rootSessionId } : {}),
                     ...(opts.notify ? { currentParentNotify: opts.notify } : {}),
                 });
-                const summary = typeof a.summary === "string" && a.summary.trim() !== "" ? clipSendMessageSummary(a.summary.trim()) : undefined;
-                const fromPrefix = parentTaskId !== undefined ? `(message from teammate "${senderName ?? senderId ?? "unknown"}")\n` : "";
+                const fromPrefix = senderIsChild ? `(message from teammate "${senderLabel}")\n` : "";
                 try {
-                    const safeSummary = summary !== undefined ? escapeEnvelopeTag(TEAMMATE_MESSAGE_TAG, summary) : undefined;
+                    const safeSummary = escapeEnvelopeTag(TEAMMATE_MESSAGE_TAG, summary);
                     const safeMessage = escapeEnvelopeTag(TEAMMATE_MESSAGE_TAG, message);
-                    const marker = await resume(`${fromPrefix}${safeSummary ? `[${safeSummary}] ${safeMessage}` : safeMessage}`);
+                    const marker = await resume(`${fromPrefix}[${safeSummary}] ${safeMessage}`);
                     return {
                         content: `Message sent — ${who} resumed in the background with its prior context intact (correlation marker [${marker}]).\n` +
                             `You will be notified automatically when it completes; its reply will carry [${marker}]. Continue with other work — do not poll.`,
-                        details: { type: "send-message", status: "resumed", to, task_id: targetId, marker, ...(summary !== undefined ? { summary } : {}) },
+                        details: { type: "send-message", status: "resumed", to, task_id: targetId, marker, summary },
                     };
                 }
                 catch (e) {

package/dist/agents/subagent.js

@@ -1372,8 +1372,10 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 const editedFiles = stepRecorder.editedFiles();
                 return { ...(recentSteps ? { recentSteps } : {}), ...(editedFiles ? { editedFiles } : {}) };
             };
+            const treeScope = reviveClaim?.row.scope ?? ctx.principal ?? opts.background?.scope;
             const childInternals = {
                 ...(inheritedManifestScope ? { inheritedManifestScope } : {}),
+                ...(treeScope !== undefined ? { registryScope: treeScope } : {}),
                 ...(ctx.inheritedGateForChildren ? { inheritedGate: ctx.inheritedGateForChildren() } : {}),
                 ...(childDefaultPersona !== undefined ? { defaultSystemPrompt: childDefaultPersona } : {}),
                 isDelegatedChild: true,
@@ -1632,7 +1634,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                     }
                     const shortDesc = `fork: ${(typeof a.description === "string" && a.description.trim() ? a.description.trim() : prompt).slice(0, 180)}`;
                     const bgOwner = sessionScopedBg ? ctx.sessionId : ctx.taskId ?? bg.owner;
-                    const bgScope = ctx.principal ?? bg.scope;
+                    const bgScope = treeScope;
                     let taskId;
                     try {
                         taskId = bg.registry.registerBackgroundAgent({
@@ -2037,7 +2039,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 }
                 const shortDesc = reviveRow?.description ?? String(a.description ?? "sub-agent").slice(0, 200);
                 const bgOwner = reviveRow !== undefined ? reviveRow.owner : sessionScopedBg ? ctx.sessionId : ctx.taskId ?? bg.owner;
-                const bgScope = reviveRow !== undefined ? reviveRow.scope : ctx.principal ?? bg.scope;
+                const bgScope = treeScope;
                 let taskId;
                 try {
                     taskId = bg.registry.registerBackgroundAgent(reviveRow !== undefined

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

@@ -242,6 +242,7 @@ export interface CheckpointSummary {
     contentKind?: "content_ask";
     createdAt?: number;
     toolInput?: string;
+    restoreMode?: "snapshot" | "park_only";
     preview?: unknown;
 }
 export declare function summarizeCheckpoint(cp: Checkpoint): CheckpointSummary;

package/dist/core/checkpoint-store.js

@@ -181,6 +181,9 @@ export function summarizeCheckpoint(cp) {
         ...(tool !== undefined ? { toolCallId: tool.toolCallId, toolName: tool.toolName } : {}),
         ...(tool?.toolName === ASK_USER_QUESTION_TOOL_NAME ? { contentKind: "content_ask" } : {}),
         ...(toolInput !== undefined ? { toolInput } : {}),
+        ...(cp.state.workspaceHandle !== undefined
+            ? { restoreMode: cp.state.workspaceHandle.restoreMode === "park_only" ? "park_only" : "snapshot" }
+            : {}),
         ...(tool?.preview !== undefined ? { preview: tool.preview } : {}),
     };
 }

package/dist/core/consolidate-scope.js

@@ -23,8 +23,10 @@ export async function consolidateScope(scope, deps, opts = {}) {
             "(getConsolidationCursor/setConsolidationCursor) — skipped (no-op), NOT degraded to a full re-consolidation"));
         return undefined;
     }
-    if (!supportsConsolidation(store) || typeof store.listStructuredNotes !== "function") {
-        onWarn?.(new Error("consolidateScope: store is not id-addressable / has no manifest — skipped (no-op)"));
+    if (!supportsConsolidation(store) ||
+        typeof store.listStructuredNotes !== "function" ||
+        typeof store.getByIds !== "function") {
+        onWarn?.(new Error("consolidateScope: store is not id-addressable / has no manifest read pair — skipped (no-op)"));
         return undefined;
     }
     const release = deps.acquire ? await deps.acquire(scope) : () => { };

package/dist/core/context-edit.js

@@ -76,29 +76,28 @@ export function clearStaleToolResults(messages, opts) {
     }
     const keep = opts.keepRecentToolResults ?? 3;
     const compactable = opts.compactableTools ?? COMPACTABLE_TOOLS;
-    const toolResultIdx = messages.flatMap((m, i) => isToolResult(m) && !isCleared(m) && compactable.has(m.toolName ?? "") ? [i] : []);
-    const clearable = toolResultIdx.slice(0, Math.max(0, toolResultIdx.length - keep));
+    const toolResultCandidates = messages.flatMap((m, i) => isToolResult(m) && !isCleared(m) && compactable.has(m.toolName) ? [{ idx: i, target: m }] : []);
+    const clearable = toolResultCandidates.slice(0, Math.max(0, toolResultCandidates.length - keep));
     if (clearable.length === 0) {
         return messages;
     }
     const out = messages.slice();
     let current = total;
-    for (const idx of clearable) {
+    for (const { idx, target } of clearable) {
         if (current <= opts.budgetTokens) {
             break;
         }
-        const before = estimateTokens(out[idx], cpt);
-        const msg = out[idx];
-        const rawContent = Array.isArray(msg.content) ? msg.content : [];
+        const before = estimateTokens(target, cpt);
+        const rawContent = Array.isArray(target.content) ? target.content : [];
         let ref;
         if (opts.offload) {
             const fullText = rawContent
                 .filter((c) => c?.type === "text" && typeof c.text === "string")
                 .map((c) => c.text)
                 .join("\n");
-            if (msg.toolCallId && fullText.trim().length > 0) {
+            if (target.toolCallId && fullText.trim().length > 0) {
                 try {
-                    ref = refNote(opts.offload.persist(msg.toolCallId, fullText));
+                    ref = refNote(opts.offload.persist(target.toolCallId, fullText));
                 }
                 catch {
                     ref = undefined;
@@ -107,10 +106,7 @@ export function clearStaleToolResults(messages, opts) {
         }
         const mediaBlocks = rawContent.filter((c) => c?.type !== "text");
         const marker = clearedMarker([ref, mediaBlocks.length > 0 ? mediaNote(mediaBlocks) : undefined]);
-        const cleared = {
-            ...out[idx],
-            content: [{ type: "text", text: marker }],
-        };
+        const cleared = { ...target, content: [{ type: "text", text: marker }] };
         out[idx] = cleared;
         current -= idx > anchorIdx ? before - estimateTokens(cleared, cpt) : 0;
     }

package/dist/core/mcp.d.ts

@@ -57,6 +57,7 @@ export interface McpServerStatus {
     };
     toolNames?: string[];
     error?: string;
+    transportClosed?: boolean;
 }
 export declare const MCP_PREFIX = "mcp__";
 export declare function resolveMcpDeclaredResultSize(meta: Record<string, unknown> | undefined): number | undefined;
@@ -69,6 +70,7 @@ export declare const MCP_IDLE_TIMEOUT_STDIO_DEFAULT_MS: number;
 export declare const MCP_IDLE_TIMEOUT_HTTP_DEFAULT_MS: number;
 export declare function mcpIdleTimeoutMs(kind: "stdio" | "http"): number;
 export declare function describeMcpSpecErrorCode(code: unknown): string | undefined;
+export declare function collapseMcpErrorPrefix(message: string): string;
 export declare function normalizeMcpName(name: string): string;
 export declare function clampNameSegment(seg: string, max?: number): string;
 export * from "./image-downsample.js";

package/dist/core/mcp.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { StreamableHTTPClientTransport, StreamableHTTPError } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { lstat, mkdir, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -145,8 +145,24 @@ const MCP_SPEC_ERROR_CODE_NAMES = new Map([
 export function describeMcpSpecErrorCode(code) {
     return typeof code === "number" ? MCP_SPEC_ERROR_CODE_NAMES.get(code) : undefined;
 }
+export function collapseMcpErrorPrefix(message) {
+    let out = message;
+    for (;;) {
+        const m = /^MCP error (-?\d+): (?=MCP error \1: )/.exec(out);
+        if (m === null)
+            return out;
+        out = out.slice(m[0].length);
+    }
+}
+function collapseMcpErrorStampInPlace(err) {
+    if (!(err instanceof McpError))
+        return;
+    const collapsed = collapseMcpErrorPrefix(err.message);
+    if (collapsed !== err.message)
+        err.message = collapsed;
+}
 function namedMcpFailureText(err) {
-    const detail = err instanceof Error ? err.message : String(err);
+    const detail = err instanceof Error ? collapseMcpErrorPrefix(err.message) : String(err);
     const condition = err instanceof McpError ? describeMcpSpecErrorCode(err.code) : undefined;
     return condition !== undefined ? `${condition}: ${detail}` : detail;
 }
@@ -155,6 +171,53 @@ function isTransportLost(err) {
         return true;
     return err instanceof Error && /not connected|connection closed/i.test(err.message);
 }
+const NETWORK_CODES_NEVER_DELIVERED = new Set([
+    "ECONNREFUSED",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "UND_ERR_CONNECT_TIMEOUT",
+]);
+function networkErrorCode(err, depth = 0) {
+    if (depth > 5 || !(err instanceof Error))
+        return undefined;
+    const code = err.code;
+    if (typeof code === "string" && /^(?:E[A-Z]+|UND_ERR_[A-Z_]+)$/.test(code))
+        return code;
+    if (err instanceof AggregateError) {
+        for (const inner of err.errors) {
+            const found = networkErrorCode(inner, depth + 1);
+            if (found !== undefined)
+                return found;
+        }
+    }
+    return networkErrorCode(err.cause, depth + 1);
+}
+function describeHttpTransportFailure(err) {
+    if (err instanceof McpError)
+        return undefined;
+    if (err instanceof StreamableHTTPError) {
+        const status = typeof err.code === "number" && err.code > 0 ? err.code : undefined;
+        return {
+            condition: status !== undefined
+                ? `its HTTP endpoint answered ${status} instead of an MCP response`
+                : "its HTTP endpoint answered something that is not an MCP response",
+            delivered: "unknown",
+            ...(status !== undefined ? { httpStatus: status } : {}),
+        };
+    }
+    const code = networkErrorCode(err);
+    if (code !== undefined) {
+        return NETWORK_CODES_NEVER_DELIVERED.has(code)
+            ? { condition: `its HTTP endpoint could not be reached (${code})`, delivered: "no" }
+            : { condition: `the connection to its HTTP endpoint failed (${code})`, delivered: "unknown" };
+    }
+    if (err instanceof TypeError && /fetch failed|terminated|network/i.test(err.message)) {
+        return { condition: "the HTTP request to its endpoint failed at the network layer", delivered: "unknown" };
+    }
+    return undefined;
+}
 function writeEffectWarning(writeEffect) {
     return writeEffect
         ? " This tool is write-capable: treat its side effects as POSSIBLY APPLIED and verify the actual state before retrying."
@@ -173,6 +236,7 @@ function rethrowHonestMcpError(err, ctx) {
     }
     if (ctx.signal?.aborted)
         throw err;
+    collapseMcpErrorStampInPlace(err);
     const serverLabel = inlineUntrusted(ctx.server);
     if (err instanceof McpError && err.code === ErrorCode.RequestTimeout) {
         const data = err.data;
@@ -193,6 +257,21 @@ function rethrowHonestMcpError(err, ctx) {
         e.details = { transportLost: true, server: ctx.server };
         throw e;
     }
+    const httpFailure = describeHttpTransportFailure(err);
+    if (httpFailure !== undefined) {
+        const detail = err instanceof Error ? err.message : String(err);
+        const fenced = `\nThe transport error follows as external/untrusted data:\n${delimitUntrusted(`${ctx.server} transport error`, truncateMcpErrorText(detail))}`;
+        const e = new Error(httpFailure.delivered === "no"
+            ? `${ctx.what} could not reach MCP server "${serverLabel}": ${httpFailure.condition}. The request was not delivered, so the server did not execute it. This server's tools and resources will keep failing until its endpoint is reachable again — do not retry them; use an alternative if one exists.${fenced}`
+            : `${ctx.what} failed at the transport layer of MCP server "${serverLabel}": ${httpFailure.condition}. The request may or may not have executed on the server — the outcome is unknown.${writeEffectWarning(ctx.writeEffect)}${fenced}`, { cause: err });
+        e.errorKind = httpFailure.delivered === "no" ? "server_disconnected" : "transport_lost";
+        e.details = {
+            server: ctx.server,
+            ...(httpFailure.delivered === "no" ? {} : { transportLost: true }),
+            ...(httpFailure.httpStatus !== undefined ? { httpStatus: httpFailure.httpStatus } : {}),
+        };
+        throw e;
+    }
     if (err instanceof McpError) {
         const condition = describeMcpSpecErrorCode(err.code);
         if (condition !== undefined) {
@@ -546,12 +625,16 @@ export async function materializeMcpTools(specs, principal, onElicit, imageResiz
                     serverInstructions.push({ server: spec.name, text: s.instructions });
                 }
                 const hasInstructions = s.instructions !== undefined;
-                s.announce.fn = () => {
-                    if (!disposing && hasInstructions)
+                const announceClose = () => {
+                    if (disposing)
+                        return;
+                    s.status.transportClosed = true;
+                    if (hasInstructions)
                         instructionsDelta.pendingRemovals.push(spec.name);
                 };
-                if (s.health.dead && hasInstructions)
-                    instructionsDelta.pendingRemovals.push(spec.name);
+                s.announce.fn = announceClose;
+                if (s.health.dead)
+                    announceClose();
                 if (s.resourceServer)
                     resourceServers.push(s.resourceServer);
                 for (const d of s.dropped)

package/dist/core/memory.d.ts

@@ -47,8 +47,10 @@ export interface MemoryNoteHeader {
 export interface MemoryNoteRecord extends MemoryNoteHeader {
     text: string;
 }
-export declare function supportsConsolidation(store: MemoryStore): boolean;
-export declare function supportsPeriodicConsolidation(store: MemoryStore): boolean;
+export type ConsolidationCapableStore = MemoryStore & Required<Pick<MemoryStore, "searchScored" | "update" | "delete">>;
+export declare function supportsConsolidation(store: MemoryStore): store is ConsolidationCapableStore;
+export type PeriodicConsolidationCapableStore = MemoryStore & Required<Pick<MemoryStore, "getConsolidationCursor" | "setConsolidationCursor">>;
+export declare function supportsPeriodicConsolidation(store: MemoryStore): store is PeriodicConsolidationCapableStore;
 export declare const CALLER_AUTHORED_TYPES: ReadonlySet<string>;
 export declare const DEFAULT_CALLER_AUTHORED_TYPE: MemoryNoteType;
 export type UtilityGate = (stats: unknown) => boolean;

package/dist/core/message-utils.d.ts

@@ -1,3 +1,4 @@
 import type { AgentMessage } from "../internal/harness-types.js";
+import type { ToolResultMessage } from "../internal/llm.js";
 export declare function messageRole(m: AgentMessage): string | undefined;
-export declare function isToolResult(m: AgentMessage): boolean;
+export declare function isToolResult(m: AgentMessage): m is ToolResultMessage;

package/dist/core/remote-env.d.ts

@@ -44,6 +44,8 @@ export interface ExecStreamOptions {
     maxOutputBytes?: number;
 }
 export type RemoteExecutionErrorCode = "suspended" | "command_in_flight" | "connect_failed" | "post_resume_failed" | "aborted" | "timeout" | "unsupported" | "auth_transient" | "auth_failed" | "transport_lost" | "unknown";
+export declare const RETRYABLE_REMOTE_ERROR_CODES: readonly RemoteExecutionErrorCode[];
+export declare function isRetryableRemoteErrorCode(code: RemoteExecutionErrorCode): boolean;
 export declare class RemoteExecutionError extends Error {
     readonly code: RemoteExecutionErrorCode;
     constructor(code: RemoteExecutionErrorCode, message: string, cause?: Error);
@@ -101,5 +103,6 @@ export interface ExecutionEnvFactoryContext {
 export type ExecutionEnvFactory = (ctx: ExecutionEnvFactoryContext) => ExecutionEnv | Promise<ExecutionEnv>;
 export declare function hasDestroy(env: ExecutionEnv): env is ExecutionEnv & Pick<RemoteExecutionEnv, "destroy">;
 export declare function isRemoteExecutionEnv(env: ExecutionEnv): env is RemoteExecutionEnv;
+export declare function missingRestoreSurface(env: ExecutionEnv): readonly ("resumeVM" | "postResumeInit")[];
 export declare function isSuspendable(env: ExecutionEnv): env is RemoteExecutionEnv;
 export declare function isIsolated(env: ExecutionEnv): boolean;

package/dist/core/remote-env.js

@@ -1,3 +1,12 @@
+export const RETRYABLE_REMOTE_ERROR_CODES = [
+    "auth_transient",
+    "connect_failed",
+    "timeout",
+    "transport_lost",
+];
+export function isRetryableRemoteErrorCode(code) {
+    return RETRYABLE_REMOTE_ERROR_CODES.includes(code);
+}
 export class RemoteExecutionError extends Error {
     code;
     constructor(code, message, cause) {
@@ -18,8 +27,17 @@ export function isRemoteExecutionEnv(env) {
         typeof e.capabilities === "object" &&
         e.capabilities !== null);
 }
+export function missingRestoreSurface(env) {
+    const e = env;
+    const missing = [];
+    if (typeof e.resumeVM !== "function")
+        missing.push("resumeVM");
+    if (typeof e.postResumeInit !== "function")
+        missing.push("postResumeInit");
+    return missing;
+}
 export function isSuspendable(env) {
-    return isRemoteExecutionEnv(env) && env.capabilities.suspendable;
+    return isRemoteExecutionEnv(env) && env.capabilities.suspendable && missingRestoreSurface(env).length === 0;
 }
 export function isIsolated(env) {
     return isRemoteExecutionEnv(env) ? env.capabilities.isolation : false;

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

@@ -70,6 +70,7 @@ export interface ResultFlags {
     model?: string;
     unpricedSpend?: boolean;
     rewindNotes?: TaskResult["rewindNotes"];
+    remoteEnvFailures?: TaskResult["remoteEnvFailures"];
     abortedForTimeout: boolean;
     abortedForTurns: boolean;
     abortedLive?: boolean;
@@ -81,10 +82,12 @@ export interface ResultFlags {
     suspendRef?: {
         token: import("../checkpoint-store.js").CheckpointToken;
         gate: import("../checkpoint-store.js").CheckpointGate;
+        restoreMode?: "snapshot" | "park_only";
     };
     reviewRef?: {
         token: import("../checkpoint-store.js").CheckpointToken;
         gate: import("../checkpoint-store.js").CheckpointGate;
+        restoreMode?: "snapshot" | "park_only";
     };
 }
 export declare function errorCodeOf(err: unknown): string | undefined;

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

@@ -54,6 +54,7 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
     let salvagedOutput;
     let checkpointToken;
     let checkpointGate;
+    let workspaceRestoreMode;
     const isDegenerate = final?.stopReason === "error" && final.errorMessage === DEGENERATE_MESSAGE;
     const isWalltimeCutoff = final?.stopReason === "error" && final.errorMessage === WALLTIME_CUTOFF_MESSAGE;
     if (flags.outputInvalid) {
@@ -105,12 +106,14 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
         status = "suspended";
         checkpointToken = flags.suspendRef.token;
         checkpointGate = flags.suspendRef.gate;
+        workspaceRestoreMode = flags.suspendRef.restoreMode;
     }
     else if (flags.reviewRef) {
         status = "needs_review";
         errorCode = "review.pending";
         checkpointToken = flags.reviewRef.token;
         checkpointGate = flags.reviewRef.gate;
+        workspaceRestoreMode = flags.reviewRef.restoreMode;
     }
     else if (flags.abortedLive || final?.stopReason === "aborted") {
         status = flags.abortedForTimeout ? "timeout" : "failed";
@@ -143,5 +146,5 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
     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, ...(flags.rewindNotes !== undefined && flags.rewindNotes.length > 0 ? { rewindNotes: flags.rewindNotes } : {}), stats: publicStats };
+    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 };
 }

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

@@ -127,12 +127,15 @@ export interface Prepared {
         token?: CheckpointToken;
         gate?: CheckpointGate;
         scope?: string;
+        restoreMode?: "snapshot" | "park_only";
     };
     reviewRef: {
         token?: CheckpointToken;
         gate?: CheckpointGate;
         scope?: string;
+        restoreMode?: "snapshot" | "park_only";
     };
+    remoteEnvFailures: NonNullable<TaskResult["remoteEnvFailures"]>;
     suspendLoopRef: {
         hit: boolean;
     };
@@ -308,6 +311,7 @@ export interface RunInternals {
     parentTaskId?: string;
     parentSessionId?: string;
     rootSessionId?: string;
+    registryScope?: string;
     parentCenterArtifactDigest?: string;
     parentCenterSourceRevision?: string;
     promptProfile?: "simple" | "classic";
@@ -339,4 +343,5 @@ export declare function batchContextAt(messages: AgentMessage[], currentId: stri
     completedCallIds: string[];
 };
 export declare function rebaseWorkspacePath(p: string, fromRaw: string, toRaw: string): string;
+export declare function rebaseWorkspacePathAcross(p: string, froms: readonly string[], to: string): string;
 export declare function prepareTask(spec: TaskSpec, deps: RunnerDeps, sessions: SessionStore, resume?: PrepareResume, internals?: RunInternals, runnerSelf?: Runner): Promise<Prepared>;