@the-open-engine/zeroshot 6.10.0 → 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/status.js

@@ -41,6 +41,7 @@ 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}`);
   }

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 };
 }
 
-export 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 ? '...' : ''),
@@ -186,6 +233,15 @@ export function buildTaskRecord({ id, prompt, cwd, options, logFile, providerNam
     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,
   };
 }
 
@@ -244,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];

package/task-lib/store.js

@@ -56,7 +56,10 @@ function getDb() {
       socket_path TEXT,
       attachable INTEGER DEFAULT 0,
       process_group_id INTEGER,
-      termination_strategy TEXT
+      termination_strategy TEXT,
+      command_cleanup TEXT,
+      cancel_requested INTEGER DEFAULT 0,
+      spawn_ownership_token TEXT
     );
 
     CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
@@ -93,12 +96,34 @@ function ensureTaskColumn(database, name, definition) {
   }
 }
 
+function parseCommandCleanup(value) {
+  if (typeof value !== 'string' || value === '') return null;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function serializeCommandCleanup(value) {
+  return value ? JSON.stringify(value) : null;
+}
+
 export function migrateTaskStore(database) {
   ensureTaskColumn(database, 'process_group_id', 'INTEGER');
   ensureTaskColumn(database, 'termination_strategy', 'TEXT');
+  ensureTaskColumn(database, 'command_cleanup', 'TEXT');
+  ensureTaskColumn(database, 'cancel_requested', 'INTEGER DEFAULT 0');
+  ensureTaskColumn(database, 'spawn_ownership_token', 'TEXT');
   ensureTaskColumn(database, 'requested_resume_session_id', 'TEXT');
   ensureTaskColumn(database, 'session_id_conflict', 'INTEGER NOT NULL DEFAULT 0');
   ensureTaskColumn(database, 'resume_identity_verified', 'INTEGER NOT NULL DEFAULT 0');
+  database.exec(`
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_spawn_ownership_token
+      ON tasks(spawn_ownership_token)
+      WHERE spawn_ownership_token IS NOT NULL
+  `);
 
   const version = database.pragma('user_version', { simple: true });
   if (version >= TASK_STORE_SCHEMA_VERSION) return;
@@ -164,6 +189,9 @@ function rowToTask(row) {
     attachable: Boolean(row.attachable),
     processGroupId: row.process_group_id,
     terminationStrategy: row.termination_strategy,
+    commandCleanup: parseCommandCleanup(row.command_cleanup),
+    cancelRequested: Boolean(row.cancel_requested),
+    spawnOwnershipToken: row.spawn_ownership_token,
   };
 }
 
@@ -191,11 +219,13 @@ export function saveTasks(tasks) {
     INSERT OR REPLACE INTO tasks (
       id, prompt, full_prompt, cwd, status, pid, session_id, session_id_conflict, requested_resume_session_id, resume_identity_verified, log_file,
       created_at, updated_at, exit_code, error, provider, model,
-      schedule_id, socket_path, attachable, process_group_id, termination_strategy
+      schedule_id, socket_path, attachable, process_group_id, termination_strategy,
+      command_cleanup, cancel_requested, spawn_ownership_token
     ) VALUES (
       @id, @prompt, @fullPrompt, @cwd, @status, @pid, @sessionId, @sessionIdConflict, @requestedResumeSessionId, @resumeIdentityVerified, @logFile,
       @createdAt, @updatedAt, @exitCode, @error, @provider, @model,
-      @scheduleId, @socketPath, @attachable, @processGroupId, @terminationStrategy
+      @scheduleId, @socketPath, @attachable, @processGroupId, @terminationStrategy,
+      @commandCleanup, @cancelRequested, @spawnOwnershipToken
     )
   `);
 
@@ -227,6 +257,9 @@ export function saveTasks(tasks) {
         attachable: task.attachable ? 1 : 0,
         processGroupId: task.processGroupId || null,
         terminationStrategy: task.terminationStrategy || null,
+        commandCleanup: serializeCommandCleanup(task.commandCleanup),
+        cancelRequested: task.cancelRequested ? 1 : 0,
+        spawnOwnershipToken: task.spawnOwnershipToken || null,
       });
     }
   });
@@ -257,6 +290,24 @@ export function getTask(id) {
   return rowToTask(row);
 }
 
+export function getTaskBySpawnOwnershipToken(token) {
+  if (typeof token !== 'string' || token.length === 0) return null;
+  const row = getDb().prepare('SELECT * FROM tasks WHERE spawn_ownership_token = ?').get(token);
+  return rowToTask(row);
+}
+
+export function requestTaskCancellation(id) {
+  const now = new Date().toISOString();
+  getDb()
+    .prepare(
+      `UPDATE tasks
+       SET cancel_requested = 1, updated_at = ?, error = ?
+       WHERE id = ? AND status = 'running'`
+    )
+    .run(now, 'Cancellation requested before provider startup completed', id);
+  return getTask(id);
+}
+
 /**
  * Update a task
  * @param {string} id
@@ -296,7 +347,10 @@ export function updateTask(id, updates) {
       socket_path = @socketPath,
       attachable = @attachable,
       process_group_id = @processGroupId,
-      termination_strategy = @terminationStrategy
+      termination_strategy = @terminationStrategy,
+      command_cleanup = @commandCleanup,
+      cancel_requested =
+        CASE WHEN @hasCancelRequested = 1 THEN @cancelRequested ELSE cancel_requested END
     WHERE id = @id
   `
     )
@@ -322,6 +376,9 @@ export function updateTask(id, updates) {
       attachable: updated.attachable ? 1 : 0,
       processGroupId: updated.processGroupId || null,
       terminationStrategy: updated.terminationStrategy || null,
+      commandCleanup: serializeCommandCleanup(updated.commandCleanup),
+      hasCancelRequested: Object.prototype.hasOwnProperty.call(updates, 'cancelRequested') ? 1 : 0,
+      cancelRequested: updated.cancelRequested ? 1 : 0,
     });
 
   return updated;
@@ -346,11 +403,13 @@ export function addTask(task) {
     INSERT INTO tasks (
       id, prompt, full_prompt, cwd, status, pid, session_id, session_id_conflict, requested_resume_session_id, resume_identity_verified, log_file,
       created_at, updated_at, exit_code, error, provider, model,
-      schedule_id, socket_path, attachable, process_group_id, termination_strategy
+      schedule_id, socket_path, attachable, process_group_id, termination_strategy,
+      command_cleanup, cancel_requested, spawn_ownership_token
     ) VALUES (
       @id, @prompt, @fullPrompt, @cwd, @status, @pid, @sessionId, @sessionIdConflict, @requestedResumeSessionId, @resumeIdentityVerified, @logFile,
       @createdAt, @updatedAt, @exitCode, @error, @provider, @model,
-      @scheduleId, @socketPath, @attachable, @processGroupId, @terminationStrategy
+      @scheduleId, @socketPath, @attachable, @processGroupId, @terminationStrategy,
+      @commandCleanup, @cancelRequested, @spawnOwnershipToken
     )
   `
     )
@@ -377,6 +436,9 @@ export function addTask(task) {
       attachable: fullTask.attachable ? 1 : 0,
       processGroupId: fullTask.processGroupId || null,
       terminationStrategy: fullTask.terminationStrategy || null,
+      commandCleanup: serializeCommandCleanup(fullTask.commandCleanup),
+      cancelRequested: fullTask.cancelRequested ? 1 : 0,
+      spawnOwnershipToken: fullTask.spawnOwnershipToken || null,
     });
 
   return fullTask;