@crewx/cli 0.9.0-rc.9 → 0.9.0-rc.90

package/dist/commands/ps.js

@@ -34,9 +34,9 @@ function isAgyCommand(codingAgentCommand) {
     const base = firstToken.split('/').pop() ?? firstToken;
     return base.startsWith('agy');
 }
-function getLastActive(task) {
+function getLastActive(task, taskRepo) {
     try {
-        const entries = task.logs ? JSON.parse(task.logs) : [];
+        const entries = taskRepo.readLogsTail(task.id, 1)?.entries ?? [];
         if (Array.isArray(entries) && entries.length > 0) {
             const lastEntry = entries[entries.length - 1];
             const ts = lastEntry?.timestamp;
@@ -59,9 +59,9 @@ function getLastActive(task) {
     }
     return { display: '—', isoTimestamp: null, logCapable: true };
 }
-function taskToRow(task) {
+function taskToRow(task, taskRepo) {
     const elapsed = formatElapsed(Date.now() - new Date(task.started_at).getTime());
-    const lastActive = getLastActive(task);
+    const lastActive = getLastActive(task, taskRepo);
     return [
         task.id,
         task.agent_id ?? '—',
@@ -83,6 +83,7 @@ function renderTable(headers, rows) {
 }
 async function handlePs(args) {
     const repo = new repository_1.TaskRepository();
+    repo.reapRunningWorkflowTasks();
     const tasks = repo.getRunningTasks();
     if (tasks.length === 0) {
         console.log('No running tasks.');
@@ -90,7 +91,7 @@ async function handlePs(args) {
     }
     if (args.includes('--json')) {
         const withLastActive = tasks.map((task) => {
-            const lastActive = getLastActive(task);
+            const lastActive = getLastActive(task, repo);
             return {
                 ...task,
                 last_active_at: lastActive.isoTimestamp,
@@ -101,7 +102,7 @@ async function handlePs(args) {
         return;
     }
     const headers = ['TASK ID', 'AGENT', 'PID', 'ELAPSED', 'MODE', 'LAST ACTIVE'];
-    const rows = tasks.map(taskToRow);
+    const rows = tasks.map((task) => taskToRow(task, repo));
     renderTable(headers, rows);
     console.log(`\n  ${tasks.length} running task(s)`);
 }

package/dist/commands/publish.d.ts

@@ -0,0 +1 @@
+export declare function handlePublish(args: string[]): Promise<void>;

package/dist/commands/publish.js

@@ -0,0 +1,290 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePublish = handlePublish;
+/**
+ * crewx publish handler — thin CLI wrapper over @crewx/sdk/publish.
+ *
+ * Usage:
+ *   crewx publish [dir] [--dry-run] [--version <semver>] [--json] [--upload]
+ *
+ * All scanning, exclusion-rule judgment, secret detection, hashing, and
+ * tar.gz packing lives in @crewx/sdk/publish (planPublish / packTemplate).
+ * Submit+upload (WI-SHR-20260806-013) lives in the same package
+ * (uploadToMarketplace) for the same reason — see that module's header.
+ * This command only parses argv, forwards options, asks the SDK SessionManager
+ * for a valid account bearer when upload is requested, and renders the result.
+ */
+const fs = __importStar(require("fs"));
+const account_1 = require("@crewx/sdk/account");
+const publish_1 = require("@crewx/sdk/publish");
+const parse_common_flags_1 = require("./parse-common-flags");
+function parsePublishFlags(args) {
+    const flags = { dryRun: false, json: false, help: false, upload: false };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--help' || arg === '-h') {
+            flags.help = true;
+            continue;
+        }
+        if (arg === '--dry-run') {
+            flags.dryRun = true;
+            continue;
+        }
+        if (arg === '--json') {
+            flags.json = true;
+            continue;
+        }
+        if (arg === '--upload') {
+            flags.upload = true;
+            continue;
+        }
+        if (arg === '--version') {
+            const value = args[i + 1];
+            if (value === undefined)
+                throw new parse_common_flags_1.UnknownOptionError('--version requires a value');
+            flags.version = value;
+            i++;
+            continue;
+        }
+        if (arg.startsWith('--version=')) {
+            flags.version = arg.slice('--version='.length);
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            throw new parse_common_flags_1.UnknownOptionError(`Unknown option: ${arg}`);
+        }
+        if (flags.dir === undefined) {
+            flags.dir = arg;
+            continue;
+        }
+        throw new parse_common_flags_1.UnknownOptionError(`Unknown option: ${arg}`);
+    }
+    return flags;
+}
+function resolveWorkspaceDir(flags) {
+    return flags.dir ?? process.env['CREWX_WORKSPACE'] ?? process.cwd();
+}
+function printJson(payload) {
+    console.log(JSON.stringify(payload));
+}
+/** Prints the error and exits 1. Never returns (matches `process.exit`'s `never` type). */
+function failWithError(err, json) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (json) {
+        printJson({ success: false, error: message });
+    }
+    else {
+        console.error(`✗ ${message}`);
+    }
+    process.exit(1);
+}
+function printHelp() {
+    console.log(`
+crewx publish — package a workspace as a distributable template archive
+
+Usage:
+  crewx publish [dir] [--dry-run] [--version <semver>] [--json] [--upload]
+
+Arguments:
+  dir              Workspace to publish (default: $CREWX_WORKSPACE or cwd)
+
+Options:
+  --dry-run        Scan + build manifest only; do not write a .tgz
+  --version <ver>  Override manifest version (semver, e.g. 1.0.0)
+  --json           Print machine-readable JSON to stdout
+  --upload         Submit + upload the packed archive to marketplace
+                    (requires CREWX_MARKETPLACE_URL and a prior login;
+                    ignored when combined with --dry-run)
+  --help, -h       Show this help
+
+Notes:
+  Without --upload, this command only scans the workspace, applies
+  exclusion rules, checks for secrets, and packs a local
+  .crewx/publish/<name>-<version>.tgz archive.
+`.trim());
+}
+/** CREWX_MARKETPLACE_URL — same env var name as the server's MARKETPLACE_DISABLED check, never a second name. */
+function requireMarketplaceUrl() {
+    const url = process.env['CREWX_MARKETPLACE_URL'];
+    if (!url?.trim()) {
+        throw new Error('publish: [E_ENV_MISSING] CREWX_MARKETPLACE_URL is not set — this environment variable is required for upload');
+    }
+    return url.trim();
+}
+function isMarketplaceUnauthorized(err) {
+    return err instanceof Error
+        && err.message.includes('publish: [E_AUTH_EXPIRED]')
+        && /HTTP 401\b/.test(err.message);
+}
+async function uploadWithSessionRefresh(sessionManager, options, accessToken) {
+    try {
+        return await (0, publish_1.uploadToMarketplace)({ ...options, accessToken });
+    }
+    catch (err) {
+        if (!isMarketplaceUnauthorized(err))
+            throw err;
+        const refreshedSession = await sessionManager.refresh();
+        return (0, publish_1.uploadToMarketplace)({ ...options, accessToken: refreshedSession.access_token });
+    }
+}
+async function handlePublish(args) {
+    const flags = parsePublishFlags(args);
+    if (flags.help) {
+        printHelp();
+        return;
+    }
+    const dir = resolveWorkspaceDir(flags);
+    process.stderr.write(`[publish] scanning ${dir}...\n`);
+    let plan;
+    try {
+        plan = await (0, publish_1.planPublish)(dir, { version: flags.version });
+    }
+    catch (err) {
+        failWithError(err, flags.json);
+    }
+    if (plan.secretFindings.length > 0) {
+        if (flags.json) {
+            printJson({ success: false, error: 'secret findings detected', findings: plan.secretFindings });
+        }
+        else {
+            console.error('✗ secret findings detected — publish aborted');
+            for (const f of plan.secretFindings) {
+                console.error(`  ${f.path}:${f.line} (${f.rule})`);
+            }
+        }
+        process.exit(1);
+    }
+    if (flags.dryRun) {
+        if (flags.json) {
+            printJson({
+                success: true,
+                dryRun: true,
+                workspace: dir,
+                manifest: plan.manifest,
+                included: plan.included,
+                excluded: plan.excluded,
+            });
+        }
+        else {
+            console.log('✓ dry-run — no archive written');
+            console.log(`  workspace: ${dir}`);
+            console.log(`  name: ${plan.manifest.name}  version: ${plan.manifest.version}`);
+            console.log(`  included: ${plan.included.length} files`);
+            console.log(`  excluded: ${plan.excluded.length} entries`);
+            for (const e of plan.excluded) {
+                console.log(`    ${e.path} (${e.rule})`);
+            }
+        }
+        return;
+    }
+    // Resolved before packing (not after) so a doomed --upload run (no
+    // marketplace url / no session) never writes a stray .tgz to the
+    // workspace — WI-SHR-20260806-013 AC-U5.
+    let marketplaceUrl = '';
+    let accessToken = '';
+    let sessionManager;
+    if (flags.upload) {
+        try {
+            marketplaceUrl = requireMarketplaceUrl();
+            sessionManager = new account_1.SessionManager({ authClient: new account_1.AuthClient() });
+            accessToken = await sessionManager.getAccessToken();
+        }
+        catch (err) {
+            if (err instanceof Error && !err.message.startsWith('publish: [')) {
+                failWithError(new Error(`publish: [E_AUTH_EXPIRED] Authentication is missing or expired — please log in again — ${err.message}`), flags.json);
+            }
+            failWithError(err, flags.json);
+        }
+    }
+    process.stderr.write(`[publish] packing ${plan.manifest.name}@${plan.manifest.version}...\n`);
+    let packed;
+    try {
+        packed = await (0, publish_1.packTemplate)(dir, { version: flags.version });
+    }
+    catch (err) {
+        failWithError(err, flags.json);
+    }
+    const fileCount = packed.manifest.files.length;
+    const totalBytes = fs.statSync(packed.tgzPath).size;
+    let uploadResult;
+    if (flags.upload) {
+        process.stderr.write(`[publish] uploading ${packed.manifest.name}@${packed.manifest.version} to ${marketplaceUrl}...\n`);
+        try {
+            if (!sessionManager)
+                throw new Error('publish: [E_AUTH_EXPIRED] Account session is unavailable');
+            uploadResult = await uploadWithSessionRefresh(sessionManager, {
+                tgzPath: packed.tgzPath,
+                manifest: packed.manifest,
+                baseUrl: marketplaceUrl,
+            }, accessToken);
+        }
+        catch (err) {
+            failWithError(err, flags.json);
+        }
+        process.stderr.write(`[publish] submit -> ${uploadResult.submitOutcome}\n`);
+    }
+    if (flags.json) {
+        printJson({
+            success: true,
+            tgzPath: packed.tgzPath,
+            fileCount,
+            totalBytes,
+            manifest: packed.manifest,
+            ...(uploadResult
+                ? {
+                    slug: uploadResult.slug,
+                    version: uploadResult.version,
+                    artifactChecksum: uploadResult.artifactChecksum,
+                    artifactSizeBytes: uploadResult.artifactSizeBytes,
+                    submitOutcome: uploadResult.submitOutcome,
+                    versionUpdate: uploadResult.versionUpdate,
+                    serverVersionBefore: uploadResult.serverVersionBefore,
+                }
+                : {}),
+        });
+    }
+    else {
+        console.log(`✓ packed: ${packed.tgzPath}`);
+        console.log(`  files: ${fileCount}  bytes: ${totalBytes}`);
+        if (uploadResult) {
+            console.log(`✓ uploaded: ${uploadResult.slug}@${uploadResult.version} (${uploadResult.submitOutcome})`);
+            console.log(`  artifactChecksum: ${uploadResult.artifactChecksum}  artifactSizeBytes: ${uploadResult.artifactSizeBytes}`);
+        }
+    }
+    if (!flags.upload) {
+        console.error('⚠ To upload, use --upload — check the generated file path');
+    }
+}

package/dist/commands/query.d.ts

@@ -5,6 +5,7 @@
  * Flags:
  *   --thread <name>          Conversation thread name
  *   --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)
@@ -18,10 +19,11 @@
  *   e.g. cat brief.md | crewx q "@agent label"
  *   Stdin is ignored when running in an interactive TTY.
  */
+import { type DelegationEmitState } from './emit-trailer';
 /**
  * Handle `crewx query <agentRef> <message>` command.
  *
  * Default output: raw agent response only (stdout).
  * --verbose: debug info written to stderr, response to stdout.
  */
-export declare function handleQuery(args: string[]): Promise<void>;
+export declare function handleQuery(args: string[], command?: string, emitState?: DelegationEmitState): Promise<void>;

package/dist/commands/query.js

@@ -6,6 +6,7 @@
  * Flags:
  *   --thread <name>          Conversation thread name
  *   --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)
@@ -27,19 +28,38 @@ 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 emit_trailer_1 = require("./emit-trailer");
 /**
  * Handle `crewx query <agentRef> <message>` command.
  *
  * Default output: raw agent response only (stdout).
  * --verbose: debug info written to stderr, response to stdout.
  */
-async function handleQuery(args) {
-    const { thread, provider, metadata, verbose, config, outputFormat, effort, promptFile, overdrive, vars, rest } = (0, parse_common_flags_1.parseCommonFlags)(args);
-    const { agentRef: parsedAgentRef, message } = (0, parse_agent_message_1.parseAgentMessage)(rest);
-    // No @mention → default to @crewx agent (matches cli-bak behaviour)
+async function handleQuery(args, command = 'query', emitState = (0, emit_trailer_1.createDelegationEmitState)()) {
+    let parsedFlags;
+    try {
+        parsedFlags = (0, parse_common_flags_1.parseCommonFlags)(args);
+    }
+    catch (err) {
+        (0, emit_trailer_1.emitDelegationResult)({ command, isError: true, state: emitState });
+        throw err;
+    }
+    const { thread, provider, model, metadata, verbose, config, outputFormat, effort, promptFile, overdrive, vars, out, rest } = parsedFlags;
+    const inheritedTrace = (0, inherited_trace_1.readInheritedTrace)();
+    let parsedAgentRef;
+    let message;
+    let finalMessage;
+    try {
+        ({ agentRef: parsedAgentRef, message } = (0, parse_agent_message_1.parseAgentMessage)(rest));
+        // Resolve final prompt: argv | stdin pipe | --prompt-file (or combination)
+        finalMessage = await (0, resolve_prompt_1.resolvePrompt)(message, promptFile);
+    }
+    catch (err) {
+        (0, emit_trailer_1.emitDelegationResult)({ command, trace: inheritedTrace, isError: true, state: emitState });
+        throw err;
+    }
     const agentRef = parsedAgentRef || '@crewx';
-    // Resolve final prompt: argv | stdin pipe | --prompt-file (or combination)
-    const finalMessage = await (0, resolve_prompt_1.resolvePrompt)(message, promptFile);
     if (!finalMessage) {
         console.error('Usage: crewx query [@agent] <message> [options]');
         console.error('       crewx q [@agent] <message> [options]');
@@ -55,6 +75,7 @@ async function handleQuery(args) {
         console.error('Options:');
         console.error('  --thread <name>           Conversation thread name');
         console.error('  --provider <cli/xxx>      Provider override');
+        console.error('  --model <name>            Model override (e.g. claude-sonnet-5)');
         console.error('  --metadata <json>         Extra metadata (JSON object, double-quoted).');
         console.error('                            Propagated to events/hooks/tracing.');
         console.error('                            Invalid JSON aborts with exit code 2.');
@@ -62,16 +83,26 @@ async function handleQuery(args) {
         console.error('  --verbose                 Debug output mode');
         console.error('  --config/-c <path>        Config file path');
         console.error('  --output-format <fmt>     Output format (json|text|stream-json)');
+        console.error('  --out/-o <path>           Save result to file (stdout suppressed)');
         console.error('  --effort <level>          Model effort (high|medium|low)');
         console.error('  -f/--prompt-file <path>   Read prompt body from file');
         console.error('  --var key=value           Template variable (repeatable)');
         console.error('  --overdrive               Activate overdrive (boost) profile for this request');
+        (0, emit_trailer_1.emitDelegationResult)({ command, trace: inheritedTrace, isError: true, state: emitState });
         process.exit(1);
+        return;
     }
     const configPath = config ?? process.env.CREWX_CONFIG ?? 'crewx.yaml';
     // Only show exec audit span JSON in verbose mode
     (0, sdk_1.setAuditVerbose)(verbose);
-    const crewx = await (0, crewx_cli_1.createCliCrewx)(configPath);
+    let crewx;
+    try {
+        crewx = await (0, crewx_cli_1.createCliCrewx)(configPath);
+    }
+    catch (err) {
+        (0, emit_trailer_1.emitDelegationResult)({ command, trace: inheritedTrace, isError: true, state: emitState });
+        throw err;
+    }
     // file:// remote agent delegation is handled transparently inside Crewx.query/execute.
     if (verbose) {
         process.stderr.write(`📋 Task: ${finalMessage}\n`);
@@ -80,6 +111,8 @@ async function handleQuery(args) {
             process.stderr.write(`🔗 Thread: ${thread}\n`);
         if (provider)
             process.stderr.write(`🔌 Provider: ${provider}\n`);
+        if (model)
+            process.stderr.write(`🧠 Model: ${model}\n`);
         if (outputFormat)
             process.stderr.write(`📄 Output-format: ${outputFormat}\n`);
         if (effort)
@@ -95,22 +128,34 @@ async function handleQuery(args) {
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         process.stderr.write(`Error: ${msg}\n`);
+        (0, emit_trailer_1.emitDelegationResult)({ command, trace: inheritedTrace, isError: true, state: emitState });
         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;
     let exitCode = 0;
+    let result;
     try {
-        const result = await crewx.query(agentRef, finalMessage, {
+        result = await crewx.query(agentRef, finalMessage, {
             provider,
+            model,
             effort: effort || undefined,
             overdrive: overdrive || undefined,
             threadId: thread,
+            taskId: selfTaskId,
             metadata: Object.keys(parsedMetadata).length > 0 ? parsedMetadata : undefined,
             vars: Object.keys(vars).length > 0 ? vars : undefined,
-            trace: (0, inherited_trace_1.readInheritedTrace)(),
+            trace: inheritedTrace,
         });
         if (!result.ok) {
             const errMsg = result.error?.message ?? 'Query failed';
             console.error(errMsg);
+            (0, write_output_1.appendError)(out, errMsg);
             exitCode = 1;
         }
         else {
@@ -123,7 +168,7 @@ async function handleQuery(args) {
                 process.stderr.write('\n📄 Response:\n');
                 process.stderr.write('─'.repeat(40) + '\n');
             }
-            console.log(result.data);
+            (0, write_output_1.writeResult)(out, result.data);
             if (verbose) {
                 process.stderr.write('\n✅ Query completed successfully\n');
             }
@@ -132,11 +177,33 @@ async function handleQuery(args) {
     catch (err) {
         const errMsg = err instanceof Error ? err.message : String(err);
         console.error(`Error: ${errMsg}`);
+        (0, write_output_1.appendError)(out, `Error: ${errMsg}`);
         exitCode = 1;
     }
     finally {
-        await crewx.close();
+        try {
+            await crewx.close();
+        }
+        catch (err) {
+            (0, emit_trailer_1.emitDelegationResult)({
+                command,
+                trace: inheritedTrace,
+                taskId: result?.meta.taskId,
+                agentId: result?.meta.agentId,
+                isError: true,
+                state: emitState,
+            });
+            throw err;
+        }
     }
+    (0, emit_trailer_1.emitDelegationResult)({
+        command,
+        trace: inheritedTrace,
+        taskId: result?.meta.taskId,
+        agentId: result?.meta.agentId,
+        isError: exitCode !== 0 || result?.ok === false,
+        state: emitState,
+    });
     if (exitCode !== 0)
         process.exit(exitCode);
 }

package/dist/commands/registry.js

@@ -17,13 +17,15 @@ exports.KNOWN_COMMANDS = new Set([
     'doctor', 'init',
     'db',
     'help',
+    'shortcut',
+    'publish',
     'slack', 'slack:files',
     'hook', 'hook-dispatch',
 ]);
 /** Built-in tool commands routed via handleBuiltin(). */
 exports.BUILTIN_COMMAND_NAMES = new Set([
     'memory', 'search', 'doc', 'wbs', 'cron', 'workflow', 'skill', 'dreaming',
-    'wi', 'chromex',
+    'wi', 'chromex', 'notify',
 ]);
 /** Commands not yet migrated from cli-bak — show a migration message. */
 exports.NOT_YET_MIGRATED = new Set([

package/dist/commands/result.d.ts

@@ -3,8 +3,12 @@
  * Retrieves the result of a completed task by its ID.
  *
  * Usage:
- *   crewx result <task-id>         Print raw result
- *   crewx result <task-id> --json  Print full task record as JSON
- *   crewx result                   List recent tasks (latest 10)
+ *   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
+ *                                    timeout. --wait=0 behaves like no --wait
+ *                                    (single immediate check).
+ *   crewx result                      List recent tasks (latest 10)
  */
 export declare function handleResult(args: string[]): Promise<void>;

package/dist/commands/result.js

@@ -4,13 +4,19 @@
  * Retrieves the result of a completed task by its ID.
  *
  * Usage:
- *   crewx result <task-id>         Print raw result
- *   crewx result <task-id> --json  Print full task record as JSON
- *   crewx result                   List recent tasks (latest 10)
+ *   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
+ *                                    timeout. --wait=0 behaves like no --wait
+ *                                    (single immediate check).
+ *   crewx result                      List recent tasks (latest 10)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleResult = handleResult;
+const sdk_1 = require("@crewx/sdk");
 const repository_1 = require("@crewx/sdk/repository");
+const POLL_INTERVAL_MS = 1000;
 function statusIcon(status) {
     switch (status) {
         case 'running': return '⏳';
@@ -19,8 +25,20 @@ function statusIcon(status) {
         default: return '❓';
     }
 }
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Parses `--wait=N` (seconds). Returns undefined when the flag is absent. */
+function parseWaitSeconds(args) {
+    const arg = args.find(a => a.startsWith('--wait='));
+    if (arg === undefined)
+        return undefined;
+    const n = Number(arg.slice('--wait='.length));
+    return Number.isFinite(n) && n >= 0 ? n : 0;
+}
 async function handleResult(args) {
     const jsonMode = args.includes('--json');
+    const waitSeconds = parseWaitSeconds(args);
     const taskId = args.find(a => !a.startsWith('--'));
     const repo = new repository_1.TaskRepository();
     if (!taskId) {
@@ -36,21 +54,38 @@ async function handleResult(args) {
             const icon = statusIcon(task.status);
             console.log(`${idx + 1}. ${icon} ${task.id}`);
             console.log(`   Agent: ${task.agent_id ?? '—'}  Mode: ${task.mode ?? '—'}`);
-            console.log(`   Started: ${new Date(task.started_at).toLocaleString()}`);
+            console.log(`   Started: ${(0, sdk_1.formatDisplayTimestamp)(new Date(task.started_at))}`);
             if (task.completed_at) {
-                console.log(`   Completed: ${new Date(task.completed_at).toLocaleString()}`);
+                console.log(`   Completed: ${(0, sdk_1.formatDisplayTimestamp)(new Date(task.completed_at))}`);
             }
             console.log('');
         });
         console.log('Tip: Run `crewx result <task-id>` to see full output.');
         return;
     }
-    const task = repo.getTask(taskId);
+    let task = repo.getTask(taskId);
     if (!task) {
         console.error(`Error: Task not found: ${taskId}`);
         process.exit(1);
         return;
     }
+    if (waitSeconds !== undefined && waitSeconds > 0 && task.status === 'running') {
+        const deadline = Date.now() + waitSeconds * 1000;
+        while (task && task.status === 'running') {
+            if (Date.now() >= deadline) {
+                console.error(`Task ${taskId} did not complete within --wait=${waitSeconds}s (status: running).`);
+                process.exit(124);
+                return;
+            }
+            await sleep(Math.min(POLL_INTERVAL_MS, Math.max(0, deadline - Date.now())));
+            task = repo.getTask(taskId);
+            if (!task) {
+                console.error(`Error: Task not found: ${taskId}`);
+                process.exit(1);
+                return;
+            }
+        }
+    }
     if (jsonMode) {
         console.log(JSON.stringify(task, null, 2));
         return;

package/dist/commands/shortcut.d.ts

@@ -0,0 +1 @@
+export declare function handleShortcut(args: string[]): Promise<void>;