@crewx/cli 0.9.0-rc.94 → 0.9.0-rc.96

package/dist/commands/execute.js

@@ -8,90 +8,35 @@
  *   --provider <cli/xxx>     Provider override
  *   --model <name>           Model override (e.g. claude-sonnet-5)
  *   --metadata <json>        Extra metadata JSON (double-quoted object). Propagated to events/hooks/tracing.
- *                           e.g. --metadata='{"workflow_id":"wf-1"}'
  *   --verbose                Debug output mode (default: raw agent response only)
  *   --config/-c <path>       Config file path override
  *   --output-format <fmt>    Output format (json|text|stream-json)
  *   --effort <level>         Model effort (high|medium|low)
- *   -f/--prompt-file <path>  Read task body from file (bypasses cmd.exe argv truncation)
- *   --detach                 Re-spawn as a detached runner; print task-id and exit 0 immediately.
- *                           Ignored when CREWX_TRACE_ID is already set (recursive-spawn guard) or
- *                           on win32 (unsupported — exits with an error).
+ *   -f/--prompt-file <path>  Read task body from file
+ *   --detach/--async         Persist a receipt and launch a detached runner
+ *   --wait                   Force synchronous execution
  *
  * Stdin support:
  *   Pipe or redirect content into crewx x to supply the task body via stdin.
- *   e.g. cat task.md | crewx x "@agent label"
  *   Stdin is ignored when running in an interactive TTY.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDetachedMiddle = void 0;
 exports.handleExecute = handleExecute;
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const os_1 = require("os");
 const sdk_1 = require("@crewx/sdk");
+const repository_1 = require("@crewx/sdk/repository");
 const parse_agent_message_1 = require("./parse-agent-message");
 const parse_common_flags_1 = require("./parse-common-flags");
 const resolve_prompt_1 = require("./resolve-prompt");
 const crewx_cli_1 = require("../bootstrap/crewx-cli");
 const inherited_trace_1 = require("../utils/inherited-trace");
 const write_output_1 = require("./write-output");
+const detached_1 = require("./detached");
 const emit_trailer_1 = require("./emit-trailer");
-/**
- * Split `--detach` out of argv, respecting the `--` literal-args sentinel
- * (a `--detach` appearing after `--` is message text, not the flag).
- */
-function extractDetachFlag(args) {
-    const rest = [];
-    let detach = false;
-    let escapeMode = false;
-    for (const arg of args) {
-        if (!escapeMode && arg === '--') {
-            escapeMode = true;
-            rest.push(arg);
-            continue;
-        }
-        if (!escapeMode && arg === '--detach') {
-            detach = true;
-            continue;
-        }
-        rest.push(arg);
-    }
-    return { detach, rest };
-}
-/**
- * Double-detach: re-spawn this same CLI entry (minus --detach) as a detached
- * process so it survives the parent's exit. The task-id is pre-generated here
- * and injected as CREWX_TRACE_ID so the runner's own task row is created under
- * this id (see handleExecute's `selfTaskId` derivation below) — it doubles as
- * both this task's row id and the root of any further delegation it spawns.
- *
- * stdout contract (script-parseable): task-id only, on the first line.
- * Everything else goes to stderr.
- */
-function runDetached(filteredArgs) {
-    const taskId = (0, sdk_1.generateId)('tsk');
-    const logDir = (0, path_1.join)((0, os_1.homedir)(), '.crewx', 'logs');
-    if (!(0, fs_1.existsSync)(logDir))
-        (0, fs_1.mkdirSync)(logDir, { recursive: true });
-    const logPath = (0, path_1.join)(logDir, `${taskId}.log`);
-    const logFd = (0, fs_1.openSync)(logPath, 'a');
-    const entry = process.argv[1];
-    const child = (0, child_process_1.spawn)(process.execPath, [entry, 'x', ...filteredArgs], {
-        detached: true,
-        stdio: ['ignore', logFd, logFd],
-        env: { ...process.env, CREWX_TRACE_ID: taskId },
-    });
-    (0, fs_1.closeSync)(logFd);
-    child.on('error', (err) => {
-        process.stderr.write(`Failed to spawn detached runner: ${err.message}\n`);
-    });
-    child.unref();
-    console.log(taskId);
-    process.stderr.write(`Detached task ${taskId} started (log: ${logPath}).\n`);
-    process.stderr.write(`Use \`crewx result ${taskId} --wait=N\` to wait for completion.\n`);
-    process.exit(0);
-}
+// Exported for platform-focused tests; the middle hop remains an internal CLI
+// contract and is not routed through the public command registry.
+var detached_2 = require("./detached");
+Object.defineProperty(exports, "runDetachedMiddle", { enumerable: true, get: function () { return detached_2.runDetachedMiddle; } });
 /**
  * Handle `crewx execute <agentRef> <message>` command.
  *
@@ -99,29 +44,27 @@ function runDetached(filteredArgs) {
  * --verbose: debug info written to stderr, response to stdout.
  */
 async function handleExecute(args, command = 'execute', emitState = (0, emit_trailer_1.createDelegationEmitState)()) {
-    const { detach, rest: detachFilteredArgs } = extractDetachFlag(args);
-    if (detach) {
-        // Recursive-spawn guard: a CREWX_TRACE_ID already present means this
-        // process is itself running inside a traced context (either the
-        // respawned runner, or a delegated sub-call) — never chain a second
-        // detach off of it. Silently fall through to normal (synchronous) execution.
-        if (process.env['CREWX_TRACE_ID']) {
-            process.stderr.write('Note: --detach ignored (already running inside a traced context; CREWX_TRACE_ID is set).\n');
-        }
-        else if (process.platform === 'win32') {
-            console.error('Error: --detach is not supported on win32.');
-            (0, emit_trailer_1.emitDelegationResult)({ command, isError: true, state: emitState });
-            process.exit(1);
-            return;
-        }
-        else {
-            runDetached(detachFilteredArgs);
-            return;
-        }
+    // The private middle-hop marker is consumed before public flag parsing. An
+    // invalid direct use remains an unknown option and is rejected normally.
+    const middleHop = (0, detached_1.readDetachedMiddleHop)(args);
+    if (middleHop) {
+        await (0, detached_1.runDetachedMiddle)(command, middleHop);
+        return;
+    }
+    const receiptFlags = (0, detached_1.extractReceiptFlags)(args);
+    const receiptMode = (0, detached_1.resolveReceiptMode)({
+        detach: receiptFlags.detach,
+        wait: receiptFlags.wait,
+        detachedRunner: (0, inherited_trace_1.isDetachedRunner)(),
+        agentContext: Boolean(process.env['CREWX_AGENT_ID']),
+    });
+    if (receiptMode.receipt) {
+        await (0, detached_1.runDetached)(command, receiptFlags.rest, receiptMode.reason);
+        return;
     }
     let parsedFlags;
     try {
-        parsedFlags = (0, parse_common_flags_1.parseCommonFlags)(detachFilteredArgs);
+        parsedFlags = (0, parse_common_flags_1.parseCommonFlags)(receiptFlags.rest);
     }
     catch (err) {
         (0, emit_trailer_1.emitDelegationResult)({ command, isError: true, state: emitState });
@@ -187,6 +130,7 @@ async function handleExecute(args, command = 'execute', emitState = (0, emit_tra
     }
     // file:// remote agent delegation is handled transparently inside Crewx.query/execute.
     if (verbose) {
+        process.stderr.write(`mode=sync reason=${receiptMode.reason}\n`);
         process.stderr.write(`📋 Task: ${finalMessage}\n`);
         process.stderr.write(`🤖 Agent: ${agentRef}\n`);
         if (thread)
@@ -200,7 +144,7 @@ async function handleExecute(args, command = 'execute', emitState = (0, emit_tra
         if (effort)
             process.stderr.write(`⚡ Effort: ${effort}\n`);
         if (overdrive)
-            process.stderr.write(`🚀 Overdrive: ON\n`);
+            process.stderr.write('🚀 Overdrive: ON\n');
         process.stderr.write('─'.repeat(60) + '\n');
     }
     let parsedMetadata = {};
@@ -214,14 +158,21 @@ async function handleExecute(args, command = 'execute', emitState = (0, emit_tra
         process.exit(2);
         return;
     }
-    // A trace with a rootTraceId but no parentTaskId means the id was pre-assigned
-    // to *this* task itself (the detach runner's parent injects only CREWX_TRACE_ID,
-    // never CREWX_PARENT_TASK_ID — see execute.ts's runDetached), not inherited from
-    // an ancestor task in a delegation chain (which always carries both). It doubles
-    // as this task's own row id so `crewx result <task-id>` can find it.
-    const selfTaskId = inheritedTrace && !inheritedTrace.parentTaskId
-        ? (inheritedTrace.rootTraceId || undefined)
-        : undefined;
+    // Only the detached runner may adopt a pre-issued task row. Trace variables
+    // describe the caller chain and are never used as this task's identity.
+    const detachedRunner = (0, inherited_trace_1.isDetachedRunner)();
+    const assignedTaskId = (0, inherited_trace_1.readRunnerAssignment)();
+    let selfTaskId;
+    if (assignedTaskId !== undefined) {
+        const adoption = (0, detached_1.adoptAssignedTask)(new repository_1.TaskRepository(), assignedTaskId, detachedRunner);
+        if (adoption.kind === 'failed') {
+            (0, emit_trailer_1.emitDelegationResult)({ command, trace: inheritedTrace, isError: true, state: emitState });
+            process.exit(1);
+            return;
+        }
+        if (adoption.kind === 'adopted')
+            selfTaskId = adoption.taskId;
+    }
     let exitCode = 0;
     let result;
     try {
@@ -253,9 +204,8 @@ async function handleExecute(args, command = 'execute', emitState = (0, emit_tra
                 process.stderr.write('─'.repeat(40) + '\n');
             }
             (0, write_output_1.writeResult)(out, result.data);
-            if (verbose) {
+            if (verbose)
                 process.stderr.write('\n✅ Execute completed successfully\n');
-            }
         }
     }
     catch (err) {

package/dist/commands/kill.d.ts

@@ -1,9 +1,3 @@
-/**
- * crewx kill handler.
- * Kills a running task by ID or kills all running tasks.
- *
- * Usage:
- *   crewx kill <task-id>   Kill a specific running task
- *   crewx kill --all       Kill all running tasks
- */
+/** Compatibility entry point for `crewx kill`; the implementation lives in stop.ts. */
+export { handleStop } from './stop';
 export declare function handleKill(args: string[]): Promise<void>;

package/dist/commands/kill.js

@@ -1,52 +1,11 @@
 "use strict";
-/**
- * crewx kill handler.
- * Kills a running task by ID or kills all running tasks.
- *
- * Usage:
- *   crewx kill <task-id>   Kill a specific running task
- *   crewx kill --all       Kill all running tasks
- */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStop = void 0;
 exports.handleKill = handleKill;
-const repository_1 = require("@crewx/sdk/repository");
+/** Compatibility entry point for `crewx kill`; the implementation lives in stop.ts. */
+var stop_1 = require("./stop");
+Object.defineProperty(exports, "handleStop", { enumerable: true, get: function () { return stop_1.handleStop; } });
+const stop_2 = require("./stop");
 async function handleKill(args) {
-    const killAll = args.includes('--all');
-    const taskId = args.find(a => !a.startsWith('--'));
-    if (!taskId && !killAll) {
-        console.error('Error: Please provide a task ID or use --all to kill all running tasks.');
-        console.error('');
-        console.error('Usage:');
-        console.error('  crewx kill <task-id>    Kill a running task by ID');
-        console.error('  crewx kill --all        Kill all running tasks');
-        process.exit(1);
-        return;
-    }
-    const repo = new repository_1.TaskRepository();
-    if (killAll) {
-        const running = repo.getRunningTasks();
-        if (running.length === 0) {
-            console.log('No running tasks found.');
-            return;
-        }
-        console.log(`Found ${running.length} running task(s). Killing...`);
-        for (const task of running) {
-            const r = repo.killTask(task.id);
-            if (r.killed) {
-                console.log(`Killed task ${task.id}${r.pid ? ` (PID: ${r.pid})` : ''}`);
-            }
-            else {
-                console.log(`Task ${task.id} could not be killed (may have already finished)`);
-            }
-        }
-        return;
-    }
-    const r = repo.killTask(taskId);
-    if (r.killed) {
-        console.log(`Killed task ${taskId}${r.pid ? ` (PID: ${r.pid})` : ''}`);
-    }
-    else {
-        console.error(`Error: Task not found or not running: ${taskId}`);
-        process.exit(1);
-    }
+    return (0, stop_2.handleStop)(args, 'kill');
 }

package/dist/commands/ps.d.ts

@@ -1,9 +1,9 @@
 /**
  * crewx ps handler.
- * Lists currently running tasks in table format.
+ * Lists active tasks (pending or running) in table format.
  *
  * Usage:
- *   crewx ps           List all running tasks
+ *   crewx ps           List all pending and running tasks
  *   crewx ps --json    Output as JSON array
  */
 export declare function handlePs(args: string[]): Promise<void>;

package/dist/commands/ps.js

@@ -1,15 +1,16 @@
 "use strict";
 /**
  * crewx ps handler.
- * Lists currently running tasks in table format.
+ * Lists active tasks (pending or running) in table format.
  *
  * Usage:
- *   crewx ps           List all running tasks
+ *   crewx ps           List all pending and running tasks
  *   crewx ps --json    Output as JSON array
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handlePs = handlePs;
 const repository_1 = require("@crewx/sdk/repository");
+const cal_1 = require("./cal");
 function formatElapsed(ms) {
     const s = Math.floor(ms / 1000);
     if (s < 60)
@@ -65,6 +66,7 @@ function taskToRow(task, taskRepo) {
     return [
         task.id,
         task.agent_id ?? '—',
+        task.status,
         task.pid !== null && task.pid !== undefined ? String(task.pid) : '—',
         elapsed,
         task.mode ?? '—',
@@ -83,12 +85,11 @@ function renderTable(headers, rows) {
 }
 async function handlePs(args) {
     const repo = new repository_1.TaskRepository();
+    const reaped = repo.reapOrphanedTasks();
+    if (reaped > 0)
+        console.error(`Reaped ${reaped} orphaned task(s)`);
     repo.reapRunningWorkflowTasks();
-    const tasks = repo.getRunningTasks();
-    if (tasks.length === 0) {
-        console.log('No running tasks.');
-        return;
-    }
+    const tasks = repo.getActiveTasks();
     if (args.includes('--json')) {
         const withLastActive = tasks.map((task) => {
             const lastActive = getLastActive(task, repo);
@@ -101,8 +102,16 @@ async function handlePs(args) {
         console.log(JSON.stringify(withLastActive, null, 2));
         return;
     }
-    const headers = ['TASK ID', 'AGENT', 'PID', 'ELAPSED', 'MODE', 'LAST ACTIVE'];
+    if (tasks.length === 0) {
+        console.log('No active tasks.');
+        return;
+    }
+    const headers = ['TASK ID', 'AGENT', 'STATUS', 'PID', 'ELAPSED', 'MODE', 'LAST ACTIVE'];
     const rows = tasks.map((task) => taskToRow(task, repo));
     renderTable(headers, rows);
-    console.log(`\n  ${tasks.length} running task(s)`);
+    console.log(`\n  ${tasks.length} active task(s)`);
+    (0, cal_1.writeCalFooter)({
+        commandId: 'crewx.ps',
+        params: { taskId: tasks[0].id },
+    });
 }

package/dist/commands/query.d.ts

@@ -13,6 +13,8 @@
  *   --output-format <fmt>    Output format (json|text|stream-json)
  *   --effort <level>         Model effort (high|medium|low)
  *   -f/--prompt-file <path>  Read prompt body from file (bypasses cmd.exe argv truncation)
+ *   --detach/--async         Persist a receipt and launch a detached runner
+ *   --wait                   Force synchronous execution
  *
  * Stdin support:
  *   Pipe or redirect content into crewx q to supply the prompt body via stdin.

package/dist/commands/query.js

@@ -14,6 +14,8 @@
  *   --output-format <fmt>    Output format (json|text|stream-json)
  *   --effort <level>         Model effort (high|medium|low)
  *   -f/--prompt-file <path>  Read prompt body from file (bypasses cmd.exe argv truncation)
+ *   --detach/--async         Persist a receipt and launch a detached runner
+ *   --wait                   Force synchronous execution
  *
  * Stdin support:
  *   Pipe or redirect content into crewx q to supply the prompt body via stdin.
@@ -23,12 +25,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleQuery = handleQuery;
 const sdk_1 = require("@crewx/sdk");
+const repository_1 = require("@crewx/sdk/repository");
 const parse_agent_message_1 = require("./parse-agent-message");
 const parse_common_flags_1 = require("./parse-common-flags");
 const resolve_prompt_1 = require("./resolve-prompt");
 const crewx_cli_1 = require("../bootstrap/crewx-cli");
 const inherited_trace_1 = require("../utils/inherited-trace");
 const write_output_1 = require("./write-output");
+const detached_1 = require("./detached");
 const emit_trailer_1 = require("./emit-trailer");
 /**
  * Handle `crewx query <agentRef> <message>` command.
@@ -37,9 +41,27 @@ const emit_trailer_1 = require("./emit-trailer");
  * --verbose: debug info written to stderr, response to stdout.
  */
 async function handleQuery(args, command = 'query', emitState = (0, emit_trailer_1.createDelegationEmitState)()) {
+    // The private middle-hop marker is consumed before public flag parsing. An
+    // invalid direct use remains an unknown option and is rejected normally.
+    const middleHop = (0, detached_1.readDetachedMiddleHop)(args);
+    if (middleHop) {
+        await (0, detached_1.runDetachedMiddle)(command, middleHop);
+        return;
+    }
+    const receiptFlags = (0, detached_1.extractReceiptFlags)(args);
+    const receiptMode = (0, detached_1.resolveReceiptMode)({
+        detach: receiptFlags.detach,
+        wait: receiptFlags.wait,
+        detachedRunner: (0, inherited_trace_1.isDetachedRunner)(),
+        agentContext: Boolean(process.env['CREWX_AGENT_ID']),
+    });
+    if (receiptMode.receipt) {
+        await (0, detached_1.runDetached)(command, receiptFlags.rest, receiptMode.reason);
+        return;
+    }
     let parsedFlags;
     try {
-        parsedFlags = (0, parse_common_flags_1.parseCommonFlags)(args);
+        parsedFlags = (0, parse_common_flags_1.parseCommonFlags)(receiptFlags.rest);
     }
     catch (err) {
         (0, emit_trailer_1.emitDelegationResult)({ command, isError: true, state: emitState });
@@ -105,6 +127,7 @@ async function handleQuery(args, command = 'query', emitState = (0, emit_trailer
     }
     // file:// remote agent delegation is handled transparently inside Crewx.query/execute.
     if (verbose) {
+        process.stderr.write(`mode=sync reason=${receiptMode.reason}\n`);
         process.stderr.write(`📋 Task: ${finalMessage}\n`);
         process.stderr.write(`🤖 Agent: ${agentRef}\n`);
         if (thread)
@@ -132,12 +155,21 @@ async function handleQuery(args, command = 'query', emitState = (0, emit_trailer
         process.exit(2);
         return;
     }
-    // A trace with a rootTraceId but no parentTaskId means the id was pre-assigned
-    // to *this* task itself. Keep query and execute on the same contract so the
-    // reserved trace id remains the single source of truth for this task row.
-    const selfTaskId = inheritedTrace && !inheritedTrace.parentTaskId
-        ? (inheritedTrace.rootTraceId || undefined)
-        : undefined;
+    // Only the detached runner may adopt a pre-issued task row. Trace variables
+    // describe the caller chain and are never used as this task's identity.
+    const detachedRunner = (0, inherited_trace_1.isDetachedRunner)();
+    const assignedTaskId = (0, inherited_trace_1.readRunnerAssignment)();
+    let selfTaskId;
+    if (assignedTaskId !== undefined) {
+        const adoption = (0, detached_1.adoptAssignedTask)(new repository_1.TaskRepository(), assignedTaskId, detachedRunner);
+        if (adoption.kind === 'failed') {
+            (0, emit_trailer_1.emitDelegationResult)({ command, trace: inheritedTrace, isError: true, state: emitState });
+            process.exit(1);
+            return;
+        }
+        if (adoption.kind === 'adopted')
+            selfTaskId = adoption.taskId;
+    }
     let exitCode = 0;
     let result;
     try {

package/dist/commands/registry.js

@@ -13,7 +13,7 @@ exports.KNOWN_COMMANDS = new Set([
     'q', 'query',
     'x', 'execute',
     'agent',
-    'ps', 'kill', 'result', 'log', 'restart',
+    'ps', 'stop', 'kill', 'result', 'log', 'restart',
     'doctor', 'init',
     'db',
     'help',

package/dist/commands/result.d.ts

@@ -5,8 +5,9 @@
  * Usage:
  *   crewx result <task-id>            Print raw result
  *   crewx result <task-id> --json     Print full task record as JSON
- *   crewx result <task-id> --wait=N   Poll (1s interval) up to N seconds for
- *                                    the task to leave 'running'. Exit 124 on
+ *   crewx result <task-id> --wait=<seconds> Poll (1s interval) up to the given
+ *                                    number of seconds for
+ *                                    the task to leave 'pending'/'running'. Exit 124 on
  *                                    timeout. --wait=0 behaves like no --wait
  *                                    (single immediate check).
  *   crewx result                      List recent tasks (latest 10)

package/dist/commands/result.js

@@ -6,8 +6,9 @@
  * Usage:
  *   crewx result <task-id>            Print raw result
  *   crewx result <task-id> --json     Print full task record as JSON
- *   crewx result <task-id> --wait=N   Poll (1s interval) up to N seconds for
- *                                    the task to leave 'running'. Exit 124 on
+ *   crewx result <task-id> --wait=<seconds> Poll (1s interval) up to the given
+ *                                    number of seconds for
+ *                                    the task to leave 'pending'/'running'. Exit 124 on
  *                                    timeout. --wait=0 behaves like no --wait
  *                                    (single immediate check).
  *   crewx result                      List recent tasks (latest 10)
@@ -16,19 +17,67 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleResult = handleResult;
 const sdk_1 = require("@crewx/sdk");
 const repository_1 = require("@crewx/sdk/repository");
+const cal_1 = require("./cal");
 const POLL_INTERVAL_MS = 1000;
+const REAP_INTERVAL_MS = 10_000;
 function statusIcon(status) {
     switch (status) {
+        case 'pending': return '🕓';
         case 'running': return '⏳';
         case 'success': return '✅';
         case 'failed': return '❌';
+        case 'stopped': return '⏹';
+        case 'runner_lost': return '⚠️';
         default: return '❓';
     }
 }
+function isActiveStatus(status) {
+    return status === 'pending' || status === 'running';
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-/** Parses `--wait=N` (seconds). Returns undefined when the flag is absent. */
+function resultCommandId(status) {
+    switch (status) {
+        case 'pending': return 'crewx.result-pending';
+        case 'running': return 'crewx.result-running';
+        case 'success': return 'crewx.result-done';
+        case 'failed':
+        case 'stopped':
+        case 'runner_lost':
+            return 'crewx.result-terminal-abnormal';
+        default: return 'crewx.result';
+    }
+}
+function writeResultCalFooter(task, lastWaitSeconds) {
+    const params = { taskId: task.id };
+    if (task.agent_id)
+        params.agent = task.agent_id;
+    if (task.thread_id)
+        params.thread = task.thread_id;
+    if (isActiveStatus(task.status)) {
+        params.wait = String((0, cal_1.suggestWaitSeconds)({
+            startedAt: task.started_at,
+            lastWaitSeconds,
+        }));
+    }
+    (0, cal_1.writeCalFooter)({ commandId: resultCommandId(task.status), params });
+}
+function formatRuntimeDuration(startedAt, now = Date.now()) {
+    const startedAtMs = Date.parse(startedAt);
+    const elapsedSeconds = Number.isFinite(startedAtMs)
+        ? Math.max(0, Math.floor((now - startedAtMs) / 1000))
+        : 0;
+    const hours = Math.floor(elapsedSeconds / 3600);
+    const minutes = Math.floor((elapsedSeconds % 3600) / 60);
+    const seconds = elapsedSeconds % 60;
+    if (hours > 0)
+        return `${hours}h ${minutes}m ${seconds}s`;
+    if (minutes > 0)
+        return `${minutes}m ${seconds}s`;
+    return `${seconds}s`;
+}
+/** Parses `--wait=<seconds>`. Returns undefined when the flag is absent. */
 function parseWaitSeconds(args) {
     const arg = args.find(a => a.startsWith('--wait='));
     if (arg === undefined)
@@ -41,6 +90,9 @@ async function handleResult(args) {
     const waitSeconds = parseWaitSeconds(args);
     const taskId = args.find(a => !a.startsWith('--'));
     const repo = new repository_1.TaskRepository();
+    const initialReaped = repo.reapOrphanedTasks({ tickIntervalMs: REAP_INTERVAL_MS });
+    if (initialReaped > 0)
+        console.error(`Reaped ${initialReaped} orphaned task(s)`);
     if (!taskId) {
         const all = repo.getAllTasks();
         const recent = all.slice(0, 10);
@@ -61,6 +113,8 @@ async function handleResult(args) {
             console.log('');
         });
         console.log('Tip: Run `crewx result <task-id>` to see full output.');
+        if (!jsonMode)
+            writeResultCalFooter(recent[0]);
         return;
     }
     let task = repo.getTask(taskId);
@@ -69,15 +123,25 @@ async function handleResult(args) {
         process.exit(1);
         return;
     }
-    if (waitSeconds !== undefined && waitSeconds > 0 && task.status === 'running') {
+    if (waitSeconds !== undefined && waitSeconds > 0 && isActiveStatus(task.status)) {
         const deadline = Date.now() + waitSeconds * 1000;
-        while (task && task.status === 'running') {
+        let lastReapAt = Date.now();
+        while (task && isActiveStatus(task.status)) {
             if (Date.now() >= deadline) {
-                console.error(`Task ${taskId} did not complete within --wait=${waitSeconds}s (status: running).`);
+                console.error(`Task ${taskId} is still ${task.status} (waited ${waitSeconds}s; ` +
+                    `running for ${formatRuntimeDuration(task.started_at)}). ` +
+                    'Not stalled — check again with a longer wait.');
+                writeResultCalFooter(task, waitSeconds);
                 process.exit(124);
                 return;
             }
             await sleep(Math.min(POLL_INTERVAL_MS, Math.max(0, deadline - Date.now())));
+            if (Date.now() - lastReapAt >= REAP_INTERVAL_MS) {
+                const reaped = repo.reapOrphanedTasks({ tickIntervalMs: REAP_INTERVAL_MS });
+                if (reaped > 0)
+                    console.error(`Reaped ${reaped} orphaned task(s)`);
+                lastReapAt = Date.now();
+            }
             task = repo.getTask(taskId);
             if (!task) {
                 console.error(`Error: Task not found: ${taskId}`);
@@ -90,16 +154,49 @@ async function handleResult(args) {
         console.log(JSON.stringify(task, null, 2));
         return;
     }
+    if (task.status === 'pending') {
+        console.error(`🕓 Task ${taskId} is pending (waiting to start — runner has not adopted the task yet).`);
+        const nextWaitSeconds = (0, cal_1.suggestWaitSeconds)({
+            startedAt: task.started_at,
+            lastWaitSeconds: waitSeconds,
+        });
+        console.error(`Use \`crewx result ${taskId} --wait=${nextWaitSeconds}\` to wait for completion.`);
+        writeResultCalFooter(task, waitSeconds);
+        process.exit(1);
+        return;
+    }
     if (task.status === 'running') {
         console.error(`Task ${taskId} is still running.`);
-        console.error(`Use \`crewx kill ${taskId}\` to stop it.`);
+        const nextWaitSeconds = (0, cal_1.suggestWaitSeconds)({
+            startedAt: task.started_at,
+            lastWaitSeconds: waitSeconds,
+        });
+        console.error(`Use \`crewx result ${taskId} --wait=${nextWaitSeconds}\` to wait longer or \`crewx log ${taskId}\` to inspect progress.`);
+        writeResultCalFooter(task, waitSeconds);
+        process.exit(1);
+        return;
+    }
+    if (task.status === 'stopped') {
+        if (task.result !== null && task.result !== undefined) {
+            console.log(task.result);
+        }
+        console.error(`⏹ Task ${taskId} was stopped by user: ${task.error ?? 'no further details'}.`);
+        writeResultCalFooter(task);
+        process.exit(1);
+        return;
+    }
+    if (task.status === 'runner_lost') {
+        console.error(`⚠️ Task ${taskId} runner lost before completion: ${task.error ?? 'no further details'}.`);
+        writeResultCalFooter(task);
         process.exit(1);
         return;
     }
     if (task.status === 'failed') {
         console.error(`Task ${taskId} failed: ${task.error ?? 'unknown error'}`);
+        writeResultCalFooter(task);
         process.exit(1);
         return;
     }
     console.log(task.result ?? '');
+    writeResultCalFooter(task);
 }