@crewx/cli 0.9.0-rc.14 → 0.9.0-rc.141

package/dist/commands/execute.js

@@ -4,58 +4,125 @@
  * Parses args, loads config via Crewx SDK, and executes the task.
  *
  * Flags:
+ *   --to <agent>             Explicit recipient (the positional @agent form is shorthand)
  *   --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)
  *   --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)
+ *   -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 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_recipient_1 = require("./resolve-recipient");
 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");
+// 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.
  *
  * Default output: raw agent response only (stdout).
  * --verbose: debug info written to stderr, response to stdout.
  */
-async function handleExecute(args) {
-    const { thread, provider, metadata, verbose, config, outputFormat, effort, promptFile, overdrive, vars, out, 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)
-    const agentRef = parsedAgentRef || '@crewx';
-    // Resolve final prompt: argv | stdin pipe | --prompt-file (or combination)
-    const finalMessage = await (0, resolve_prompt_1.resolvePrompt)(message, promptFile);
+async function handleExecute(args, command = 'execute', 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, args);
+        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, to } = 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;
+    }
+    let agentRef;
+    try {
+        ({ agentRef } = (0, resolve_recipient_1.resolveRecipient)({
+            positionalRef: parsedAgentRef,
+            toFlag: to,
+            agentContext: Boolean(process.env['CREWX_AGENT_ID']),
+            bodyForHint: finalMessage,
+            command,
+            invocationArgs: args,
+        }));
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`Error: ${message}\n`);
+        (0, emit_trailer_1.emitDelegationResult)({ command, trace: inheritedTrace, isError: true, state: emitState });
+        process.exit(2);
+        return;
+    }
     if (!finalMessage) {
-        console.error('Usage: crewx execute [@agent] <task> [options]');
-        console.error('       crewx x [@agent] <task> [options]');
+        console.error('Usage: crewx execute --to <agent> <task> [options]');
+        console.error('       crewx x --to <agent> <task> [options]');
+        console.error('  Human-terminal shorthand: crewx x "@agent <task>"');
         console.error('');
-        console.error('  @agent is optional. Defaults to @crewx when omitted.');
+        console.error('  Agent calls require --to or a positional @agent recipient.');
+        console.error('  Human terminal and cron calls default to @crewx when omitted.');
         console.error('  Task body can also be supplied via stdin pipe or --prompt-file.');
         console.error('');
         console.error('Examples:');
-        console.error('  crewx x "@agent do something"');
-        console.error('  cat task.md | crewx x "@agent label"');
-        console.error('  crewx x "@agent label" --prompt-file=task.md');
+        console.error('  crewx x --to agent "do something"');
+        console.error('  crewx x --to agent -f task.md');
+        console.error('  Prompt files contain only the body; set the recipient separately with --to.');
         console.error('');
         console.error('Options:');
+        console.error('  --to <agent>              Explicit agent recipient');
         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.');
@@ -63,30 +130,43 @@ async function handleExecute(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 task body from file');
+        console.error('  -f/--prompt-file <path>   Read body only from file; set recipient separately with --to');
         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)
             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 = {};
@@ -96,50 +176,119 @@ async function handleExecute(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 x` 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.execute(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 ?? 'Execute failed';
-            console.error(errMsg);
-            (0, write_output_1.appendError)(out, errMsg);
+        try {
+            result = await crewx.execute(agentRef, finalMessage, {
+                provider,
+                model,
+                effort: effort || undefined,
+                overdrive: overdrive || undefined,
+                threadId: thread,
+                taskId: selfTaskId,
+                actor: selfTaskId === 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 ?? 'Execute 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✅ Execute 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();
             }
-            (0, write_output_1.writeResult)(out, result.data);
-            if (verbose) {
-                process.stderr.write('\n✅ Execute 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}`);
-        (0, write_output_1.appendError)(out, `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/hook/command-marker.d.ts

@@ -0,0 +1,2 @@
+/** Match only commands that invoke CrewX's hook-dispatch subcommand. */
+export declare const CREWX_HOOK_COMMAND_RE: RegExp;

package/dist/commands/hook/command-marker.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CREWX_HOOK_COMMAND_RE = void 0;
+/** Match only commands that invoke CrewX's hook-dispatch subcommand. */
+exports.CREWX_HOOK_COMMAND_RE = /crewx(?:\.js|\.cmd|\.exe)?['"]?\s+hook-dispatch\b/i;

package/dist/commands/hook/install.d.ts

@@ -10,7 +10,6 @@
  *   - Never traverses parent directories — project root determined by crewx.yaml
  */
 import { type HookProvider } from './paths';
-export declare const CREWX_HOOK_COMMAND_MARKER = "crewx hook-dispatch";
 export declare function resolveCrewxBinary(): string;
 export interface HookInstallOpts {
     projectRoot: string;

package/dist/commands/hook/install.js

@@ -10,49 +10,14 @@
  *   - Preserves existing user hooks
  *   - Never traverses parent directories — project root determined by crewx.yaml
  */
-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.CREWX_HOOK_COMMAND_MARKER = void 0;
 exports.resolveCrewxBinary = resolveCrewxBinary;
 exports.handleHookInstall = handleHookInstall;
 const fs_1 = require("fs");
-const path_1 = require("path");
-const cp = __importStar(require("child_process"));
+const sdk_1 = require("@crewx/sdk");
 const paths_1 = require("./paths");
-exports.CREWX_HOOK_COMMAND_MARKER = 'crewx hook-dispatch';
-function getProviderConfigs(projectRoot, providers, crewxBin) {
+const command_marker_1 = require("./command-marker");
+function getProviderConfigs(projectRoot, providers) {
     return providers.map((provider) => ({
         settingsPath: provider === 'claude'
             ? (0, paths_1.getClaudeSettingsPath)(projectRoot)
@@ -63,24 +28,30 @@ function getProviderConfigs(projectRoot, providers, crewxBin) {
     }));
 }
 function resolveCrewxBinary() {
-    if (process.env.CREWX_CLI)
-        return process.env.CREWX_CLI;
+    const resolution = (0, sdk_1.resolveCrewxExecutable)();
+    if (!resolution.ok) {
+        throw new Error((0, sdk_1.formatCrewxExecutableFailure)(resolution));
+    }
+    let stableEntrypoint;
     try {
-        const which = cp.execSync('which crewx 2>/dev/null', { encoding: 'utf8' }).trim();
-        const isTmpProxy = which.includes('/T/crewx-proxy-') ||
-            which.includes('/tmp/crewx-proxy-') ||
-            /\/[Tt]e?mp\//.test(which);
-        if (which && !isTmpProxy)
-            return which;
-    }
-    catch { }
-    if (process.argv[1]) {
-        const scriptPath = (0, path_1.resolve)(process.argv[1]);
-        if ((0, fs_1.existsSync)(scriptPath)) {
-            return `${process.execPath} ${scriptPath}`;
+        stableEntrypoint = (0, sdk_1.materializeCrewxStableEntrypoint)(resolution, { allowEnvStage: true });
+    }
+    catch (error) {
+        if (resolution.requiredEnv && Object.keys(resolution.requiredEnv).length > 0) {
+            throw new Error(`CrewX hook entrypoint could not preserve required environment: ${error instanceof Error ? error.message : String(error)}`);
         }
+        throw error;
+    }
+    if (stableEntrypoint) {
+        return (0, sdk_1.formatCrewxExecutableArgv)([stableEntrypoint]);
     }
-    return 'crewx';
+    // A required runtime environment cannot be represented by a raw argv string,
+    // and the fingerprint shim directory is doctor-GC managed. Refuse to write
+    // either representation when the stable hook path was not eligible.
+    if (resolution.requiredEnv && Object.keys(resolution.requiredEnv).length > 0) {
+        throw new Error('CrewX hook entrypoint could not preserve required environment: stable entrypoint is not eligible for this executable');
+    }
+    return (0, sdk_1.formatCrewxExecutableArgv)(resolution.argv);
 }
 function readSettingsTyped(settingsPath) {
     return (0, paths_1.readSettings)(settingsPath);
@@ -88,10 +59,19 @@ function readSettingsTyped(settingsPath) {
 function findCrewxEntry(preToolUse) {
     if (!preToolUse)
         return -1;
-    return preToolUse.findIndex((entry) => entry.hooks?.some((h) => h.command?.includes(exports.CREWX_HOOK_COMMAND_MARKER)));
+    return preToolUse.findIndex((entry) => entry.hooks?.some((h) => command_marker_1.CREWX_HOOK_COMMAND_RE.test(h.command)));
+}
+function findCrewxHook(entry) {
+    if (!entry.hooks)
+        return undefined;
+    const index = entry.hooks.findIndex((hook) => command_marker_1.CREWX_HOOK_COMMAND_RE.test(hook.command));
+    if (index < 0)
+        return undefined;
+    return { index, command: entry.hooks[index].command };
 }
 function installForProvider(projectRoot, config, crewxBin, yes) {
     const { settingsPath, provider, matcher, commandArg } = config;
+    const command = `${crewxBin} hook-dispatch ${commandArg}`;
     const settings = readSettingsTyped(settingsPath);
     if (!settings.hooks)
         settings.hooks = {};
@@ -99,8 +79,28 @@ function installForProvider(projectRoot, config, crewxBin, yes) {
         settings.hooks.PreToolUse = [];
     const existingIdx = findCrewxEntry(settings.hooks.PreToolUse);
     if (existingIdx >= 0) {
-        console.log(`[crewx] Hook already installed in ${settingsPath} (${provider})`);
-        return false;
+        const existingEntry = settings.hooks.PreToolUse[existingIdx];
+        const existingHook = findCrewxHook(existingEntry);
+        if (existingHook?.command === command) {
+            console.log(`[crewx] Hook already installed in ${settingsPath} (${provider})`);
+            return false;
+        }
+        if (!yes) {
+            console.log(`[crewx] Existing CrewX hook needs an install-path refresh in ${settingsPath} (${provider})`);
+            return false;
+        }
+        if ((0, fs_1.existsSync)(settingsPath)) {
+            const backupPath = settingsPath + '.crewx-backup';
+            (0, fs_1.copyFileSync)(settingsPath, backupPath);
+            console.log(`[crewx] Backup created: ${backupPath}`);
+        }
+        if (existingHook) {
+            existingEntry.hooks[existingHook.index] = { ...existingEntry.hooks[existingHook.index], command };
+        }
+        (0, fs_1.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+        console.log(`[crewx] Hook updated (${provider}): ${command}`);
+        console.log(`[crewx] Settings: ${settingsPath}`);
+        return true;
     }
     if (!yes) {
         console.log(`⚠️  crewx hook install will register crewx-hook-dispatch as a PreToolUse hook.\n` +
@@ -119,7 +119,6 @@ function installForProvider(projectRoot, config, crewxBin, yes) {
     else {
         (0, paths_1.ensureCodexHooks)(projectRoot);
     }
-    const command = `${crewxBin} hook-dispatch ${commandArg}`;
     settings.hooks.PreToolUse.push({
         matcher,
         hooks: [{ type: 'command', command }],
@@ -133,8 +132,15 @@ async function handleHookInstall(argsOrOpts) {
     if (!Array.isArray(argsOrOpts)) {
         const { projectRoot, yes, provider } = argsOrOpts;
         const providers = (0, paths_1.providersFromFilter)(provider ?? 'all');
-        const crewxBin = resolveCrewxBinary();
-        const configs = getProviderConfigs(projectRoot, providers, crewxBin);
+        let crewxBin;
+        try {
+            crewxBin = resolveCrewxBinary();
+        }
+        catch (error) {
+            console.error(`[crewx] ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+        const configs = getProviderConfigs(projectRoot, providers);
         for (const config of configs) {
             installForProvider(projectRoot, config, crewxBin, yes);
         }
@@ -152,8 +158,16 @@ async function handleHookInstall(argsOrOpts) {
     }
     const providerFilter = (0, paths_1.parseProviderArg)(args);
     const providers = (0, paths_1.providersFromFilter)(providerFilter);
-    const crewxBin = resolveCrewxBinary();
-    const configs = getProviderConfigs(projectRoot, providers, crewxBin);
+    let crewxBin;
+    try {
+        crewxBin = resolveCrewxBinary();
+    }
+    catch (error) {
+        console.error(`[crewx] ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+        return;
+    }
+    const configs = getProviderConfigs(projectRoot, providers);
     if (!yes) {
         const targets = configs.map((c) => `   - ${c.provider}: ${c.settingsPath}`).join('\n');
         console.log(`⚠️  crewx hook install will register crewx-hook-dispatch as a PreToolUse hook.\n` +

package/dist/commands/hook/status.js

@@ -11,7 +11,7 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const sdk_1 = require("@crewx/sdk");
 const paths_1 = require("./paths");
-const CREWX_HOOK_COMMAND_MARKER = 'crewx hook-dispatch';
+const command_marker_1 = require("./command-marker");
 function showProviderStatus(projectRoot, provider) {
     const settingsPath = provider === 'claude'
         ? (0, paths_1.getClaudeSettingsPath)(projectRoot)
@@ -26,9 +26,9 @@ function showProviderStatus(projectRoot, provider) {
     try {
         const settings = JSON.parse((0, fs_1.readFileSync)(settingsPath, 'utf8'));
         const preHooks = settings.hooks?.PreToolUse ?? [];
-        const crewxEntry = preHooks.find((entry) => entry.hooks?.some((h) => h.command?.includes(CREWX_HOOK_COMMAND_MARKER)));
+        const crewxEntry = preHooks.find((entry) => entry.hooks?.some((h) => command_marker_1.CREWX_HOOK_COMMAND_RE.test(h.command ?? '')));
         if (crewxEntry) {
-            const command = crewxEntry.hooks.find((h) => h.command?.includes(CREWX_HOOK_COMMAND_MARKER))?.command;
+            const command = crewxEntry.hooks.find((h) => command_marker_1.CREWX_HOOK_COMMAND_RE.test(h.command ?? ''))?.command;
             console.log(`    Status:   INSTALLED`);
             console.log(`    Command:  ${command}`);
         }

package/dist/commands/hook/uninstall.js

@@ -10,7 +10,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleHookUninstall = handleHookUninstall;
 const fs_1 = require("fs");
 const paths_1 = require("./paths");
-const CREWX_HOOK_COMMAND_MARKER = 'crewx hook-dispatch';
+const command_marker_1 = require("./command-marker");
 function getSettingsPath(projectRoot, provider) {
     return provider === 'claude'
         ? (0, paths_1.getClaudeSettingsPath)(projectRoot)
@@ -35,7 +35,7 @@ function uninstallFromProvider(projectRoot, provider) {
         return;
     }
     const before = settings.hooks.PreToolUse.length;
-    settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter((entry) => !entry.hooks?.some((h) => h.command?.includes(CREWX_HOOK_COMMAND_MARKER)));
+    settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter((entry) => !entry.hooks?.some((h) => command_marker_1.CREWX_HOOK_COMMAND_RE.test(h.command)));
     const removed = settings.hooks.PreToolUse.length < before;
     if (settings.hooks.PreToolUse.length === 0) {
         delete settings.hooks.PreToolUse;

package/dist/commands/init.d.ts

@@ -6,16 +6,48 @@
  *   crewx init                     Create crewx.yaml in current directory
  *   crewx init --force             Overwrite existing configuration
  */
+import { type ProviderAvailabilityDeps } from '@crewx/sdk';
+export type InitProvider = 'cli/claude' | 'cli/codex';
+type InitAgent = {
+    id: 'planner' | 'developer' | 'reviewer';
+    name: string;
+    role: string;
+    team: string;
+    provider: InitProvider;
+    working_directory: string;
+    description: string;
+    options: {
+        query: {
+            mode: string;
+            effort: string;
+        };
+        execute: {
+            mode: string;
+            effort: string;
+        };
+    };
+    inline: {
+        model: string;
+        prompt: string;
+    };
+};
+/** Build the three default agents using the selected CLI provider profile. */
+export declare function buildDefaultAgents(provider: InitProvider): InitAgent[];
 export interface InitResult {
     yamlCreated: boolean;
     hookInstalled: boolean;
     errors: string[];
+    provider: InitProvider;
     skippedReason?: 'yaml-exists';
     workspaceId?: string;
     slug?: string;
     statusLineConfigured?: boolean;
     statusLineSkipped?: boolean;
 }
+/** Parse the provider option accepted by `crewx init`. */
+export declare function parseInitProvider(args: readonly string[]): InitProvider | undefined;
+/** Resolve an explicit provider or detect Claude, then Codex, using PATH only. */
+export declare function resolveInitProvider(provider?: InitProvider, deps?: ProviderAvailabilityDeps): InitProvider;
 /**
  * Programmatic init — creates crewx.yaml, support dirs, and optionally installs hooks.
  * Throws on unrecoverable errors (PATH_NOT_FOUND, YAML_CREATE_FAILED).
@@ -27,4 +59,6 @@ export declare function handleInit(opts: {
     path: string;
     skipHook?: boolean;
     force?: boolean;
+    provider?: InitProvider;
 }): Promise<InitResult>;
+export {};