@the-open-engine/zeroshot 6.9.1 → 6.10.0

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,4 @@
-import { stringifyJson } from '../json';
+import { getString, isRecord, stringifyJson, tryParseJson } from '../json';
 import {
   type BuildProviderCommandOptions,
   type ClaudeCliFeatures,
@@ -66,6 +66,7 @@ function detectCliFeatures(helpText?: string | null): ClaudeCliFeatures {
     supportsVerbose: unknown ? true : /--verbose/.test(help),
     supportsModel: unknown ? true : /--model/.test(help),
     supportsEffort: unknown ? true : /--effort/.test(help),
+    supportsResume: unknown ? true : /--resume/.test(help),
     unknown,
   };
 }
@@ -115,15 +116,28 @@ 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 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[] = [];
@@ -228,6 +242,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

@@ -42,6 +42,7 @@ const CLI_FEATURE_FIELDS = [
   'supportsNoAskUser',
   'supportsAddDir',
   'supportsMcpConfig',
+  'supportsResume',
   'supportsBundledRunner',
   'supportsAcpStdio',
   'supportsPromptImages',

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',

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

@@ -101,6 +101,7 @@ export interface ClaudeCliFeatures extends BaseCliFeatures {
   readonly supportsVerbose: boolean;
   readonly supportsModel: boolean;
   readonly supportsEffort: boolean;
+  readonly supportsResume: boolean;
 }
 
 export interface CodexCliFeatures extends BaseCliFeatures {
@@ -112,6 +113,7 @@ export interface CodexCliFeatures extends BaseCliFeatures {
   readonly supportsConfigOverride: boolean;
   readonly supportsModel: boolean;
   readonly supportsSkipGitRepoCheck: boolean;
+  readonly supportsResume: boolean;
 }
 
 export interface GeminiCliFeatures extends BaseCliFeatures {
@@ -212,6 +214,7 @@ export interface CliFeatureOverrides {
   readonly supportsNoAskUser?: boolean;
   readonly supportsAddDir?: boolean;
   readonly supportsMcpConfig?: boolean;
+  readonly supportsResume?: boolean;
   readonly supportsBundledRunner?: boolean;
   readonly supportsAcpStdio?: boolean;
   readonly supportsPromptImages?: boolean;
@@ -368,6 +371,7 @@ export interface ProviderAdapter {
   readonly defaultMinLevel: ModelLevel;
   detectCliFeatures(helpText?: string | null): ProviderCliFeatures;
   buildCommand(context: string, options?: BuildProviderCommandOptions): CommandSpec;
+  extractSessionId?(line: string): string | null;
   parseEvent(line: string, state: ProviderParserState): ProviderParseResult;
   createParserState(): ProviderParserState;
   resolveModelSpec(level: ModelLevel, overrides?: LevelOverrides): ResolvedModelSpec;

package/src/agent-wrapper.js

@@ -17,6 +17,11 @@ const { normalizeProviderName } = require('../lib/provider-names');
 const { getProvider } = require('./providers');
 const { buildContext } = require('./agent/agent-context-builder');
 const { collectQueuedGuidance } = require('./agent/guidance-queue');
+const {
+  promptIdentity,
+  resolveAgentProviderSession,
+  updateAgentProviderSession,
+} = require('./agent/provider-session');
 const { findMatchingTrigger, evaluateTrigger } = require('./agent/agent-trigger-evaluator');
 const { executeHook } = require('./agent/agent-hook-executor');
 const { injectInput: injectAgentInput } = require('./agent/agent-input-injector');
@@ -66,6 +71,11 @@ class AgentWrapper {
     this.currentTask = null;
     /** @type {string | null} */
     this.currentTaskId = null; // Track spawned task ID for resume capability
+    /** @type {{provider: string, sessionId: string, agentId: string, taskId: string, generation: number, cwd: string, worktreePath: string|null, contextSequence: string, guidanceSequence: string|null, promptIdentity: string|null} | null} */
+    this.providerSession = null; // Provider continuation state, owned by this logical agent only
+    this.currentContextSequence = '0';
+    this.currentGuidanceSequence = null;
+    this.currentPromptIdentity = null;
     /** @type {number | null} */
     this.processPid = null; // Track process PID for resource monitoring
     this.running = false;
@@ -76,7 +86,7 @@ class AgentWrapper {
     /** @type {number | null} */
     this.lastAgentStartTime = null; // Track when agent last began executing (for context filtering)
     /** @type {number | null} */
-    this.lastGuidanceAppliedAt = null; // Track last queued guidance applied to prompt
+    this.lastGuidanceAppliedId = null; // Track last queued guidance sequence applied to prompt
 
     // LIVENESS DETECTION - Track output freshness to detect stuck agents
     /** @type {number | null} */
@@ -119,6 +129,7 @@ class AgentWrapper {
 
     this.testMode = options.testMode || false;
     this.quiet = options.quiet || false;
+    this.providerCliFeatures = options.providerCliFeatures || null;
 
     // ISOLATION SUPPORT - Run tasks inside Docker container
     this.isolation = options.isolation || null;
@@ -435,12 +446,29 @@ class AgentWrapper {
    */
   _buildContext(triggeringMessage) {
     const previousAgentStart = this.lastAgentStartTime;
+    const providerName = this._resolveProvider();
+    let providerSession = resolveAgentProviderSession(this, providerName);
+    if (providerSession && !this._providerSupportsSessionResume(providerName)) {
+      updateAgentProviderSession(this, null);
+      providerSession = null;
+    }
+    const contextMode = providerSession ? 'continuation' : 'full';
+    const selectedPrompt = this._selectPrompt();
+    const latestMessage = this.messageBus.findLast({
+      cluster_id: this.cluster.id,
+      orderBySequence: true,
+    });
+    this.currentContextSequence = latestMessage?.sequence || '0';
     const queuedGuidance = collectQueuedGuidance({
       messageBus: this.messageBus,
       clusterId: this.cluster.id,
       agentId: this.id,
-      lastDeliveredAt: this.lastGuidanceAppliedAt,
+      afterId: this.lastGuidanceAppliedId,
+      throughId: this.currentContextSequence,
     });
+    this.currentGuidanceSequence =
+      queuedGuidance.latestSequence ?? this.lastGuidanceAppliedId ?? null;
+    this.currentPromptIdentity = promptIdentity(selectedPrompt);
     const context = buildContext({
       id: this.id,
       role: this.role,
@@ -451,27 +479,35 @@ class AgentWrapper {
       lastTaskEndTime: this.lastTaskEndTime,
       lastAgentStartTime: previousAgentStart,
       triggeringMessage,
-      selectedPrompt: this._selectPrompt(),
+      selectedPrompt,
       queuedGuidance: queuedGuidance.guidanceBlock,
+      mode: contextMode,
+      continuationSequence: providerSession?.contextSequence,
+      contextThroughId: this.currentContextSequence,
+      previousPromptIdentity: providerSession?.promptIdentity,
+      currentPromptIdentity: this.currentPromptIdentity,
       // Pass isolation state for conditional git restriction
       worktree: this.worktree,
       isolation: this.isolation,
     });
 
     // Record when this iteration started so future "since: last_agent_start" filters work.
-    const latestMessage = this.messageBus.findLast({ cluster_id: this.cluster.id });
     const latestTimestamp = latestMessage?.timestamp;
     const now = Date.now();
     this.lastAgentStartTime =
       typeof latestTimestamp === 'number' ? Math.max(now, latestTimestamp + 1) : now;
 
-    if (queuedGuidance.latestTimestamp !== null) {
-      this.lastGuidanceAppliedAt = queuedGuidance.latestTimestamp;
-    }
-
     return context;
   }
 
+  _providerSupportsSessionResume(providerName) {
+    const override = this.providerCliFeatures?.[providerName];
+    if (override && Object.hasOwn(override, 'supportsResume')) {
+      return override.supportsResume === true;
+    }
+    return getProvider(providerName).getCliFeatures().supportsResume === true;
+  }
+
   /**
    * Spawn claude-zeroshots process and stream output via message bus
    * @private