@the-open-engine/zeroshot 6.9.1 → 6.10.1

package/task-lib/commands/clean.js

@@ -1,6 +1,7 @@
 import { unlinkSync, existsSync } from 'fs';
 import chalk from 'chalk';
 import { loadTasks, saveTasks } from '../store.js';
+import { createCommandSpecCleanup } from '../command-spec-cleanup.js';
 
 export function cleanTasks(options = {}) {
   const tasks = loadTasks();
@@ -11,6 +12,8 @@ export function cleanTasks(options = {}) {
     return;
   }
 
+  let cleanupFailed = false;
+  let removedCount = 0;
   const toRemove = [];
 
   for (const task of taskList) {
@@ -33,18 +36,45 @@ export function cleanTasks(options = {}) {
   console.log(chalk.dim(`Removing ${toRemove.length} task(s)...\n`));
 
   for (const task of toRemove) {
-    // Delete log file
+    if (task.commandCleanup) {
+      if (task.status === 'running') {
+        cleanupFailed = true;
+        console.log(
+          chalk.yellow(`  Retained: ${task.id} [running] (live command cleanup ownership)`)
+        );
+        continue;
+      }
+      let recovered = false;
+      try {
+        const cleanup = createCommandSpecCleanup(task.commandCleanup, (cleanupPath, error) => {
+          console.log(chalk.yellow(`Warning: failed to clean up ${cleanupPath}: ${error.message}`));
+        });
+        recovered = cleanup.runSync();
+      } catch (error) {
+        console.log(
+          chalk.yellow(`Warning: failed to validate cleanup for task ${task.id}: ${error.message}`)
+        );
+      }
+      if (!recovered) {
+        cleanupFailed = true;
+        console.log(
+          chalk.yellow(`  Retained: ${task.id} [${task.status}] (command cleanup pending)`)
+        );
+        continue;
+      }
+      task.commandCleanup = null;
+    }
     if (task.logFile && existsSync(task.logFile)) {
       unlinkSync(task.logFile);
     }
 
-    // Remove from tasks
-    delete tasks[task.id];
-
     console.log(chalk.dim(`  Removed: ${task.id} [${task.status}]`));
+    delete tasks[task.id];
+    removedCount++;
   }
 
   saveTasks(tasks);
 
-  console.log(chalk.green(`\n✓ Cleaned ${toRemove.length} task(s)`));
+  console.log(chalk.green(`\n✓ Cleaned ${removedCount} task(s)`));
+  if (cleanupFailed) process.exitCode = 1;
 }

package/task-lib/commands/get-task-id-by-spawn-token.js

@@ -0,0 +1,10 @@
+import { getTaskBySpawnOwnershipToken } from '../store.js';
+
+export function getTaskIdBySpawnToken(token) {
+  const task = getTaskBySpawnOwnershipToken(token);
+  if (!task) {
+    process.exitCode = 2;
+    return;
+  }
+  process.stdout.write(`${task.id}\n`);
+}

package/task-lib/commands/kill.js

@@ -1,6 +1,75 @@
 import chalk from 'chalk';
-import { getTask, updateTask } from '../store.js';
-import { terminateProcess } from '../runner.js';
+import { getTask, requestTaskCancellation, updateTask } from '../store.js';
+import { createCommandSpecCleanup } from '../command-spec-cleanup.js';
+import { terminateProcess } from '../process-termination.js';
+
+async function cleanupTerminatedTask(task) {
+  if (!task.commandCleanup) return {};
+  try {
+    const cleanup = createCommandSpecCleanup(task.commandCleanup, (cleanupPath, error) => {
+      console.log(chalk.yellow(`Warning: failed to clean up ${cleanupPath}: ${error.message}`));
+    });
+    return (await cleanup.run()) ? { commandCleanup: null } : {};
+  } catch (error) {
+    console.log(
+      chalk.yellow(`Warning: failed to validate persisted command cleanup: ${error.message}`)
+    );
+    return {};
+  }
+}
+
+async function retryTerminalTaskCleanup(taskId, task) {
+  if (!task.commandCleanup) return true;
+  const cleanupUpdate = await cleanupTerminatedTask(task);
+  if (cleanupUpdate.commandCleanup === null) {
+    updateTask(taskId, cleanupUpdate);
+    console.log(chalk.green(`✓ Recovered pending command cleanup for task ${taskId}`));
+    return true;
+  }
+  console.log(chalk.yellow(`Warning: command cleanup remains pending for task ${taskId}`));
+  process.exitCode = 1;
+  return false;
+}
+
+const TERMINAL_STATUSES = new Set(['completed', 'failed', 'killed', 'stale']);
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForStartupCancellation(taskId, options) {
+  const timeoutMs = options.startupCancelTimeoutMs ?? 8000;
+  const pollMs = options.startupCancelPollMs ?? options.pollMs ?? 25;
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() <= deadline) {
+    const current = getTask(taskId);
+    if (!current) break;
+    if (TERMINAL_STATUSES.has(current.status)) {
+      await retryTerminalTaskCleanup(taskId, current);
+      if (!getTask(taskId)?.commandCleanup) {
+        console.log(chalk.green(`✓ Cancelled task ${taskId} before provider startup completed`));
+        return true;
+      }
+    }
+    if (Number.isInteger(current.pid) && current.pid > 0) {
+      await killTaskCommand(taskId, options);
+      const terminal = getTask(taskId);
+      return Boolean(
+        terminal && TERMINAL_STATUSES.has(terminal.status) && !terminal.commandCleanup
+      );
+    }
+    await sleep(pollMs);
+  }
+
+  console.log(
+    chalk.yellow(
+      `Cancellation for task ${taskId} remains pending; provider termination and cleanup were not confirmed`
+    )
+  );
+  process.exitCode = 1;
+  return false;
+}
 
 export async function killTaskCommand(taskId, options = {}) {
   const task = getTask(taskId);
@@ -11,30 +80,68 @@ export async function killTaskCommand(taskId, options = {}) {
   }
 
   if (task.status !== 'running') {
+    await retryTerminalTaskCleanup(taskId, task);
     console.log(chalk.yellow(`Task is not running (status: ${task.status})`));
     return;
   }
 
+  if (!Number.isInteger(task.pid) || task.pid <= 0) {
+    requestTaskCancellation(taskId);
+    console.log(
+      chalk.yellow(
+        `Task ${taskId} has not published a provider PID; persisted cancellation is pending`
+      )
+    );
+    await waitForStartupCancellation(taskId, options);
+    return;
+  }
+
+  const platform = options.platform || process.platform;
+  const terminate = options.terminateProcessFn || terminateProcess;
+  const processOptions = { ...options };
+  delete processOptions.platform;
+  delete processOptions.terminateProcessFn;
+
   const terminationOptions = {
-    ...options,
+    ...processOptions,
     processGroupId: task.processGroupId,
     terminationStrategy: task.terminationStrategy || 'process',
   };
 
-  const result = await terminateProcess(task.pid, terminationOptions);
+  const result = await terminate(task.pid, terminationOptions);
 
   if (result.terminated && result.alreadyDead) {
+    if (platform === 'win32' && task.terminationStrategy === 'process-tree') {
+      console.log(
+        chalk.yellow(
+          `Warning: Windows task root ${task.pid} is gone but descendant termination is unverified; preserving cleanup ownership`
+        )
+      );
+      updateTask(taskId, {
+        error: 'Windows process-tree termination could not be confirmed after root exit',
+      });
+      process.exitCode = 1;
+      return;
+    }
     console.log(chalk.yellow('Process already dead, updating status...'));
+    const cleanupUpdate = await cleanupTerminatedTask(task);
     updateTask(taskId, {
       status: 'stale',
       pid: null,
       processGroupId: null,
       error: 'Process died unexpectedly',
+      cancelRequested: false,
+      ...cleanupUpdate,
     });
+    if (getTask(taskId)?.commandCleanup) {
+      console.log(chalk.yellow(`Warning: command cleanup remains pending for task ${taskId}`));
+      process.exitCode = 1;
+    }
     return;
   }
 
   if (result.terminated) {
+    const cleanupUpdate = await cleanupTerminatedTask(task);
     const suffix = result.escalated ? ' after SIGKILL escalation' : ' with SIGTERM';
     console.log(chalk.green(`✓ Killed task ${taskId} (PID: ${task.pid})${suffix}`));
     if (result.degraded) {
@@ -46,7 +153,13 @@ export async function killTaskCommand(taskId, options = {}) {
       processGroupId: null,
       exitCode: result.escalated ? 137 : 143,
       error: result.escalated ? 'Killed by user after SIGKILL escalation' : 'Killed by user',
+      cancelRequested: false,
+      ...cleanupUpdate,
     });
+    if (getTask(taskId)?.commandCleanup) {
+      console.log(chalk.yellow(`Warning: command cleanup remains pending for task ${taskId}`));
+      process.exitCode = 1;
+    }
   } else {
     console.log(chalk.red(`Failed to kill task ${taskId}`));
     updateTask(taskId, {

package/task-lib/commands/resume.js

@@ -1,7 +1,35 @@
 import chalk from 'chalk';
+import { createRequire } from 'module';
 import { getTask } from '../store.js';
 import { spawnTask } from '../runner.js';
 
+const require = createRequire(import.meta.url);
+const { providerSupportsCapability } = require('../../lib/provider-names.js');
+
+export function buildResumeTaskOptions(task) {
+  if (!providerSupportsCapability(task.provider, 'sessionResume')) {
+    throw new Error(`Provider ${task.provider} does not support safe session resume.`);
+  }
+  if (
+    task.requestedResumeSessionId &&
+    (task.status !== 'completed' || task.resumeIdentityVerified !== true)
+  ) {
+    throw new Error(
+      `Task ${task.id} did not durably verify its requested provider session; refusing resume.`
+    );
+  }
+  if (!task.sessionId) {
+    throw new Error(
+      `Task ${task.id} has no captured provider session ID; refusing cwd-wide continuation.`
+    );
+  }
+  return {
+    cwd: task.cwd,
+    resume: task.sessionId,
+    provider: task.provider,
+  };
+}
+
 export async function resumeTask(taskId, newPrompt) {
   const task = getTask(taskId);
 
@@ -23,12 +51,7 @@ export async function resumeTask(taskId, newPrompt) {
   console.log(chalk.dim(`Original prompt: ${task.prompt}`));
   console.log(chalk.dim(`Resume prompt: ${prompt}`));
 
-  const newTask = await spawnTask(prompt, {
-    cwd: task.cwd,
-    continue: true, // Use --continue to load most recent session in that directory
-    sessionId: task.sessionId,
-    provider: task.provider,
-  });
+  const newTask = await spawnTask(prompt, buildResumeTaskOptions(task));
 
   console.log(chalk.green(`\n✓ Resumed as new task: ${chalk.cyan(newTask.id)}`));
   console.log(chalk.dim(`  PID: ${newTask.pid}`));

package/task-lib/commands/status.js

@@ -41,6 +41,10 @@ export function showStatus(taskId) {
   console.log(`${chalk.dim('PID:')}        ${task.pid || 'N/A'}`);
   console.log(`${chalk.dim('Exit Code:')}  ${task.exitCode ?? 'N/A'}`);
   console.log(`${chalk.dim('Session:')}    ${task.sessionId || 'N/A'}`);
+  console.log(`${chalk.dim('Cleanup:')}    ${task.commandCleanup ? 'pending' : 'complete'}`);
+  if (task.requestedResumeSessionId) {
+    console.log(`${chalk.dim('Requested:')}  ${task.requestedResumeSessionId}`);
+  }
   console.log(`${chalk.dim('Log File:')}   ${task.logFile}`);
 
   console.log(`\n${chalk.dim('Prompt:')}`);

package/task-lib/provider-helper-runtime.js

@@ -19,6 +19,7 @@ export const {
   classifyProviderError,
   detectProviderFatalError,
   detectProviderStreamingModeError,
+  extractProviderSessionId,
   findProviderRegistryEntry,
   getProviderAdapter,
   getProviderRegistryEntry,

package/task-lib/provider-session-capture.js

@@ -0,0 +1,138 @@
+import { extractProviderSessionId } from './provider-helper-runtime.js';
+
+/**
+ * Capture a provider-owned session ID from one complete output line.
+ *
+ * The caller owns persistence so watcher variants can share parsing without
+ * importing each other's process lifecycle. Repeated IDs are idempotent; any
+ * differing ID makes the capture permanently ambiguous.
+ */
+export function captureProviderSessionLine({
+  providerName,
+  line,
+  currentSessionId = null,
+  observedSessionIds = new Set(currentSessionId ? [currentSessionId] : []),
+  sessionIdConflict = false,
+  onCapture = () => {},
+  onConflict = () => {},
+}) {
+  const sessionId = extractProviderSessionId(providerName, line);
+  if (!sessionId) {
+    return { currentSessionId, sessionIdConflict };
+  }
+
+  observedSessionIds.add(sessionId);
+  if (sessionIdConflict || observedSessionIds.size > 1) {
+    if (!sessionIdConflict) {
+      onConflict([...observedSessionIds]);
+    }
+    return { currentSessionId: null, sessionIdConflict: true };
+  }
+
+  if (sessionId === currentSessionId) {
+    return { currentSessionId, sessionIdConflict: false };
+  }
+  onCapture(sessionId);
+  return { currentSessionId: sessionId, sessionIdConflict: false };
+}
+
+function providerSessionCompletionError({
+  requestedSessionId,
+  currentSessionId,
+  sessionIdConflict,
+  persistenceError,
+}) {
+  if (persistenceError) {
+    return `Provider session identity could not be persisted: ${persistenceError.message}`;
+  }
+
+  const requested = requestedSessionId?.trim() || null;
+  if (!requested) {
+    return null;
+  }
+  if (sessionIdConflict) {
+    return 'Provider continuation emitted conflicting session identities';
+  }
+
+  const captured = currentSessionId?.trim() || null;
+  if (captured === requested) {
+    return null;
+  }
+  return captured
+    ? 'Provider continuation returned a different session identity'
+    : 'Provider continuation did not confirm the requested session identity';
+}
+
+export function createProviderSessionCapture({
+  providerName,
+  taskId,
+  updateTask,
+  log,
+  requestedSessionId = null,
+  initialSessionId = null,
+  initialSessionIdConflict = false,
+}) {
+  let currentSessionId = initialSessionId;
+  let sessionIdConflict = initialSessionIdConflict;
+  let persistenceError = null;
+  const observedSessionIds = new Set(initialSessionId ? [initialSessionId] : []);
+
+  function persist(update) {
+    try {
+      updateTask(taskId, update);
+    } catch (error) {
+      persistenceError ||= error;
+      throw error;
+    }
+  }
+
+  function captureLine(line) {
+    try {
+      ({ currentSessionId, sessionIdConflict } = captureProviderSessionLine({
+        providerName,
+        line,
+        currentSessionId,
+        observedSessionIds,
+        sessionIdConflict,
+        onCapture: (sessionId) => {
+          // Advance memory before persistence so a failed write can never leave
+          // this watcher believing the earlier identity is still trustworthy.
+          currentSessionId = sessionId;
+          persist({ sessionId });
+        },
+        onConflict: () => {
+          currentSessionId = null;
+          sessionIdConflict = true;
+          persist({
+            sessionId: null,
+            sessionIdConflict: true,
+            resumeIdentityVerified: false,
+          });
+        },
+      }));
+    } catch (error) {
+      log(`[${Date.now()}][SESSION] Failed to persist provider session: ${error.message}\n`);
+    }
+  }
+
+  function getCompletionError() {
+    return providerSessionCompletionError({
+      requestedSessionId,
+      currentSessionId,
+      sessionIdConflict,
+      persistenceError,
+    });
+  }
+
+  return {
+    captureLine,
+    getCompletionError,
+    getCompletionUpdate: (resolvedCode) => {
+      const error = getCompletionError();
+      return {
+        resumeIdentityVerified: resolvedCode === 0 && !error,
+        ...(error ? { sessionId: null, sessionIdConflict: true } : {}),
+      };
+    },
+  };
+}

package/task-lib/runner.js

@@ -12,6 +12,12 @@ const {
   ISOLATED_SETTINGS_FILE_MARKER,
   LEGACY_ISOLATED_PROVIDER_SETTINGS_ENV,
 } = require('../src/task-run-model-args.js');
+const {
+  CLAUDE_MCP_CONFIG_ENV,
+  CLAUDE_SETTINGS_ENV,
+  isClaudeSettingsOverlayPath,
+} = require('../src/worktree-claude-config');
+const { TASK_SPAWN_OWNERSHIP_TOKEN_ENV } = require('../src/task-spawn-cleanup-ownership');
 export {
   isOwnedProcessTreeRunning,
   isProcessRunning,
@@ -37,7 +43,7 @@ export function spawnTask(prompt, options = {}) {
   });
   const providerName = prepared.adapter.id;
   const modelSpec = prepared.options.modelSpec;
-  const commandSpec = prepared.commandSpec;
+  const commandSpec = attachClaudeOverlayCleanup(prepared.commandSpec, providerName);
 
   const task = buildTaskRecord({
     id,
@@ -47,6 +53,7 @@ export function spawnTask(prompt, options = {}) {
     logFile,
     providerName,
     modelSpec,
+    commandSpec,
   });
 
   addTask(task);
@@ -116,14 +123,24 @@ function buildProviderOptions(options, runtime, modelSelection) {
     autoApprove: true,
     ...(modelSelection === undefined ? {} : { modelSpec: modelSelection.modelSpec }),
     ...mcpConfigOption(options),
+    ...claudeSettingsFileOption(),
     ...(options.resume ? { resumeSessionId: options.resume } : {}),
     ...(options.continue ? { continueSession: true } : {}),
   };
 }
 
+function claudeSettingsFileOption() {
+  const settingsPath = process.env[CLAUDE_SETTINGS_ENV]?.trim();
+  return settingsPath ? { claudeSettingsFile: settingsPath } : {};
+}
+
 function mcpConfigOption(options) {
-  const entries = options.mcpConfig;
-  if (!Array.isArray(entries) || entries.length === 0) return {};
+  const entries = Array.isArray(options.mcpConfig) ? [...options.mcpConfig] : [];
+  const claudeMcpConfigPath = process.env[CLAUDE_MCP_CONFIG_ENV]?.trim();
+  if (claudeMcpConfigPath && !entries.includes(claudeMcpConfigPath)) {
+    entries.push(claudeMcpConfigPath);
+  }
+  if (entries.length === 0) return {};
   return { mcpConfig: entries };
 }
 
@@ -155,7 +172,37 @@ function providerLevelSelection(options) {
   return { modelSpec };
 }
 
-function buildTaskRecord({ id, prompt, cwd, options, logFile, providerName, modelSpec }) {
+export function attachClaudeOverlayCleanup(commandSpec, providerName) {
+  if (providerName !== 'claude') return commandSpec;
+  const settingsPath = process.env[CLAUDE_SETTINGS_ENV]?.trim();
+  if (!isClaudeSettingsOverlayPath(settingsPath)) return commandSpec;
+
+  const overlayDir = dirname(settingsPath);
+  return {
+    ...commandSpec,
+    cleanup: [...(commandSpec.cleanup || []), overlayDir],
+    cleanupMetadata: [
+      ...(commandSpec.cleanupMetadata || []),
+      {
+        kind: 'temp-directory',
+        provider: 'claude',
+        path: overlayDir,
+        reason: 'settings-overlay',
+      },
+    ],
+  };
+}
+
+export function buildTaskRecord({
+  id,
+  prompt,
+  cwd,
+  options,
+  logFile,
+  providerName,
+  modelSpec,
+  commandSpec = {},
+}) {
   return {
     id,
     prompt: prompt.slice(0, 200) + (prompt.length > 200 ? '...' : ''),
@@ -163,7 +210,15 @@ function buildTaskRecord({ id, prompt, cwd, options, logFile, providerName, mode
     cwd,
     status: 'running',
     pid: null,
-    sessionId: options.resume || options.sessionId || null,
+    // Only watcher-observed provider output may populate sessionId. A requested
+    // resume ID is diagnostic input, not proof the resumed provider emitted or
+    // accepted that session identity.
+    sessionId: null,
+    sessionIdConflict: false,
+    requestedResumeSessionId: options.resume || null,
+    // Resumed tasks start fail-closed. Only the watcher terminal transaction
+    // may prove that the requested identity completed without conflict.
+    resumeIdentityVerified: !options.resume,
     logFile,
     createdAt: new Date().toISOString(),
     updatedAt: new Date().toISOString(),
@@ -178,6 +233,15 @@ function buildTaskRecord({ id, prompt, cwd, options, logFile, providerName, mode
     attachable: false,
     processGroupId: null,
     terminationStrategy: null,
+    cancelRequested: false,
+    spawnOwnershipToken: process.env[TASK_SPAWN_OWNERSHIP_TOKEN_ENV] || null,
+    commandCleanup:
+      commandSpec.cleanup?.length > 0
+        ? {
+            cleanup: commandSpec.cleanup,
+            cleanupMetadata: commandSpec.cleanupMetadata || [],
+          }
+        : null,
   };
 }
 
@@ -236,6 +300,7 @@ function spawnWatcher({ watcherScript, id, cwd, logFile, finalArgs, watcherConfi
 export function buildWatcherEnv(sourceEnv = process.env) {
   const watcherEnv = { ...sourceEnv };
   delete watcherEnv[LEGACY_ISOLATED_PROVIDER_SETTINGS_ENV];
+  delete watcherEnv[TASK_SPAWN_OWNERSHIP_TOKEN_ENV];
   if (watcherEnv[ISOLATED_SETTINGS_FILE_MARKER] === '1') {
     delete watcherEnv[ISOLATED_SETTINGS_FILE_ENV];
     delete watcherEnv[ISOLATED_SETTINGS_FILE_MARKER];