@the-open-engine/zeroshot 6.7.0 → 6.7.2

package/task-lib/commands/kill.js

@@ -1,8 +1,8 @@
 import chalk from 'chalk';
 import { getTask, updateTask } from '../store.js';
-import { killTask as killProcess, isProcessRunning } from '../runner.js';
+import { terminateProcess } from '../runner.js';
 
-export function killTaskCommand(taskId) {
+export async function killTaskCommand(taskId, options = {}) {
   const task = getTask(taskId);
 
   if (!task) {
@@ -15,18 +15,43 @@ export function killTaskCommand(taskId) {
     return;
   }
 
-  if (!isProcessRunning(task.pid)) {
+  const terminationOptions = {
+    ...options,
+    processGroupId: task.processGroupId,
+    terminationStrategy: task.terminationStrategy || 'process',
+  };
+
+  const result = await terminateProcess(task.pid, terminationOptions);
+
+  if (result.terminated && result.alreadyDead) {
     console.log(chalk.yellow('Process already dead, updating status...'));
-    updateTask(taskId, { status: 'stale', error: 'Process died unexpectedly' });
+    updateTask(taskId, {
+      status: 'stale',
+      pid: null,
+      processGroupId: null,
+      error: 'Process died unexpectedly',
+    });
     return;
   }
 
-  const killed = killProcess(task.pid);
-
-  if (killed) {
-    console.log(chalk.green(`✓ Sent SIGTERM to task ${taskId} (PID: ${task.pid})`));
-    updateTask(taskId, { status: 'killed', error: 'Killed by user' });
+  if (result.terminated) {
+    const suffix = result.escalated ? ' after SIGKILL escalation' : ' with SIGTERM';
+    console.log(chalk.green(`✓ Killed task ${taskId} (PID: ${task.pid})${suffix}`));
+    if (result.degraded) {
+      console.log(chalk.yellow(`Warning: ${result.degradedReason}`));
+    }
+    updateTask(taskId, {
+      status: 'killed',
+      pid: null,
+      processGroupId: null,
+      exitCode: result.escalated ? 137 : 143,
+      error: result.escalated ? 'Killed by user after SIGKILL escalation' : 'Killed by user',
+    });
   } else {
     console.log(chalk.red(`Failed to kill task ${taskId}`));
+    updateTask(taskId, {
+      error: result.error || 'Process termination failed',
+    });
+    process.exitCode = 1;
   }
 }

package/task-lib/commands/run.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { spawnTask } from '../runner.js';
+import { shouldUseAttachableWatcher, spawnTask } from '../runner.js';
 
 export async function runTask(prompt, options = {}) {
   if (!prompt || prompt.trim().length === 0) {
@@ -46,8 +46,23 @@ export async function runTask(prompt, options = {}) {
   console.log(chalk.dim(`  Log: ${task.logFile}`));
   console.log(chalk.dim(`  CWD: ${task.cwd}`));
 
+  const attachSupported = shouldUseAttachableWatcher(
+    {
+      jsonSchema: outputFormat === 'json' ? jsonSchema : null,
+    },
+    task.provider
+  );
+
   console.log(chalk.dim('\nCommands:'));
-  console.log(chalk.dim(`  zeroshot attach ${task.id}    # Attach to task (Ctrl+B d to detach)`));
+  if (attachSupported) {
+    console.log(chalk.dim(`  zeroshot attach ${task.id}    # Attach to task (Ctrl+B d to detach)`));
+  } else {
+    console.log(
+      chalk.dim(
+        `  Attach unavailable: ${task.provider} strict structured output uses a non-PTY watcher`
+      )
+    );
+  }
   console.log(chalk.dim(`  zeroshot logs ${task.id}      # View output`));
   console.log(chalk.dim(`  zeroshot logs -f ${task.id}   # Follow output`));
   console.log(chalk.dim(`  zeroshot status ${task.id}    # Check status`));

package/task-lib/commands/status.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { getTask } from '../store.js';
-import { isProcessRunning } from '../runner.js';
+import { isOwnedProcessTreeRunning } from '../runner.js';
 
 export function showStatus(taskId) {
   const task = getTask(taskId);
@@ -12,8 +12,18 @@ export function showStatus(taskId) {
 
   // Verify running status
   let status = task.status;
-  if (status === 'running' && !isProcessRunning(task.pid)) {
-    status = 'stale (process died)';
+  if (status === 'running') {
+    try {
+      const running = isOwnedProcessTreeRunning(task.pid, {
+        processGroupId: task.processGroupId,
+        terminationStrategy: task.terminationStrategy || 'process',
+      });
+      if (!running) {
+        status = 'stale (process died)';
+      }
+    } catch (error) {
+      status = `stale (invalid process ownership: ${error.message})`;
+    }
   }
 
   const statusColor =

package/task-lib/process-termination.js

@@ -0,0 +1,202 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+
+const execFileAsync = promisify(execFile);
+
+export function isProcessRunning(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function killTask(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 'SIGTERM');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function normalizeTerminationOwnership(pid, options) {
+  const terminationStrategy = options.terminationStrategy || 'process';
+  const processGroupId = Number(options.processGroupId) || null;
+
+  if (terminationStrategy === 'process-group') {
+    if (process.platform === 'win32') {
+      throw new Error(
+        'Process-group termination is unavailable on Windows; use terminationStrategy "process-tree"'
+      );
+    }
+    if (!processGroupId || processGroupId !== pid) {
+      throw new Error(
+        `Refusing process-group termination for PID ${pid}: owned processGroupId must equal the provider root PID`
+      );
+    }
+  }
+
+  if (terminationStrategy === 'process-tree' && process.platform !== 'win32') {
+    throw new Error(
+      `Process-tree termination is only supported on Windows; use terminationStrategy "process-group" on ${process.platform}`
+    );
+  }
+
+  if (!['process', 'process-group', 'process-tree'].includes(terminationStrategy)) {
+    throw new Error(`Unsupported termination strategy: ${terminationStrategy}`);
+  }
+
+  return { terminationStrategy, processGroupId };
+}
+
+function isProcessGroupRunning(processGroupId) {
+  try {
+    process.kill(-processGroupId, 0);
+    return true;
+  } catch (error) {
+    return error?.code === 'EPERM';
+  }
+}
+
+export function isOwnedProcessTreeRunning(pid, options = {}) {
+  if (!pid) return false;
+  const ownership = normalizeTerminationOwnership(pid, options);
+  if (ownership.terminationStrategy === 'process-group') {
+    return isProcessGroupRunning(ownership.processGroupId);
+  }
+  return isProcessRunning(pid);
+}
+
+async function signalWindowsProcessTree(pid, force) {
+  const args = ['/PID', String(pid), '/T'];
+  if (force) args.push('/F');
+  await execFileAsync('taskkill', args, { windowsHide: true });
+}
+
+async function signalOwnedProcessTree(pid, signal, ownership) {
+  if (ownership.terminationStrategy === 'process-group') {
+    process.kill(-ownership.processGroupId, signal);
+    return;
+  }
+  if (ownership.terminationStrategy === 'process-tree') {
+    await signalWindowsProcessTree(pid, signal === 'SIGKILL');
+    return;
+  }
+  process.kill(pid, signal);
+}
+
+async function waitForOwnedProcessTreeExit(pid, ownership, timeoutMs, pollMs) {
+  const deadline = Date.now() + timeoutMs;
+  const options = {
+    terminationStrategy: ownership.terminationStrategy,
+    processGroupId: ownership.processGroupId,
+  };
+  while (Date.now() < deadline) {
+    if (!isOwnedProcessTreeRunning(pid, options)) return true;
+    await sleep(pollMs);
+  }
+  return !isOwnedProcessTreeRunning(pid, options);
+}
+
+function terminationResult(ownership, overrides = {}) {
+  const degraded = ownership.terminationStrategy === 'process';
+  return {
+    terminated: false,
+    alreadyDead: false,
+    escalated: false,
+    signal: null,
+    scope: ownership.terminationStrategy,
+    degraded,
+    degradedReason: degraded
+      ? 'Task has no process-tree ownership metadata; only the provider root PID can be terminated'
+      : null,
+    ...overrides,
+  };
+}
+
+async function signalAndWait(pid, ownership, signal, timeoutMs, pollMs) {
+  const escalated = signal === 'SIGKILL';
+  try {
+    await signalOwnedProcessTree(pid, signal, ownership);
+  } catch (error) {
+    if (
+      !isOwnedProcessTreeRunning(pid, {
+        terminationStrategy: ownership.terminationStrategy,
+        processGroupId: ownership.processGroupId,
+      })
+    ) {
+      return terminationResult(ownership, {
+        terminated: true,
+        alreadyDead: signal === 'SIGTERM',
+        escalated,
+        signal: escalated ? signal : null,
+      });
+    }
+    return terminationResult(ownership, {
+      escalated,
+      signal,
+      error: error.message,
+    });
+  }
+
+  const terminated = await waitForOwnedProcessTreeExit(pid, ownership, timeoutMs, pollMs);
+  return terminationResult(ownership, {
+    terminated,
+    escalated,
+    signal,
+    error:
+      terminated || !escalated
+        ? null
+        : `Owned ${ownership.terminationStrategy} for PID ${pid} survived ${signal}`,
+  });
+}
+
+/**
+ * Terminate an owned provider process tree. Watchers create a dedicated process
+ * group on POSIX and persist that ownership boundary; Windows uses taskkill /T.
+ * Legacy tasks without ownership metadata fall back to root-only termination
+ * and report the degraded scope explicitly.
+ */
+export async function terminateProcess(pid, options = {}) {
+  let ownership;
+  try {
+    ownership = normalizeTerminationOwnership(pid, options);
+  } catch (error) {
+    return {
+      terminated: false,
+      alreadyDead: false,
+      escalated: false,
+      signal: null,
+      error: error.message,
+    };
+  }
+
+  if (!isOwnedProcessTreeRunning(pid, options)) {
+    return terminationResult(ownership, { terminated: true, alreadyDead: true });
+  }
+
+  const graceful = await signalAndWait(
+    pid,
+    ownership,
+    'SIGTERM',
+    options.graceMs ?? 5000,
+    options.pollMs ?? 50
+  );
+  if (graceful.terminated || graceful.error) return graceful;
+
+  return signalAndWait(
+    pid,
+    ownership,
+    'SIGKILL',
+    options.hardKillWaitMs ?? 1000,
+    options.pollMs ?? 50
+  );
+}

package/task-lib/runner.js

@@ -7,6 +7,12 @@ import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
 const { prepareSingleAgentProviderCommand } = require('./provider-helper-runtime.js');
+export {
+  isOwnedProcessTreeRunning,
+  isProcessRunning,
+  killTask,
+  terminateProcess,
+} from './process-termination.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -47,7 +53,13 @@ export function spawnTask(prompt, options = {}) {
     providerName,
     commandSpec
   );
-  const watcherScript = resolveWatcherScript(options);
+  const watcherScript = resolveWatcherScript(
+    {
+      attachable: options.attachable,
+      jsonSchema,
+    },
+    providerName
+  );
   spawnWatcher({
     watcherScript,
     id,
@@ -136,6 +148,8 @@ function buildTaskRecord({ id, prompt, cwd, options, logFile, providerName, mode
     // Attach support
     socketPath: null,
     attachable: false,
+    processGroupId: null,
+    terminationStrategy: null,
   };
 }
 
@@ -157,8 +171,20 @@ function buildWatcherCommandSpec(commandSpec) {
   return watcherCommandSpec;
 }
 
-function resolveWatcherScript(options) {
-  const useAttachable = options.attachable !== false && !options.jsonSchema;
+export function shouldUseAttachableWatcher(options, providerName) {
+  if (options.attachable === false) {
+    return false;
+  }
+
+  // Claude strict structured output still needs the non-PTY watcher. Claude
+  // can treat PTY notifications as streaming commands and reject the run.
+  // Other providers, including Codex, support their structured-output mode in
+  // the attachable PTY watcher and must not lose the advertised attach socket.
+  return !(providerName === 'claude' && options.jsonSchema);
+}
+
+function resolveWatcherScript(options, providerName) {
+  const useAttachable = shouldUseAttachableWatcher(options, providerName);
   return useAttachable ? join(__dirname, 'attachable-watcher.js') : join(__dirname, 'watcher.js');
 }
 
@@ -176,23 +202,3 @@ function spawnWatcher({ watcherScript, id, cwd, logFile, finalArgs, watcherConfi
   watcher.unref();
   watcher.disconnect(); // Close IPC channel so parent can exit
 }
-
-export function isProcessRunning(pid) {
-  if (!pid) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export function killTask(pid) {
-  if (!pid) return false;
-  try {
-    process.kill(pid, 'SIGTERM');
-    return true;
-  } catch {
-    return false;
-  }
-}

package/task-lib/store.js

@@ -50,7 +50,9 @@ function getDb() {
       model TEXT,
       schedule_id TEXT,
       socket_path TEXT,
-      attachable INTEGER DEFAULT 0
+      attachable INTEGER DEFAULT 0,
+      process_group_id INTEGER,
+      termination_strategy TEXT
     );
 
     CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
@@ -75,9 +77,19 @@ function getDb() {
     CREATE INDEX IF NOT EXISTS idx_schedules_enabled ON schedules(enabled);
   `);
 
+  ensureTaskColumn(db, 'process_group_id', 'INTEGER');
+  ensureTaskColumn(db, 'termination_strategy', 'TEXT');
+
   return db;
 }
 
+function ensureTaskColumn(database, name, definition) {
+  const columns = database.pragma('table_info(tasks)');
+  if (!columns.some((column) => column.name === name)) {
+    database.exec(`ALTER TABLE tasks ADD COLUMN ${name} ${definition}`);
+  }
+}
+
 export function ensureDirs() {
   if (!existsSync(TASKS_DIR)) mkdirSync(TASKS_DIR, { recursive: true });
   if (!existsSync(LOGS_DIR)) mkdirSync(LOGS_DIR, { recursive: true });
@@ -110,6 +122,8 @@ function rowToTask(row) {
     scheduleId: row.schedule_id,
     socketPath: row.socket_path,
     attachable: Boolean(row.attachable),
+    processGroupId: row.process_group_id,
+    terminationStrategy: row.termination_strategy,
   };
 }
 
@@ -137,11 +151,11 @@ export function saveTasks(tasks) {
     INSERT OR REPLACE INTO tasks (
       id, prompt, full_prompt, cwd, status, pid, session_id, log_file,
       created_at, updated_at, exit_code, error, provider, model,
-      schedule_id, socket_path, attachable
+      schedule_id, socket_path, attachable, process_group_id, termination_strategy
     ) VALUES (
       @id, @prompt, @fullPrompt, @cwd, @status, @pid, @sessionId, @logFile,
       @createdAt, @updatedAt, @exitCode, @error, @provider, @model,
-      @scheduleId, @socketPath, @attachable
+      @scheduleId, @socketPath, @attachable, @processGroupId, @terminationStrategy
     )
   `);
 
@@ -168,6 +182,8 @@ export function saveTasks(tasks) {
         scheduleId: task.scheduleId || null,
         socketPath: task.socketPath || null,
         attachable: task.attachable ? 1 : 0,
+        processGroupId: task.processGroupId || null,
+        terminationStrategy: task.terminationStrategy || null,
       });
     }
   });
@@ -232,7 +248,9 @@ export function updateTask(id, updates) {
       model = @model,
       schedule_id = @scheduleId,
       socket_path = @socketPath,
-      attachable = @attachable
+      attachable = @attachable,
+      process_group_id = @processGroupId,
+      termination_strategy = @terminationStrategy
     WHERE id = @id
   `
     )
@@ -253,6 +271,8 @@ export function updateTask(id, updates) {
       scheduleId: updated.scheduleId || null,
       socketPath: updated.socketPath || null,
       attachable: updated.attachable ? 1 : 0,
+      processGroupId: updated.processGroupId || null,
+      terminationStrategy: updated.terminationStrategy || null,
     });
 
   return updated;
@@ -277,11 +297,11 @@ export function addTask(task) {
     INSERT INTO tasks (
       id, prompt, full_prompt, cwd, status, pid, session_id, log_file,
       created_at, updated_at, exit_code, error, provider, model,
-      schedule_id, socket_path, attachable
+      schedule_id, socket_path, attachable, process_group_id, termination_strategy
     ) VALUES (
       @id, @prompt, @fullPrompt, @cwd, @status, @pid, @sessionId, @logFile,
       @createdAt, @updatedAt, @exitCode, @error, @provider, @model,
-      @scheduleId, @socketPath, @attachable
+      @scheduleId, @socketPath, @attachable, @processGroupId, @terminationStrategy
     )
   `
     )
@@ -303,6 +323,8 @@ export function addTask(task) {
       scheduleId: fullTask.scheduleId || null,
       socketPath: fullTask.socketPath || null,
       attachable: fullTask.attachable ? 1 : 0,
+      processGroupId: fullTask.processGroupId || null,
+      terminationStrategy: fullTask.terminationStrategy || null,
     });
 
   return fullTask;

package/task-lib/watcher.js

@@ -45,10 +45,15 @@ const child = spawn(command, finalArgs, {
   cwd: commandSpec.cwd || cwd,
   env,
   stdio: ['ignore', 'pipe', 'pipe'],
+  detached: process.platform !== 'win32',
   windowsHide: true,
 });
 
-updateTask(taskId, { pid: child.pid });
+updateTask(taskId, {
+  pid: child.pid,
+  processGroupId: process.platform === 'win32' ? null : child.pid,
+  terminationStrategy: process.platform === 'win32' ? 'process-tree' : 'process-group',
+});
 
 const silentJsonMode =
   config.outputFormat === 'json' &&
@@ -285,6 +290,8 @@ child.on('close', async (code, signal) => {
   try {
     await updateTask(taskId, {
       status,
+      pid: null,
+      processGroupId: null,
       exitCode: resolvedCode,
       error: fatalError || (resolvedCode !== 0 && signal ? `Killed by ${signal}` : null),
     });
@@ -298,7 +305,12 @@ child.on('error', async (err) => {
   log(`\nError: ${err.message}\n`);
   cleanupCommandSpecSync();
   try {
-    await updateTask(taskId, { status: 'failed', error: err.message });
+    await updateTask(taskId, {
+      status: 'failed',
+      pid: null,
+      processGroupId: null,
+      error: err.message,
+    });
   } catch (updateError) {
     log(`[${Date.now()}][ERROR] Failed to update task status: ${updateError.message}\n`);
   }