@the-open-engine/zeroshot 6.31.2 → 6.32.0

package/src/status-footer.js

@@ -151,21 +151,29 @@ class StatusFooter {
   }
 
   /**
-   * Print text to stdout, coordinating with the render cycle.
-   * When a render is in progress, queues output to prevent cursor corruption.
-   * When no render is active, writes immediately.
-   *
-   * MUST be used instead of console.log() when status footer is active.
-   * @param {string} text - Text to print (newline will be added)
+   * Print one logical line while coordinating with footer rendering.
+   * The caller owns line normalization; this method appends one newline.
+   * @param {string} text
    */
   print(text) {
+    this._queueOrWrite(`${text}\n`);
+  }
+
+  /**
+   * Write an exact streaming chunk while coordinating with footer rendering.
+   * @param {string} text
+   */
+  write(text) {
+    this._queueOrWrite(String(text));
+  }
+
+  /** @private */
+  _queueOrWrite(text) {
     if (this.isRendering) {
-      // Queue for later - render() will flush after restoring cursor
       this.printQueue.push(text);
-    } else {
-      // Write immediately - no render in progress
-      process.stdout.write(text + '\n');
+      return;
     }
+    process.stdout.write(text);
   }
 
   /**
@@ -176,8 +184,7 @@ class StatusFooter {
   _flushPrintQueue() {
     if (this.printQueue.length === 0) return;
 
-    // Write all queued output
-    const output = this.printQueue.map((text) => text + '\n').join('');
+    const output = this.printQueue.join('');
     this.printQueue = [];
     process.stdout.write(output);
   }

package/task-lib/commands/list.js

@@ -1,97 +1,109 @@
 import chalk from 'chalk';
+import { resolveEffectiveTaskStatus } from '../effective-status.js';
 import { loadTasks } from '../store.js';
-import { isProcessRunning } from '../runner.js';
 
-export function listTasks(options = {}) {
-  const tasks = loadTasks();
-  const taskList = Object.values(tasks);
+const DEFAULT_LIMIT = 20;
+
+function selectTasks(options = {}, deps = {}) {
+  const readTasks = deps.loadTasks || loadTasks;
+  const resolveStatus = deps.resolveEffectiveTaskStatus || resolveEffectiveTaskStatus;
+  const allTasks = Object.values(readTasks());
+  const selected = allTasks
+    .map((task) => ({ task, effectiveStatus: resolveStatus(task) }))
+    .sort((left, right) => new Date(left.task.createdAt) - new Date(right.task.createdAt))
+    .filter(({ effectiveStatus }) => !options.status || effectiveStatus.status === options.status)
+    .slice(0, options.limit || DEFAULT_LIMIT);
+  return { total: allTasks.length, selected };
+}
+
+function projectTask({ task, effectiveStatus }) {
+  return {
+    id: task.id,
+    status: effectiveStatus.status,
+    statusReason: effectiveStatus.reason,
+    cwd: task.cwd,
+    provider: task.provider || null,
+    model: task.model || null,
+    createdAt: task.createdAt,
+    updatedAt: task.updatedAt,
+    exitCode: task.exitCode ?? null,
+    error: task.error || null,
+    attachable: task.attachable === true,
+  };
+}
+
+export function getTasksData(options = {}, deps = {}) {
+  return selectTasks(options, deps).selected.map(projectTask);
+}
 
-  if (taskList.length === 0) {
+export function listTasks(options = {}, deps = {}) {
+  const { selected, total } = selectTasks(options, deps);
+
+  if (total === 0) {
     console.log(chalk.dim('No tasks found.'));
     return;
   }
 
-  // Sort by creation date, oldest first (chronological)
-  taskList.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
-
-  // Filter by status if specified
-  let filtered = taskList;
-  if (options.status) {
-    filtered = taskList.filter((t) => t.status === options.status);
+  if (options.verbose) {
+    printVerboseTasks(selected, total);
+  } else {
+    printTaskTable(selected, total);
   }
+}
 
-  // Limit results
-  const limit = options.limit || 20;
-  filtered = filtered.slice(0, limit);
-
-  // Table format (default) or verbose format
-  if (options.verbose) {
-    // Verbose format (old behavior)
-    console.log(chalk.bold(`\nTasks (${filtered.length}/${taskList.length})\n`));
-
-    for (const task of filtered) {
-      // Verify running status
-      let status = task.status;
-      if (status === 'running' && !isProcessRunning(task.pid)) {
-        status = 'stale';
-      }
-
-      const statusColor =
-        {
-          running: chalk.green,
-          completed: chalk.green,
-          failed: chalk.red,
-          stale: chalk.yellow,
-        }[status] || chalk.dim;
-
-      const age = getAge(task.createdAt);
-      const timestamp = new Date(task.createdAt).toLocaleString();
-
-      console.log(
-        `${statusColor('●')} ${chalk.cyan(task.id)} ${statusColor(`[${status}]`)} ${chalk.dim(age + ' • ' + timestamp)}`
-      );
-      console.log(`  ${chalk.dim('CWD:')} ${task.cwd}`);
-      console.log(`  ${chalk.dim('Prompt:')} ${task.prompt}`);
-      if (task.pid && status === 'running') {
-        console.log(`  ${chalk.dim('PID:')} ${task.pid}`);
-      }
-      if (task.error) {
-        console.log(`  ${chalk.red('Error:')} ${task.error}`);
-      }
-      console.log();
+function printVerboseTasks(selected, total) {
+  console.log(chalk.bold(`\nTasks (${selected.length}/${total})\n`));
+
+  for (const { task, effectiveStatus } of selected) {
+    const statusColor = colorForStatus(effectiveStatus.status);
+    const age = getAge(task.createdAt);
+    const timestamp = new Date(task.createdAt).toLocaleString();
+
+    const heading = `${statusColor('●')} ${chalk.cyan(task.id)}`;
+    const status = statusColor(`[${effectiveStatus.status}]`);
+    const timing = chalk.dim(age + ' • ' + timestamp);
+    console.log(`${heading} ${status} ${timing}`);
+    console.log(`  ${chalk.dim('CWD:')} ${task.cwd}`);
+    console.log(`  ${chalk.dim('Prompt:')} ${task.prompt}`);
+    if (task.pid && effectiveStatus.status === 'running') {
+      console.log(`  ${chalk.dim('PID:')} ${task.pid}`);
     }
-  } else {
-    // Table format (clean, default)
-    console.log(chalk.bold(`\n=== Tasks (${filtered.length}/${taskList.length}) ===`));
-    console.log(`${'ID'.padEnd(25)} ${'Status'.padEnd(12)} ${'Age'.padEnd(10)} CWD`);
-    console.log('-'.repeat(100));
-
-    for (const task of filtered) {
-      // Verify running status
-      let status = task.status;
-      if (status === 'running' && !isProcessRunning(task.pid)) {
-        status = 'stale';
-      }
-
-      const statusColor =
-        {
-          running: chalk.green,
-          completed: chalk.green,
-          failed: chalk.red,
-          stale: chalk.yellow,
-        }[status] || chalk.dim;
-
-      const age = getAge(task.createdAt);
-      const cwd = task.cwd.replace(process.env.HOME, '~');
-
-      console.log(
-        `${chalk.cyan(task.id.padEnd(25))} ${statusColor(status.padEnd(12))} ${chalk.dim(age.padEnd(10))} ${chalk.dim(cwd)}`
-      );
+    if (task.error) {
+      console.log(`  ${chalk.red('Error:')} ${task.error}`);
     }
     console.log();
   }
 }
 
+function printTaskTable(selected, total) {
+  console.log(chalk.bold(`\n=== Tasks (${selected.length}/${total}) ===`));
+  console.log(`${'ID'.padEnd(25)} ${'Status'.padEnd(12)} ${'Age'.padEnd(10)} CWD`);
+  console.log('-'.repeat(100));
+
+  for (const { task, effectiveStatus } of selected) {
+    const statusColor = colorForStatus(effectiveStatus.status);
+    const age = getAge(task.createdAt);
+    const cwd = process.env.HOME ? task.cwd.replace(process.env.HOME, '~') : task.cwd;
+
+    const id = chalk.cyan(task.id.padEnd(25));
+    const status = statusColor(effectiveStatus.status.padEnd(12));
+    const timing = chalk.dim(age.padEnd(10));
+    console.log(`${id} ${status} ${timing} ${chalk.dim(cwd)}`);
+  }
+  console.log();
+}
+
+function colorForStatus(status) {
+  return (
+    {
+      running: chalk.green,
+      completed: chalk.green,
+      failed: chalk.red,
+      stale: chalk.yellow,
+    }[status] || chalk.dim
+  );
+}
+
 function getAge(dateStr) {
   const diff = Date.now() - new Date(dateStr).getTime();
   const mins = Math.floor(diff / 60000);

package/task-lib/commands/status.js

@@ -1,58 +1,115 @@
 import chalk from 'chalk';
+import { resolveEffectiveTaskStatus } from '../effective-status.js';
 import { getTask } from '../store.js';
-import { isOwnedProcessTreeRunning } from '../runner.js';
 
-export function showStatus(taskId) {
-  const task = getTask(taskId);
+function nullable(value) {
+  if (value === undefined || value === null || value === '') return null;
+  return value;
+}
+
+function preferredPrompt(task) {
+  const fullPrompt = nullable(task.fullPrompt);
+  if (fullPrompt !== null) return fullPrompt;
+  return nullable(task.prompt);
+}
+
+function cleanupState(commandCleanup) {
+  if (commandCleanup) return 'pending';
+  return 'complete';
+}
+
+function projectStatus(task, effectiveStatus) {
+  return {
+    id: task.id,
+    status: effectiveStatus.status,
+    statusReason: effectiveStatus.reason,
+    statusDetail: effectiveStatus.detail,
+    createdAt: task.createdAt,
+    updatedAt: task.updatedAt,
+    cwd: task.cwd,
+    pid: nullable(task.pid),
+    exitCode: nullable(task.exitCode),
+    sessionId: nullable(task.sessionId),
+    requestedResumeSessionId: nullable(task.requestedResumeSessionId),
+    cleanup: cleanupState(task.commandCleanup),
+    logFile: nullable(task.logFile),
+    prompt: preferredPrompt(task),
+    error: nullable(task.error),
+    provider: nullable(task.provider),
+    model: nullable(task.model),
+    attachable: task.attachable === true,
+  };
+}
 
+export function getStatusData(taskId, deps = {}) {
+  const readTask = deps.getTask || getTask;
+  const resolveStatus = deps.resolveEffectiveTaskStatus || resolveEffectiveTaskStatus;
+  const task = readTask(taskId);
   if (!task) {
-    console.log(chalk.red(`Task not found: ${taskId}`));
-    process.exit(1);
+    throw new Error(`Task not found: ${taskId}`);
   }
+  return projectStatus(task, resolveStatus(task));
+}
 
-  // Verify running status
-  let status = task.status;
-  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})`;
-    }
+function loadStatusOrExit(taskId, deps) {
+  try {
+    return getStatusData(taskId, deps);
+  } catch (error) {
+    console.log(chalk.red(error.message));
+    process.exit(1);
+    return null;
   }
+}
 
-  const statusColor =
+function colorForStatus(status) {
+  return (
     {
       running: chalk.green,
       completed: chalk.green,
       failed: chalk.red,
-    }[task.status] || chalk.yellow;
-
-  console.log(chalk.bold(`\nTask: ${task.id}\n`));
-  console.log(`${chalk.dim('Status:')}     ${statusColor(status)}`);
-  console.log(`${chalk.dim('Created:')}    ${task.createdAt}`);
-  console.log(`${chalk.dim('Updated:')}    ${task.updatedAt}`);
-  console.log(`${chalk.dim('CWD:')}        ${task.cwd}`);
-  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}`);
+    }[status] || chalk.yellow
+  );
+}
 
-  console.log(`\n${chalk.dim('Prompt:')}`);
-  console.log(task.fullPrompt || task.prompt);
+function statusLabel(status) {
+  if (status.statusDetail) return `${status.status} (${status.statusDetail})`;
+  return status.status;
+}
 
-  if (task.error) {
-    console.log(`\n${chalk.red('Error:')} ${task.error}`);
-  }
+function displayOptional(value) {
+  if (value === null) return 'N/A';
+  return value;
+}
+
+function printRequestedSession(status) {
+  if (!status.requestedResumeSessionId) return;
+  console.log(`${chalk.dim('Requested:')}  ${status.requestedResumeSessionId}`);
+}
+
+function printError(status) {
+  if (!status.error) return;
+  console.log(`\n${chalk.red('Error:')} ${status.error}`);
+}
 
+export function showStatus(taskId, deps = {}) {
+  const status = loadStatusOrExit(taskId, deps);
+  if (!status) return;
+
+  const statusColor = colorForStatus(status.status);
+  console.log(chalk.bold(`\nTask: ${status.id}\n`));
+  console.log(`${chalk.dim('Status:')}     ${statusColor(statusLabel(status))}`);
+  console.log(`${chalk.dim('Created:')}    ${status.createdAt}`);
+  console.log(`${chalk.dim('Updated:')}    ${status.updatedAt}`);
+  console.log(`${chalk.dim('CWD:')}        ${status.cwd}`);
+  console.log(`${chalk.dim('PID:')}        ${displayOptional(status.pid)}`);
+  console.log(`${chalk.dim('Exit Code:')}  ${displayOptional(status.exitCode)}`);
+  console.log(`${chalk.dim('Session:')}    ${displayOptional(status.sessionId)}`);
+  console.log(`${chalk.dim('Cleanup:')}    ${status.cleanup}`);
+  printRequestedSession(status);
+  console.log(`${chalk.dim('Log File:')}   ${displayOptional(status.logFile)}`);
+
+  console.log(`\n${chalk.dim('Prompt:')}`);
+  console.log(displayOptional(status.prompt));
+  printError(status);
   console.log();
 }

package/task-lib/effective-status.js

@@ -0,0 +1,52 @@
+import { isOwnedProcessTreeRunning } from './runner.js';
+
+const DEFAULT_STARTUP_GRACE_MS = 30_000;
+
+const STALE_REASON_LABELS = {
+  invalid_process_ownership: 'invalid process ownership',
+  process_died: 'process died',
+  startup_timeout: 'provider startup timed out',
+};
+
+function runningStatus() {
+  return { status: 'running', reason: null, detail: null, label: 'running' };
+}
+
+function staleStatus(reason) {
+  const detail = STALE_REASON_LABELS[reason];
+  return { status: 'stale', reason, detail, label: `stale (${detail})` };
+}
+
+function resolveStartupStatus(task, deps) {
+  const createdAt = Date.parse(task.createdAt);
+  const now = deps.now?.() ?? Date.now();
+  const graceMs = deps.startupGraceMs ?? DEFAULT_STARTUP_GRACE_MS;
+  return Number.isFinite(createdAt) && now >= createdAt && now - createdAt <= graceMs
+    ? runningStatus()
+    : staleStatus('startup_timeout');
+}
+
+export function resolveEffectiveTaskStatus(task, deps = {}) {
+  if (task.status !== 'running') {
+    return { status: task.status, reason: null, detail: null, label: task.status };
+  }
+  // The durable row is written before the detached watcher can publish its owned provider PID.
+  // Treat that startup window as live, but bound it so an abandoned watcher cannot look active
+  // indefinitely.
+  if (task.pid === null) return resolveStartupStatus(task, deps);
+
+  const isRunning = deps.isOwnedProcessTreeRunning || isOwnedProcessTreeRunning;
+  try {
+    if (
+      isRunning(task.pid, {
+        processGroupId: task.processGroupId,
+        terminationStrategy: task.terminationStrategy || 'process',
+      })
+    ) {
+      return runningStatus();
+    }
+    return staleStatus('process_died');
+  } catch {
+    return staleStatus('invalid_process_ownership');
+  }
+}