@crewx/cli 0.9.0-rc.12 → 0.9.0-rc.120

package/dist/commands/publish.js

@@ -0,0 +1,303 @@
+"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
+                    (uses the configured account target 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());
+}
+/** Resolve and validate the Marketplace target immediately before an upload. */
+function requireMarketplaceUrl() {
+    try {
+        const url = (0, account_1.resolveMarketplaceUrl)();
+        (0, account_1.assertAccountTargetNotMixed)();
+        return url;
+    }
+    catch (error) {
+        const code = typeof error === 'object' && error !== null && 'code' in error
+            ? error.code
+            : undefined;
+        if (code === 'ACCOUNT_TARGET_INVALID' ||
+            code === 'ACCOUNT_TARGET_MIXED' ||
+            code === 'MARKETPLACE_DISABLED' ||
+            code === 'MARKETPLACE_URL_INVALID') {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`publish: [${code}] ${message}`);
+        }
+        throw error;
+    }
+}
+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)
@@ -12,16 +13,19 @@
  *   --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.
  *   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)
@@ -13,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.
@@ -22,24 +25,63 @@
 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.
  *
  * 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)()) {
+    // 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)(receiptFlags.rest);
+    }
+    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 +97,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,24 +105,37 @@ 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(`mode=sync reason=${receiptMode.reason}\n`);
         process.stderr.write(`📋 Task: ${finalMessage}\n`);
         process.stderr.write(`🤖 Agent: ${agentRef}\n`);
         if (thread)
             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,48 +151,120 @@ 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;
+    }
+    const actor = (0, detached_1.resolveCliTaskActor)(parsedMetadata);
+    // 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;
+    let taskActor;
+    if (assignedTaskId !== undefined) {
+        const taskRepo = new repository_1.TaskRepository();
+        const adoption = (0, detached_1.adoptAssignedTask)(taskRepo, 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;
+            taskActor = (0, detached_1.readAssignedTaskActor)(taskRepo, adoption.taskId);
+        }
+    }
+    // A synchronous `crewx q` runs in this same process, but this process is
+    // still separate from the embedded server and never sees its in-memory
+    // UpdateGateService (WI-CTO-20260919-004 R2 finding #1) — only the durable
+    // marker it writes. Reserve-then-check before calling into the SDK below,
+    // not after; see admitDurableTask()'s own doc comment. Never checked for
+    // an adopted receipt (selfTaskId set): that work was already admitted by
+    // whichever process first created its pending DB row.
+    let admission;
+    if (selfTaskId === undefined) {
+        admission = (0, sdk_1.admitDurableTask)(`direct-cli:${command}`);
+        if (!admission.ok) {
+            (0, detached_1.reportAdmissionBlocked)(admission);
+            (0, emit_trailer_1.emitDelegationResult)({ command, trace: inheritedTrace, isError: true, state: emitState });
+            process.exit(1);
+            return;
+        }
     }
     let exitCode = 0;
+    let result;
     try {
-        const result = await crewx.query(agentRef, finalMessage, {
-            provider,
-            effort: effort || undefined,
-            overdrive: overdrive || undefined,
-            threadId: thread,
-            metadata: Object.keys(parsedMetadata).length > 0 ? parsedMetadata : undefined,
-            vars: Object.keys(vars).length > 0 ? vars : undefined,
-            trace: (0, inherited_trace_1.readInheritedTrace)(),
-        });
-        if (!result.ok) {
-            const errMsg = result.error?.message ?? 'Query failed';
-            console.error(errMsg);
+        try {
+            result = await crewx.query(agentRef, finalMessage, {
+                provider,
+                model,
+                effort: effort || undefined,
+                overdrive: overdrive || undefined,
+                threadId: thread,
+                taskId: selfTaskId,
+                actor: assignedTaskId === undefined ? actor : taskActor,
+                metadata: Object.keys(parsedMetadata).length > 0 ? parsedMetadata : undefined,
+                vars: Object.keys(vars).length > 0 ? vars : undefined,
+                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 {
+                if (verbose) {
+                    process.stderr.write(`\n📊 Results from ${agentRef}:\n`);
+                    process.stderr.write('═'.repeat(60) + '\n');
+                    process.stderr.write('🟢 Status: Success\n');
+                    process.stderr.write(`🤖 Provider: ${result.meta.provider}\n`);
+                    process.stderr.write(`⏱️  Duration: ${result.meta.durationMs}ms\n`);
+                    process.stderr.write('\n📄 Response:\n');
+                    process.stderr.write('─'.repeat(40) + '\n');
+                }
+                (0, write_output_1.writeResult)(out, result.data);
+                if (verbose) {
+                    process.stderr.write('\n✅ Query completed successfully\n');
+                }
+            }
+        }
+        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;
         }
-        else {
-            if (verbose) {
-                process.stderr.write(`\n📊 Results from ${agentRef}:\n`);
-                process.stderr.write('═'.repeat(60) + '\n');
-                process.stderr.write('🟢 Status: Success\n');
-                process.stderr.write(`🤖 Provider: ${result.meta.provider}\n`);
-                process.stderr.write(`⏱️  Duration: ${result.meta.durationMs}ms\n`);
-                process.stderr.write('\n📄 Response:\n');
-                process.stderr.write('─'.repeat(40) + '\n');
+        finally {
+            try {
+                await crewx.close();
             }
-            console.log(result.data);
-            if (verbose) {
-                process.stderr.write('\n✅ Query completed successfully\n');
+            catch (err) {
+                (0, emit_trailer_1.emitDelegationResult)({
+                    command,
+                    trace: inheritedTrace,
+                    taskId: result?.meta.taskId,
+                    agentId: result?.meta.agentId,
+                    isError: true,
+                    state: emitState,
+                });
+                throw err;
             }
         }
     }
-    catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
-        console.error(`Error: ${errMsg}`);
-        exitCode = 1;
-    }
     finally {
-        await crewx.close();
+        if (admission?.ok)
+            admission.release();
     }
+    (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

@@ -13,17 +13,19 @@ 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',
+    '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', 'app',
 ]);
 /** 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,13 @@
  * 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=<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)
  */
 export declare function handleResult(args: string[]): Promise<void>;