@the-open-engine/zeroshot 6.9.1 → 6.10.1

package/src/agent/guidance-queue.js

@@ -1,5 +1,6 @@
 const GUIDANCE_BLOCK_START = '<<GUIDANCE_QUEUE_START>>';
 const GUIDANCE_BLOCK_END = '<<GUIDANCE_QUEUE_END>>';
+const { compareMessageSequences } = require('../ledger-sequence');
 
 function formatGuidanceMessage(message) {
   const timestamp = Number.isFinite(message.timestamp)
@@ -21,10 +22,19 @@ function formatGuidanceMessage(message) {
   return formatted.trimEnd();
 }
 
-function formatGuidanceBlock(messages) {
+function orderGuidanceMessages(messages, orderBySequence) {
+  return messages.slice().sort((a, b) => {
+    if (orderBySequence) {
+      return compareMessageSequences(a.sequence || '0', b.sequence || '0');
+    }
+    return (a.timestamp || 0) - (b.timestamp || 0);
+  });
+}
+
+function formatGuidanceBlock(messages, { orderBySequence = false } = {}) {
   if (!Array.isArray(messages) || messages.length === 0) return '';
 
-  const ordered = messages.slice().sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
+  const ordered = orderGuidanceMessages(messages, orderBySequence);
 
   let block = '## Guidance (Queued)\n\n';
   block += `${GUIDANCE_BLOCK_START}\n`;
@@ -40,7 +50,15 @@ function formatGuidanceBlock(messages) {
   return block;
 }
 
-function collectQueuedGuidance({ messageBus, clusterId, agentId, lastDeliveredAt, limit }) {
+function collectQueuedGuidance({
+  messageBus,
+  clusterId,
+  agentId,
+  afterId,
+  throughId,
+  lastDeliveredAt,
+  limit,
+}) {
   if (!messageBus) {
     throw new Error('collectQueuedGuidance: messageBus is required');
   }
@@ -54,19 +72,23 @@ function collectQueuedGuidance({ messageBus, clusterId, agentId, lastDeliveredAt
   const messages = messageBus.queryGuidanceMailbox({
     cluster_id: clusterId,
     target_agent_id: agentId,
+    afterId,
+    throughId,
     lastDeliveredAt,
     limit,
   });
 
   if (!messages.length) {
-    return { messages: [], latestTimestamp: null, guidanceBlock: '' };
+    return { messages: [], latestSequence: null, latestTimestamp: null, guidanceBlock: '' };
   }
 
-  const ordered = messages.slice().sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
+  const sequenceBounded = afterId !== undefined || throughId !== undefined;
+  const ordered = orderGuidanceMessages(messages, sequenceBounded);
+  const latestSequence = ordered[ordered.length - 1].sequence;
   const latestTimestamp = ordered[ordered.length - 1].timestamp;
-  const guidanceBlock = formatGuidanceBlock(ordered);
+  const guidanceBlock = formatGuidanceBlock(ordered, { orderBySequence: sequenceBounded });
 
-  return { messages: ordered, latestTimestamp, guidanceBlock };
+  return { messages: ordered, latestSequence, latestTimestamp, guidanceBlock };
 }
 
 module.exports = {

package/src/agent/provider-session.js

@@ -0,0 +1,277 @@
+const crypto = require('crypto');
+const path = require('path');
+
+const { normalizeProviderName, providerSupportsCapability } = require('../../lib/provider-names');
+const { tryCanonicalMessageSequence } = require('../ledger-sequence');
+
+const DURABLE_SESSION_BOUNDARY_EVENTS = new Set([
+  'TASK_STARTED',
+  'TASK_COMPLETED',
+  'TASK_FAILED',
+  'RETRY_SCHEDULED',
+  'AGENT_RESTART_ATTEMPT',
+]);
+const RESTORABLE_AGENT_STATES = new Set(['idle', 'stopped', 'completed']);
+
+function normalizeNonEmptyString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function normalizeAbsolutePath(value) {
+  const normalized = normalizeNonEmptyString(value);
+  return normalized ? path.resolve(normalized) : null;
+}
+
+function normalizeCursor(value) {
+  return tryCanonicalMessageSequence(value);
+}
+
+function normalizeNullableCursor(value) {
+  return value === null ? null : normalizeCursor(value);
+}
+
+function normalizePromptIdentity(value) {
+  if (value === null) {
+    return null;
+  }
+  return typeof value === 'string' && /^sha256:[a-f0-9]{64}$/.test(value) ? value : undefined;
+}
+
+function promptIdentity(value) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  return `sha256:${crypto.createHash('sha256').update(String(value)).digest('hex')}`;
+}
+
+function supportsSessionResume(providerName) {
+  try {
+    return providerSupportsCapability(providerName, 'sessionResume');
+  } catch {
+    return false;
+  }
+}
+
+function normalizeProviderSession(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return null;
+  }
+
+  const provider = normalizeProviderName(value.provider);
+  const sessionId = normalizeNonEmptyString(value.sessionId);
+  const agentId = normalizeNonEmptyString(value.agentId);
+  const taskId = normalizeNonEmptyString(value.taskId);
+  const generation = value.generation;
+  const cwd = normalizeAbsolutePath(value.cwd);
+  const worktreePath =
+    value.worktreePath === null ? null : normalizeAbsolutePath(value.worktreePath);
+  const contextSequence = normalizeCursor(value.contextSequence);
+  const guidanceSequence = normalizeNullableCursor(value.guidanceSequence);
+  const normalizedPromptIdentity = normalizePromptIdentity(value.promptIdentity);
+
+  if (
+    !provider ||
+    !sessionId ||
+    !agentId ||
+    !taskId ||
+    !Number.isInteger(generation) ||
+    generation < 1 ||
+    !cwd ||
+    !Object.hasOwn(value, 'worktreePath') ||
+    (value.worktreePath !== null && !worktreePath) ||
+    contextSequence === null ||
+    !Object.hasOwn(value, 'guidanceSequence') ||
+    (value.guidanceSequence !== null && guidanceSequence === null) ||
+    !Object.hasOwn(value, 'promptIdentity') ||
+    normalizedPromptIdentity === undefined ||
+    !supportsSessionResume(provider)
+  ) {
+    return null;
+  }
+
+  return {
+    provider,
+    sessionId,
+    agentId,
+    taskId,
+    generation,
+    cwd,
+    worktreePath,
+    contextSequence,
+    guidanceSequence,
+    promptIdentity: normalizedPromptIdentity,
+  };
+}
+
+function agentWorkspaceProvenance(agent) {
+  const worktreePath = agent?.worktree?.enabled ? normalizeAbsolutePath(agent.worktree.path) : null;
+  const cwd = normalizeAbsolutePath(agent?.config?.cwd || worktreePath || process.cwd());
+  return { cwd, worktreePath };
+}
+
+function agentCanReuseSession(agent, providerName) {
+  return !agent?.isolation?.enabled && supportsSessionResume(providerName);
+}
+
+function sessionMatchesAgent(session, agent, providerName, expectedGeneration) {
+  const provider = normalizeProviderName(providerName);
+  const workspace = agentWorkspaceProvenance(agent);
+  return (
+    agentCanReuseSession(agent, provider) &&
+    session.provider === provider &&
+    session.agentId === agent?.id &&
+    session.generation === expectedGeneration &&
+    session.cwd === workspace.cwd &&
+    session.worktreePath === workspace.worktreePath
+  );
+}
+
+function resolveAgentProviderSession(agent, providerName) {
+  const stored = normalizeProviderSession(agent?.providerSession);
+  const expectedGeneration = Number.isInteger(agent?.iteration) ? agent.iteration - 1 : -1;
+
+  if (!stored || !sessionMatchesAgent(stored, agent, providerName, expectedGeneration)) {
+    if (agent) {
+      if (agent.providerSession) {
+        agent.lastGuidanceAppliedId = null;
+      }
+      agent.providerSession = null;
+    }
+    return null;
+  }
+
+  return stored;
+}
+
+function resolveAgentResumeSessionId(agent, providerName) {
+  return resolveAgentProviderSession(agent, providerName)?.sessionId || null;
+}
+
+function validateCompletedResumeIdentity(taskInfo) {
+  const requestedSessionId = normalizeNonEmptyString(taskInfo?.requestedResumeSessionId);
+  if (!requestedSessionId) {
+    return null;
+  }
+  if (taskInfo?.resumeIdentityVerified !== true) {
+    return 'Provider continuation identity was not durably verified';
+  }
+  if (taskInfo?.sessionIdConflict === true) {
+    return 'Provider continuation emitted conflicting session identities';
+  }
+
+  const capturedSessionId = normalizeNonEmptyString(taskInfo?.sessionId);
+  if (capturedSessionId === requestedSessionId) {
+    return null;
+  }
+
+  return capturedSessionId
+    ? 'Provider continuation returned a different session identity'
+    : 'Provider continuation did not confirm the requested session identity';
+}
+
+function providerSessionFromCompletedTask({
+  agent,
+  providerName,
+  taskInfo,
+  logicalSuccess = true,
+}) {
+  const provider = normalizeProviderName(providerName);
+  if (!logicalSuccess || !agentCanReuseSession(agent, provider)) {
+    return null;
+  }
+  if (!taskInfo || taskInfo.status !== 'completed') {
+    return null;
+  }
+  if (normalizeProviderName(taskInfo.provider) !== provider) {
+    return null;
+  }
+  if (taskInfo.sessionIdConflict === true) {
+    return null;
+  }
+  if (validateCompletedResumeIdentity(taskInfo)) {
+    return null;
+  }
+
+  const sessionId = normalizeNonEmptyString(taskInfo.sessionId);
+  const taskId = normalizeNonEmptyString(taskInfo.id);
+  const generation = agent?.iteration;
+  const agentId = normalizeNonEmptyString(agent?.id);
+  const workspace = agentWorkspaceProvenance(agent);
+  return normalizeProviderSession({
+    provider,
+    sessionId,
+    agentId,
+    taskId,
+    generation,
+    ...workspace,
+    contextSequence: agent?.currentContextSequence,
+    guidanceSequence: agent?.currentGuidanceSequence ?? null,
+    promptIdentity: agent?.currentPromptIdentity ?? null,
+  });
+}
+
+function updateAgentProviderSession(agent, value) {
+  if (agent.providerSession && value === null) {
+    agent.lastGuidanceAppliedId = null;
+  }
+  const session = normalizeProviderSession(value);
+  agent.providerSession = session;
+  return session;
+}
+
+function readLastDurableSessionBoundary(messageBus, clusterId, agentId) {
+  const lifecycle = messageBus.query({
+    cluster_id: clusterId,
+    topic: 'AGENT_LIFECYCLE',
+    sender: agentId,
+    afterId: '0',
+  });
+  return lifecycle
+    .filter((message) => DURABLE_SESSION_BOUNDARY_EVENTS.has(message.content?.data?.event))
+    .at(-1);
+}
+
+function restoreAgentProviderSession({ agent, savedState, messageBus, clusterId }) {
+  const session = normalizeProviderSession(savedState?.providerSession);
+  if (!session || !RESTORABLE_AGENT_STATES.has(savedState?.state)) {
+    return null;
+  }
+  if (
+    !Object.hasOwn(savedState, 'lastGuidanceAppliedId') ||
+    normalizeNullableCursor(savedState.lastGuidanceAppliedId) !== session.guidanceSequence
+  ) {
+    return null;
+  }
+  if (!sessionMatchesAgent(session, agent, session.provider, savedState.iteration)) {
+    return null;
+  }
+
+  const boundary = readLastDurableSessionBoundary(messageBus, clusterId, agent.id);
+  const data = boundary?.content?.data;
+  if (
+    data?.event !== 'TASK_COMPLETED' ||
+    data.taskId !== session.taskId ||
+    data.iteration !== session.generation ||
+    normalizeProviderName(data.provider) !== session.provider ||
+    normalizeCursor(data.contextSequence) !== session.contextSequence ||
+    normalizeNullableCursor(data.guidanceSequence) !== session.guidanceSequence ||
+    data.promptIdentity !== session.promptIdentity
+  ) {
+    return null;
+  }
+
+  return session;
+}
+
+module.exports = {
+  agentWorkspaceProvenance,
+  normalizeProviderSession,
+  promptIdentity,
+  providerSessionFromCompletedTask,
+  resolveAgentProviderSession,
+  resolveAgentResumeSessionId,
+  restoreAgentProviderSession,
+  supportsSessionResume,
+  updateAgentProviderSession,
+  validateCompletedResumeIdentity,
+};

package/src/agent-cli-provider/adapters/claude.ts

@@ -1,4 +1,5 @@
-import { stringifyJson } from '../json';
+import { getString, isRecord, stringifyJson, tryParseJson } from '../json';
+import { contractError } from '../contract-errors';
 import {
   type BuildProviderCommandOptions,
   type ClaudeCliFeatures,
@@ -66,6 +67,11 @@ function detectCliFeatures(helpText?: string | null): ClaudeCliFeatures {
     supportsVerbose: unknown ? true : /--verbose/.test(help),
     supportsModel: unknown ? true : /--model/.test(help),
     supportsEffort: unknown ? true : /--effort/.test(help),
+    // Settings carry mandatory safety hooks, so an unprobed or old CLI must
+    // fail closed before a provider process is spawned.
+    supportsSettings: !unknown && /--settings/.test(help),
+    supportsMcpConfig: !unknown && /--mcp-config/.test(help),
+    supportsResume: unknown ? true : /--resume/.test(help),
     unknown,
   };
 }
@@ -115,15 +121,62 @@ function addAutoApproveArgs(args: string[], options: BuildProviderCommandOptions
 }
 
 function addSessionArgs(args: string[], options: BuildProviderCommandOptions): void {
-  if (options.resumeSessionId) {
+  const features = optionFeatures(options);
+  if ((options.resumeSessionId || options.continueSession) && features.supportsResume === false) {
+    throw new Error(
+      'Claude CLI cannot safely run continuation context because this installation lacks --resume.'
+    );
+  }
+  if (options.resumeSessionId && features.supportsResume !== false) {
     args.push('--resume', options.resumeSessionId);
     return;
   }
-  if (options.continueSession) {
+  if (options.continueSession && features.supportsResume !== false) {
     args.push('--continue');
   }
 }
 
+function addSettingsArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const settingsPath = options.claudeSettingsFile?.trim();
+  if (settingsPath) {
+    args.push('--settings', settingsPath);
+  }
+}
+
+function addMcpConfigArgs(args: string[], options: BuildProviderCommandOptions): void {
+  if (!options.mcpConfig?.length) return;
+  args.push('--mcp-config', ...options.mcpConfig);
+}
+
+function failClosedUnsupportedRunConfig(options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (options.claudeSettingsFile?.trim() && features.supportsSettings === false) {
+    throw contractError({
+      code: 'invalid-field',
+      field: 'options.cliFeatures.supportsSettings',
+      exitCode: 2,
+      message:
+        'Claude CLI does not advertise --settings support required for Zeroshot safety hooks. Upgrade Claude Code before running this task.',
+    });
+  }
+  if (options.mcpConfig?.length && features.supportsMcpConfig === false) {
+    throw contractError({
+      code: 'invalid-field',
+      field: 'options.cliFeatures.supportsMcpConfig',
+      exitCode: 2,
+      message:
+        'Claude CLI does not advertise --mcp-config support required to preserve repository MCP tools. Upgrade Claude Code before running this task.',
+    });
+  }
+}
+
+function extractSessionId(line: string): string | null {
+  const event = tryParseJson(line.trim());
+  if (!isRecord(event)) return null;
+  const sessionId = getString(event, 'session_id');
+  return sessionId?.trim() || null;
+}
+
 function collectWarnings(options: BuildProviderCommandOptions): WarningMetadata[] {
   const features = optionFeatures(options);
   const warnings: WarningMetadata[] = [];
@@ -171,15 +224,21 @@ function collectWarnings(options: BuildProviderCommandOptions): WarningMetadata[
 }
 
 function buildCommand(context: string, options: BuildProviderCommandOptions = {}): CommandSpec {
+  failClosedUnsupportedRunConfig(options);
   const { command, args: commandPrefix } = resolveClaudeCommand();
-  const args: string[] = [...commandPrefix, '--print', '--input-format', 'text'];
+  const args: string[] = [...commandPrefix, '--print'];
   const authEnv = options.authEnv ?? {};
 
+  // --mcp-config is variadic. A following option terminates its values before
+  // the positional prompt.
+  addMcpConfigArgs(args, options);
+  args.push('--input-format', 'text');
   addOutputArgs(args, options);
   addSchemaArgs(args, options);
   addModelArgs(args, options);
   addAutoApproveArgs(args, options);
   addSessionArgs(args, options);
+  addSettingsArgs(args, options);
 
   args.push(context);
 
@@ -228,6 +287,7 @@ export const claudeAdapter: ProviderAdapter = {
   defaultMinLevel: 'level1',
   detectCliFeatures,
   buildCommand,
+  extractSessionId,
   parseEvent: parseClaudeEvent,
   createParserState: () => createParserState('claude'),
   resolveModelSpec,

package/src/agent-cli-provider/adapters/codex.ts

@@ -1,3 +1,4 @@
+import { getString, isRecord, tryParseJson } from '../json';
 import { appendJsonSchemaPrompt, writeStrictOutputSchemaFile } from '../schema';
 import {
   type BuildProviderCommandOptions,
@@ -18,7 +19,6 @@ import {
   createParserState,
   optionFeatures,
   resolveModelSpecWithConfig,
-  unsupportedSessionControlWarnings,
   validateModelIdFromCatalog,
   warning,
 } from './common';
@@ -58,10 +58,18 @@ function detectCliFeatures(helpText?: string | null): CodexCliFeatures {
     supportsConfigOverride: supports(help, /--config\b/),
     supportsModel: supports(help, /\s-m\b/) || supports(help, /--model\b/),
     supportsSkipGitRepoCheck: supports(help, /--skip-git-repo-check\b/),
+    supportsResume: supports(help, /\bresume\b/),
     unknown,
   };
 }
 
+function extractSessionId(line: string): string | null {
+  const event = tryParseJson(line.trim());
+  if (!isRecord(event) || getString(event, 'type') !== 'thread.started') return null;
+  const sessionId = getString(event, 'thread_id');
+  return sessionId?.trim() || null;
+}
+
 function addOutputArgs(args: string[], options: BuildProviderCommandOptions): void {
   const features = optionFeatures(options);
   if (
@@ -121,7 +129,25 @@ function applySchemaArgs(
 
 function collectWarnings(options: BuildProviderCommandOptions): WarningMetadata[] {
   const features = optionFeatures(options);
-  const warnings: WarningMetadata[] = unsupportedSessionControlWarnings('codex', options);
+  const warnings: WarningMetadata[] = [];
+  if (options.continueSession) {
+    warnings.push(
+      warning(
+        'codex',
+        'unsupported-session-control',
+        'Codex requires an explicit session ID; ignoring continueSession.'
+      )
+    );
+  }
+  if (options.resumeSessionId && features.supportsResume === false) {
+    warnings.push(
+      warning(
+        'codex',
+        'codex-session-resume-unsupported',
+        'Codex CLI does not support exec resume; starting a fresh session.'
+      )
+    );
+  }
   if (options.autoApprove && features.supportsAutoApprove === false) {
     warnings.push(
       warning(
@@ -153,16 +179,33 @@ function collectWarnings(options: BuildProviderCommandOptions): WarningMetadata[
 }
 
 function buildCommand(context: string, options: BuildProviderCommandOptions = {}): CommandSpec {
+  if (options.resumeSessionId && optionFeatures(options).supportsResume === false) {
+    throw new Error(
+      'Codex CLI cannot safely run continuation context because this installation lacks exec resume.'
+    );
+  }
   const args: string[] = ['exec'];
   const cleanup: string[] = [];
+  const resumeSessionId =
+    options.resumeSessionId && optionFeatures(options).supportsResume !== false
+      ? options.resumeSessionId
+      : null;
+  if (resumeSessionId) {
+    args.push('resume');
+  }
 
   addOutputArgs(args, options);
   addModelArgs(args, options);
-  addCwdArgs(args, options);
+  if (!resumeSessionId) {
+    addCwdArgs(args, options);
+  }
   addAutoApproveArgs(args, options);
   addSkipGitArgs(args, options);
   const finalContext = applySchemaArgs(args, cleanup, context, options);
 
+  if (resumeSessionId) {
+    args.push(resumeSessionId);
+  }
   args.push(finalContext);
 
   return commandSpec({
@@ -216,6 +259,7 @@ export const codexAdapter: ProviderAdapter = {
   defaultMinLevel: 'level1',
   detectCliFeatures,
   buildCommand,
+  extractSessionId,
   parseEvent: parseCodexEvent,
   createParserState: () => createParserState('codex'),
   resolveModelSpec,

package/src/agent-cli-provider/adapters/common.ts

@@ -64,7 +64,7 @@ export function unsupportedSessionControlWarnings(
     warning(
       provider,
       'unsupported-session-control',
-      'resume/continue is only supported for Claude CLI; ignoring.'
+      `Provider ${provider} does not support resume/continue session control; ignoring.`
     ),
   ];
 }

package/src/agent-cli-provider/adapters/index.ts

@@ -79,6 +79,16 @@ export function parseProviderChunk(
   return events;
 }
 
+export function extractProviderSessionId(
+  providerName: KnownProviderName | string,
+  line: string
+): string | null {
+  const adapter = getProviderAdapter(providerName || 'claude');
+  const content = stripTimestampPrefix(line);
+  if (!content || !adapter.extractSessionId) return null;
+  return adapter.extractSessionId(content);
+}
+
 export function resolveModelSpec(
   providerName: KnownProviderName | string,
   level: ModelLevel,

package/src/agent-cli-provider/contract-options.ts

@@ -23,6 +23,7 @@ const CLI_FEATURE_FIELDS = [
   'supportsVerbose',
   'supportsModel',
   'supportsEffort',
+  'supportsSettings',
   'supportsJson',
   'supportsOutputSchema',
   'supportsDir',
@@ -42,6 +43,7 @@ const CLI_FEATURE_FIELDS = [
   'supportsNoAskUser',
   'supportsAddDir',
   'supportsMcpConfig',
+  'supportsResume',
   'supportsBundledRunner',
   'supportsAcpStdio',
   'supportsPromptImages',
@@ -208,6 +210,11 @@ function normalizeBuildOptions(value: Record<string, unknown>): BuildProviderCom
     'continueSession',
     optionalBooleanValue(value.continueSession, 'options.continueSession')
   );
+  addDefined(
+    result,
+    'claudeSettingsFile',
+    optionalStringValue(value.claudeSettingsFile, 'options.claudeSettingsFile')
+  );
   addDefined(result, 'cliFeatures', optionalCliFeatures(value.cliFeatures));
   addDefined(result, 'mcpConfig', optionalMcpConfig(value.mcpConfig));
   addDefined(

package/src/agent-cli-provider/index.ts

@@ -3,6 +3,7 @@ export {
   classifyProviderError,
   detectProviderFatalError,
   detectProviderStreamingModeError,
+  extractProviderSessionId,
   getProviderAdapter,
   listProviderAdapters,
   parseProviderChunk,

package/src/agent-cli-provider/provider-registry.ts

@@ -19,6 +19,7 @@ export interface ProviderCapabilities {
   readonly streamJson: ProviderCapabilityState;
   readonly thinkingMode: ProviderCapabilityState;
   readonly reasoningEffort: ProviderCapabilityState;
+  readonly sessionResume: ProviderCapabilityState;
 }
 
 interface FixedProviderCommandSpec {
@@ -93,13 +94,22 @@ export interface ProviderRegistryEntry {
 }
 
 const STANDARD_CAPABILITIES: Readonly<
-  Pick<ProviderCapabilities, 'dockerIsolation' | 'worktreeIsolation' | 'mcpServers' | 'streamJson' | 'thinkingMode'>
+  Pick<
+    ProviderCapabilities,
+    | 'dockerIsolation'
+    | 'worktreeIsolation'
+    | 'mcpServers'
+    | 'streamJson'
+    | 'thinkingMode'
+    | 'sessionResume'
+  >
 > = {
   dockerIsolation: true,
   worktreeIsolation: true,
   mcpServers: true,
   streamJson: true,
   thinkingMode: true,
+  sessionResume: false,
 };
 
 const CLAUDE_DOCKER_ENV_PASSTHROUGH = [
@@ -161,6 +171,7 @@ export const providerRegistry = [
       ...STANDARD_CAPABILITIES,
       jsonSchema: true,
       reasoningEffort: true,
+      sessionResume: true,
     },
     docs: {
       label: 'Claude',
@@ -197,6 +208,7 @@ export const providerRegistry = [
       ...STANDARD_CAPABILITIES,
       jsonSchema: true,
       reasoningEffort: true,
+      sessionResume: true,
     },
     docs: {
       label: 'Codex',