@the-open-engine/zeroshot 6.9.1 → 6.10.1

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

@@ -101,6 +101,9 @@ export interface ClaudeCliFeatures extends BaseCliFeatures {
   readonly supportsVerbose: boolean;
   readonly supportsModel: boolean;
   readonly supportsEffort: boolean;
+  readonly supportsSettings: boolean;
+  readonly supportsMcpConfig: boolean;
+  readonly supportsResume: boolean;
 }
 
 export interface CodexCliFeatures extends BaseCliFeatures {
@@ -112,6 +115,7 @@ export interface CodexCliFeatures extends BaseCliFeatures {
   readonly supportsConfigOverride: boolean;
   readonly supportsModel: boolean;
   readonly supportsSkipGitRepoCheck: boolean;
+  readonly supportsResume: boolean;
 }
 
 export interface GeminiCliFeatures extends BaseCliFeatures {
@@ -193,6 +197,7 @@ export interface CliFeatureOverrides {
   readonly supportsVerbose?: boolean;
   readonly supportsModel?: boolean;
   readonly supportsEffort?: boolean;
+  readonly supportsSettings?: boolean;
   readonly supportsJson?: boolean;
   readonly supportsOutputSchema?: boolean;
   readonly supportsDir?: boolean;
@@ -212,6 +217,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;
@@ -228,10 +234,10 @@ export interface CliFeatureOverrides {
 }
 
 export interface CleanupMetadata {
-  readonly kind: 'temp-file';
+  readonly kind: 'temp-file' | 'temp-directory';
   readonly provider: ProviderId;
   readonly path: string;
-  readonly reason: 'output-schema';
+  readonly reason: 'output-schema' | 'settings-overlay';
 }
 
 export interface WarningMetadata {
@@ -265,14 +271,14 @@ export interface BuildProviderCommandOptions {
   readonly autoApprove?: boolean;
   readonly resumeSessionId?: string;
   readonly continueSession?: boolean;
+  readonly claudeSettingsFile?: string;
   readonly cliFeatures?: CliFeatureOverrides;
   readonly authEnv?: Readonly<Record<string, string>>;
   readonly strictSchema?: boolean;
   readonly gateway?: GatewayBuildOptions;
-  // MCP server configs forwarded to providers that accept an MCP config CLI flag (currently
-  // Copilot's `--additional-mcp-config`). Each entry is an inline JSON string (the standard
-  // `{"mcpServers": {...}}` envelope) or an `@<path>` file reference; adapters emit one flag per
-  // entry. Providers whose adapter models no MCP flag ignore this field.
+  // MCP server configs forwarded to providers that accept an MCP config CLI flag. Claude accepts
+  // one variadic `--mcp-config` followed by file paths; adapters such as Copilot accept repeated
+  // flags with inline JSON so configs survive container path translation.
   readonly mcpConfig?: readonly string[];
 }
 
@@ -368,6 +374,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

package/src/claude-task-runner.js

@@ -12,7 +12,23 @@ const { loadSettings } = require('../lib/settings');
 const { normalizeProviderName } = require('../lib/provider-names');
 const { getProvider } = require('./providers');
 const { prependWorktreeToolBinToEnv } = require('./worktree-tooling-env');
-const { prepareClaudeConfigDir } = require('./worktree-claude-config');
+const { getTask, getTaskBySpawnOwnershipToken } = require('../task-lib/store.js');
+const {
+  TASK_SPAWN_OWNERSHIP_TOKEN_ENV,
+  cleanupCallerOwnedCommand,
+  callerOwnsCommandCleanup,
+  createTaskSpawnOwnershipToken,
+  requireTaskIdFromWrapperResult,
+  trackTaskWrapperCleanupOwnership,
+} = require('./task-spawn-cleanup-ownership');
+const {
+  CLAUDE_MCP_CONFIG_ENV,
+  CLAUDE_SETTINGS_ENV,
+  cleanupClaudeSettingsOverlay,
+  prepareClaudeSettingsOverlay,
+  resolveContainerMcpConfigPath,
+  resolveRepoMcpConfigPath,
+} = require('./worktree-claude-config');
 const {
   appendTaskRunModelArgs,
   wrapTaskRunWithIsolatedSettings,
@@ -80,6 +96,28 @@ function runCommand(command, args, options = {}, callback = null) {
   });
 }
 
+const TASK_TERMINAL_STATUSES = new Set(['completed', 'failed', 'killed', 'stale', 'cancelled']);
+
+async function cleanupPersistedTaskAfterLaunchFailure(ctPath, taskId) {
+  let lastError = null;
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    let commandError = null;
+    try {
+      await runCommand(ctPath, ['kill', taskId], { timeout: 10000 });
+    } catch (error) {
+      commandError = error;
+    }
+    const task = getTask(taskId);
+    if (!task || (TASK_TERMINAL_STATUSES.has(task.status) && !task.commandCleanup)) {
+      return;
+    }
+    lastError =
+      commandError ||
+      new Error(`Task ${taskId} termination and command cleanup were not confirmed`);
+  }
+  throw lastError || new Error(`Task ${taskId} cleanup failed`);
+}
+
 function runCommandSync(command, args, options = {}) {
   const timeout = options.timeout ?? 30000;
   const result = spawnSync(command, args, { ...options, timeout });
@@ -95,6 +133,17 @@ function runCommandSync(command, args, options = {}) {
   return result.stdout?.toString() || '';
 }
 
+function appendIsolatedMcpConfigArgs(command, provider, options) {
+  if (provider !== 'claude') return;
+  const mcpConfigPath = resolveContainerMcpConfigPath({
+    cwd: options.cwd || process.cwd(),
+    worktreePath: options.worktreePath || null,
+  });
+  if (mcpConfigPath) {
+    command.push('--mcp-config', mcpConfigPath);
+  }
+}
+
 class ClaudeTaskRunner extends TaskRunner {
   /**
    * @param {Object} options
@@ -191,14 +240,20 @@ class ClaudeTaskRunner extends TaskRunner {
       worktreePath,
     });
 
-    const taskId = await this._spawnAndGetTaskId(ctPath, args, cwd, spawnEnv, agentId);
+    let taskId;
+    try {
+      taskId = await this._spawnAndGetTaskId(ctPath, args, cwd, spawnEnv, agentId);
+    } catch (error) {
+      cleanupCallerOwnedCommand(error, () =>
+        cleanupClaudeSettingsOverlay(spawnEnv[CLAUDE_SETTINGS_ENV])
+      );
+      throw error;
+    }
 
+    // Once a task ID is returned, the detached watcher owns provider
+    // termination and command cleanup.
     this._log(`📋 [${agentId}]: Following zeroshot logs for ${taskId}`);
-
-    // Wait for task registration
     await this._waitForTaskReady(ctPath, taskId);
-
-    // Follow logs until completion
     return this._followLogs(ctPath, taskId, agentId);
   }
 
@@ -325,9 +380,12 @@ class ClaudeTaskRunner extends TaskRunner {
       spawnEnv.ANTHROPIC_MODEL = resolvedModelSpec.model;
     }
     if (providerName === 'claude') {
-      const claudeConfigDir = prepareClaudeConfigDir({ cwd, worktreePath });
-      if (claudeConfigDir) {
-        spawnEnv.CLAUDE_CONFIG_DIR = claudeConfigDir;
+      spawnEnv[CLAUDE_SETTINGS_ENV] = prepareClaudeSettingsOverlay({
+        includeDangerousGit: Boolean(worktreePath),
+      });
+      const mcpConfigPath = resolveRepoMcpConfigPath({ cwd, worktreePath });
+      if (mcpConfigPath) {
+        spawnEnv[CLAUDE_MCP_CONFIG_ENV] = mcpConfigPath;
       }
     }
 
@@ -345,16 +403,49 @@ class ClaudeTaskRunner extends TaskRunner {
    * @returns {Promise<string>}
    */
   _spawnAndGetTaskId(ctPath, args, cwd, spawnEnv, _agentId) {
+    const ownershipToken = createTaskSpawnOwnershipToken();
+    const findPersistedTaskId = () => getTaskBySpawnOwnershipToken(ownershipToken)?.id || null;
     return new Promise((resolve, reject) => {
       const proc = spawn(ctPath, args, {
         cwd,
         stdio: ['ignore', 'pipe', 'pipe'],
-        env: spawnEnv,
+        env: { ...spawnEnv, [TASK_SPAWN_OWNERSHIP_TOKEN_ENV]: ownershipToken },
         windowsHide: true,
       });
 
       let stdout = '';
       let stderr = '';
+      let settled = false;
+      const classifyCleanupOwnership = trackTaskWrapperCleanupOwnership(findPersistedTaskId);
+      const rejectWithOwnership = async (error) => {
+        if (settled) return;
+        settled = true;
+        const classifiedError = classifyCleanupOwnership(error);
+        if (!callerOwnsCommandCleanup(classifiedError)) {
+          classifiedError.spawnOwnershipToken = ownershipToken;
+          let persistedTaskId = null;
+          let lookupError = null;
+          try {
+            persistedTaskId = findPersistedTaskId();
+          } catch (lookupFailure) {
+            lookupError = lookupFailure;
+          }
+          classifiedError.taskId = persistedTaskId;
+          try {
+            if (lookupError) throw lookupError;
+            if (persistedTaskId) {
+              await cleanupPersistedTaskAfterLaunchFailure(ctPath, persistedTaskId);
+            }
+          } catch (cleanupError) {
+            classifiedError.message += ` Task cleanup was not confirmed: ${cleanupError.message}`;
+            classifiedError.permanent = true;
+            classifiedError.restartExhausted = true;
+            classifiedError.terminationExhausted = true;
+            classifiedError.terminationAttempts = persistedTaskId ? 3 : 1;
+          }
+        }
+        reject(classifiedError);
+      };
 
       proc.stdout.on('data', (data) => {
         stdout += data.toString();
@@ -364,21 +455,26 @@ class ClaudeTaskRunner extends TaskRunner {
         stderr += data.toString();
       });
 
-      proc.on('close', (code) => {
-        if (code === 0) {
-          const match = stdout.match(/Task spawned: ((?:task-)?[a-z]+-[a-z]+-[a-z0-9]+)/);
-          if (match) {
-            resolve(match[1]);
-          } else {
-            reject(new Error(`Could not parse task ID from output: ${stdout}`));
-          }
-        } else {
-          reject(new Error(`zeroshot task run failed with code ${code}: ${stderr}`));
+      proc.on('close', async (code) => {
+        if (settled) return;
+        try {
+          const taskId = requireTaskIdFromWrapperResult({
+            code,
+            stdout,
+            stderr,
+            parseTaskId: (output) =>
+              output.match(/Task spawned: ((?:task-)?[a-z]+-[a-z]+-[a-z0-9]+)/)?.[1],
+            persistedTaskId: findPersistedTaskId(),
+          });
+          settled = true;
+          resolve(taskId);
+        } catch (error) {
+          await rejectWithOwnership(error);
         }
       });
 
-      proc.on('error', (error) => {
-        reject(error);
+      proc.on('error', async (error) => {
+        await rejectWithOwnership(error);
       });
     });
   }
@@ -424,6 +520,7 @@ class ClaudeTaskRunner extends TaskRunner {
       let statusCheckInterval = null;
       let resolved = false;
       let lineBuffer = '';
+      let cleanupRecoveryPending = false;
 
       // Get log file path
       try {
@@ -558,33 +655,43 @@ class ClaudeTaskRunner extends TaskRunner {
 
       statusCheckInterval = setInterval(() => {
         runCommand(ctPath, ['status', taskId], {}, (error, stdout) => {
-          if (resolved) return;
-
-          if (
-            !error &&
-            (stdout.includes('Status:     completed') || stdout.includes('Status:     failed'))
-          ) {
-            const success = stdout.includes('Status:     completed');
+          if (resolved || error) return;
+          const terminalMatch = stdout.match(/Status:\s+(completed|failed)/i);
+          if (!terminalMatch) return;
+          if (/Cleanup:\s+pending/i.test(stdout)) {
+            if (!cleanupRecoveryPending) {
+              cleanupRecoveryPending = true;
+              runCommand(ctPath, ['kill', taskId], { timeout: 10000 }, (cleanupError) => {
+                cleanupRecoveryPending = false;
+                if (cleanupError) {
+                  this._log(
+                    `⚠️ [${agentId}]: Terminal cleanup recovery will retry: ${cleanupError.message}`
+                  );
+                }
+              });
+            }
+            return;
+          }
 
-            pollLogFile();
+          const success = terminalMatch[1].toLowerCase() === 'completed';
+          pollLogFile();
 
-            setTimeout(() => {
-              if (resolved) return;
-              resolved = true;
+          setTimeout(() => {
+            if (resolved) return;
+            resolved = true;
 
-              if (pollInterval) clearInterval(pollInterval);
-              if (statusCheckInterval) clearInterval(statusCheckInterval);
+            clearInterval(pollInterval);
+            clearInterval(statusCheckInterval);
 
-              const errorContext = extractErrorContext(success, stdout);
+            const errorContext = extractErrorContext(success, stdout);
 
-              resolve({
-                success,
-                output,
-                error: errorContext,
-                taskId,
-              });
-            }, 500);
-          }
+            resolve({
+              success,
+              output,
+              error: errorContext,
+              taskId,
+            });
+          }, 500);
         });
       }, 1000);
 
@@ -664,6 +771,8 @@ class ClaudeTaskRunner extends TaskRunner {
       command.push('--json-schema', JSON.stringify(jsonSchema));
     }
 
+    appendIsolatedMcpConfigArgs(command, provider, options);
+
     let finalContext = context;
     if (jsonSchema && desiredOutputFormat === 'json' && runOutputFormat === 'stream-json') {
       finalContext += `\n\n## Output Format (REQUIRED)\n\nReturn a JSON object that matches this schema exactly.\n\nSchema:\n\`\`\`json\n${JSON.stringify(

package/src/ledger-sequence.js

@@ -0,0 +1,63 @@
+const MAX_SQLITE_ROWID = 9223372036854775807n;
+const CANONICAL_SEQUENCE = /^(0|[1-9][0-9]*)$/;
+
+function canonicalMessageSequence(value, name = 'message sequence') {
+  let sequence;
+  if (typeof value === 'string' && CANONICAL_SEQUENCE.test(value)) {
+    sequence = value;
+  } else if (Number.isSafeInteger(value) && value >= 0) {
+    // Accept legacy JSON state while normalizing every new boundary to a
+    // JSON-safe decimal string.
+    sequence = String(value);
+  } else {
+    throw new TypeError(`${name} must be a canonical non-negative decimal string`);
+  }
+
+  if (BigInt(sequence) > MAX_SQLITE_ROWID) {
+    throw new RangeError(`${name} exceeds the SQLite rowid range`);
+  }
+  return sequence;
+}
+
+function messageSequenceFromSql(value, name = 'message sequence') {
+  if (typeof value === 'bigint') {
+    if (value < 0n || value > MAX_SQLITE_ROWID) {
+      throw new RangeError(`${name} is outside the SQLite rowid range`);
+    }
+    return value.toString();
+  }
+  return canonicalMessageSequence(value, name);
+}
+
+function messageSequenceToSql(value, name = 'message sequence') {
+  return BigInt(canonicalMessageSequence(value, name));
+}
+
+function compareMessageSequences(left, right) {
+  const leftValue = messageSequenceToSql(left, 'left message sequence');
+  const rightValue = messageSequenceToSql(right, 'right message sequence');
+  if (leftValue < rightValue) {
+    return -1;
+  }
+  if (leftValue > rightValue) {
+    return 1;
+  }
+  return 0;
+}
+
+function tryCanonicalMessageSequence(value) {
+  try {
+    return canonicalMessageSequence(value);
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  MAX_SQLITE_ROWID,
+  canonicalMessageSequence,
+  compareMessageSequences,
+  messageSequenceFromSql,
+  messageSequenceToSql,
+  tryCanonicalMessageSequence,
+};