@crewx/cli 0.9.0-rc.7 → 0.9.0-rc.71

package/dist/bootstrap/codex-writable-roots.d.ts

@@ -0,0 +1,58 @@
+/**
+ * CLI-layer policy: inject CrewX home as an extra writable root for Codex
+ * `workspace-write` sandbox invocations.
+ *
+ * Why this lives in packages/cli (not packages/sdk):
+ * CrewX home (`~/.crewx` by default) is a product-specific path. The SDK's
+ * `additionalArgsProvider` extension point (WI-20260703-001) exists precisely
+ * so that product layers like this CLI can inject such paths without the SDK
+ * knowing about them.
+ *
+ * Why `-c sandbox_workspace_write.writable_roots=[...]` instead of `--add-dir`:
+ * Verified against codex-cli 0.139.0 (`codex exec --help` / `codex exec resume --help`):
+ *   - `codex exec` supports `--add-dir <DIR>`.
+ *   - `codex exec resume` does NOT support `--add-dir` (only `-c/--config`).
+ * Using the `-c` config-override form works identically for both `exec` and
+ * `exec resume`, avoiding a resume-incompatible flag.
+ */
+import type { AdditionalArgsProvider } from '@crewx/sdk';
+/**
+ * Resolve CrewX home directory.
+ * Priority: `CREWX_HOME` env var → `~/.crewx`.
+ */
+export declare function resolveCrewxHome(): string;
+/**
+ * Escape a string for embedding inside a TOML basic string (`"..."`).
+ * Sufficient for filesystem paths: handles backslash (Windows paths),
+ * double-quote, and control characters that could otherwise break TOML
+ * parsing of the `-c key="value"` override.
+ */
+export declare function escapeTomlBasicString(value: string): string;
+/**
+ * Build the `-c sandbox_workspace_write.writable_roots=["<path>"]` arg pair.
+ * Works for both `codex exec` and `codex exec resume` (config-override form).
+ */
+export declare function buildCodexWritableRootArgs(crewxHome: string): string[];
+/**
+ * Create an `AdditionalArgsProvider` that skips Codex's git repository trust
+ * check for a resolved workspace.
+ *
+ * The workspace is resolved by the product layer, so an unavailable workspace
+ * must not fall back to the host cwd. The flag is independent of execution
+ * mode because it controls repository trust rather than filesystem access.
+ */
+export declare function createCodexSkipGitRepoCheckProvider(workspaceRoot: string | undefined): AdditionalArgsProvider;
+/**
+ * Compose product-layer argument providers while preserving their order.
+ */
+export declare function composeAdditionalArgsProviders(...providers: AdditionalArgsProvider[]): AdditionalArgsProvider;
+/**
+ * Create an `AdditionalArgsProvider` (SDK extension point, WI-20260703-001)
+ * that injects CrewX home as a Codex writable root for `workspace-write`
+ * equivalent modes (`agent`, `auto`, `undefined`).
+ *
+ * No-ops for:
+ *   - Non-codex providers.
+ *   - Modes in {@link NO_INJECT_MODES} (read-only/plan/agent-full-access/yolo/danger-full-access).
+ */
+export declare function createCodexWritableRootsProvider(crewxHome?: string): AdditionalArgsProvider;

package/dist/bootstrap/codex-writable-roots.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * CLI-layer policy: inject CrewX home as an extra writable root for Codex
+ * `workspace-write` sandbox invocations.
+ *
+ * Why this lives in packages/cli (not packages/sdk):
+ * CrewX home (`~/.crewx` by default) is a product-specific path. The SDK's
+ * `additionalArgsProvider` extension point (WI-20260703-001) exists precisely
+ * so that product layers like this CLI can inject such paths without the SDK
+ * knowing about them.
+ *
+ * Why `-c sandbox_workspace_write.writable_roots=[...]` instead of `--add-dir`:
+ * Verified against codex-cli 0.139.0 (`codex exec --help` / `codex exec resume --help`):
+ *   - `codex exec` supports `--add-dir <DIR>`.
+ *   - `codex exec resume` does NOT support `--add-dir` (only `-c/--config`).
+ * Using the `-c` config-override form works identically for both `exec` and
+ * `exec resume`, avoiding a resume-incompatible flag.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCrewxHome = resolveCrewxHome;
+exports.escapeTomlBasicString = escapeTomlBasicString;
+exports.buildCodexWritableRootArgs = buildCodexWritableRootArgs;
+exports.createCodexSkipGitRepoCheckProvider = createCodexSkipGitRepoCheckProvider;
+exports.composeAdditionalArgsProviders = composeAdditionalArgsProviders;
+exports.createCodexWritableRootsProvider = createCodexWritableRootsProvider;
+const os_1 = require("os");
+const path_1 = require("path");
+/**
+ * crewx.yaml / query-option `mode` values for which Codex is NOT running in
+ * (or being pushed into) a `workspace-write`-equivalent sandbox. Injecting an
+ * extra writable root is meaningless (read-only/plan) or redundant
+ * (full-access variants already allow writes everywhere) in these modes.
+ */
+const NO_INJECT_MODES = new Set([
+    'read-only',
+    'plan',
+    'agent-full-access',
+    'yolo',
+    'danger-full-access',
+]);
+/**
+ * Resolve CrewX home directory.
+ * Priority: `CREWX_HOME` env var → `~/.crewx`.
+ */
+function resolveCrewxHome() {
+    return process.env.CREWX_HOME ?? (0, path_1.join)((0, os_1.homedir)(), '.crewx');
+}
+/**
+ * Escape a string for embedding inside a TOML basic string (`"..."`).
+ * Sufficient for filesystem paths: handles backslash (Windows paths),
+ * double-quote, and control characters that could otherwise break TOML
+ * parsing of the `-c key="value"` override.
+ */
+function escapeTomlBasicString(value) {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t');
+}
+/**
+ * Build the `-c sandbox_workspace_write.writable_roots=["<path>"]` arg pair.
+ * Works for both `codex exec` and `codex exec resume` (config-override form).
+ */
+function buildCodexWritableRootArgs(crewxHome) {
+    const escaped = escapeTomlBasicString(crewxHome);
+    return ['-c', `sandbox_workspace_write.writable_roots=["${escaped}"]`];
+}
+function isCodexProvider(ctx) {
+    return ctx.providerId === 'codex' || ctx.providerStr === 'cli/codex';
+}
+/**
+ * Create an `AdditionalArgsProvider` that skips Codex's git repository trust
+ * check for a resolved workspace.
+ *
+ * The workspace is resolved by the product layer, so an unavailable workspace
+ * must not fall back to the host cwd. The flag is independent of execution
+ * mode because it controls repository trust rather than filesystem access.
+ */
+function createCodexSkipGitRepoCheckProvider(workspaceRoot) {
+    return (ctx) => {
+        if (!isCodexProvider(ctx))
+            return [];
+        if (!workspaceRoot)
+            return [];
+        return ['--skip-git-repo-check'];
+    };
+}
+/**
+ * Compose product-layer argument providers while preserving their order.
+ */
+function composeAdditionalArgsProviders(...providers) {
+    return (ctx) => providers.flatMap((provider) => provider(ctx));
+}
+/**
+ * Create an `AdditionalArgsProvider` (SDK extension point, WI-20260703-001)
+ * that injects CrewX home as a Codex writable root for `workspace-write`
+ * equivalent modes (`agent`, `auto`, `undefined`).
+ *
+ * No-ops for:
+ *   - Non-codex providers.
+ *   - Modes in {@link NO_INJECT_MODES} (read-only/plan/agent-full-access/yolo/danger-full-access).
+ */
+function createCodexWritableRootsProvider(crewxHome = resolveCrewxHome()) {
+    return (ctx) => {
+        if (!isCodexProvider(ctx))
+            return [];
+        if (ctx.mode !== undefined && NO_INJECT_MODES.has(ctx.mode))
+            return [];
+        return buildCodexWritableRootArgs(crewxHome);
+    };
+}

package/dist/bootstrap/crewx-cli.js

@@ -9,6 +9,7 @@ const plugins_1 = require("@crewx/sdk/plugins");
 const repository_1 = require("@crewx/sdk/repository");
 const register_builtin_tools_1 = require("../register-builtin-tools");
 const version_1 = require("../utils/version");
+const codex_writable_roots_1 = require("./codex-writable-roots");
 /**
  * Build a Crewx instance with CLI-standard plugins (FileLogger + SqliteTracing)
  * and built-in tools registered. Use this from any CLI command that needs a
@@ -39,6 +40,7 @@ async function createCliCrewx(configPath = process.env.CREWX_CONFIG ?? 'crewx.ya
     else {
         yamlPath = undefined;
     }
+    const skipRoot = yamlPath !== undefined ? (0, path_1.dirname)(absConfigPath) : undefined;
     // Run drizzle migrations once at bootstrap — plugin relies on this guarantee.
     const dbDir = (0, path_1.join)((0, os_1.homedir)(), '.crewx');
     (0, fs_1.mkdirSync)(dbDir, { recursive: true });
@@ -52,6 +54,7 @@ async function createCliCrewx(configPath = process.env.CREWX_CONFIG ?? 'crewx.ya
     }
     const crewx = await sdk_1.Crewx.loadYaml(yamlPath, {
         remoteFactory: createCliCrewx,
+        additionalArgsProvider: (0, codex_writable_roots_1.composeAdditionalArgsProviders)((0, codex_writable_roots_1.createCodexWritableRootsProvider)(), (0, codex_writable_roots_1.createCodexSkipGitRepoCheckProvider)(skipRoot)),
     });
     (0, register_builtin_tools_1.registerBuiltinToolsIfNeeded)(crewx);
     await crewx.use(new plugins_1.ConversationPlugin());

package/dist/builtin.js

@@ -55,6 +55,7 @@ const BUILTIN_MAP = {
     dreaming: () => Promise.resolve().then(() => __importStar(require('@crewx/dreaming/cli'))),
     wi: () => Promise.resolve().then(() => __importStar(require('@crewx/wi/cli'))),
     chromex: () => Promise.resolve().then(() => __importStar(require('@crewx/chromex/cli'))),
+    notify: () => Promise.resolve().then(() => __importStar(require('@crewx/notify/cli'))),
 };
 exports.BUILTIN_COMMANDS = new Set(Object.keys(BUILTIN_MAP));
 // Load skill-tracer for observability (graceful degradation if unavailable)

package/dist/commands/db.d.ts

@@ -6,4 +6,5 @@
  *   crewx db push --force        Apply without confirmation + reset migration history
  *   crewx db push --dry-run      Show preview only, no changes
  */
+export declare const TASK_LOG_MIGRATION_HELP = "Usage:\n  crewx db migrate-task-logs --dry-run [--db PATH]\n  crewx db migrate-task-logs --apply [--db PATH] [--batch-tasks N]\n  crewx db migrate-task-logs --verify [--db PATH]\n\nModes:\n  --dry-run  Read and validate legacy blobs without writing or creating a backup.\n  --apply    Create a consistent SQLite backup, then migrate one task per transaction.\n  --verify   Check source invariants, event sequences, counts, and orphan rows.\n\nApply policy:\n  Only blob tasks with status success, failed, or completed are migrated.\n  pending, running, paused, and unknown statuses are deferred for a later run.\n  There is no --force or --include-active option. Apply requires the estimated\n  database/event growth plus a 10 GiB free-space reserve.\n\nExit codes:\n  0  Completed with no malformed rows or invariant failures.\n  1  Safe tasks completed but a row/invariant failed, or apply was blocked.\n  2  Invalid command-line arguments.\n\nThe command never runs automatically at server startup and never runs VACUUM.";
 export declare function handleDb(args: string[]): Promise<void>;

package/dist/commands/db.js

@@ -11,12 +11,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_LOG_MIGRATION_HELP = void 0;
 exports.handleDb = handleDb;
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const readline_1 = __importDefault(require("readline"));
 const repository_1 = require("@crewx/sdk/repository");
 const repository_2 = require("@crewx/sdk/repository");
+const repository_3 = require("@crewx/sdk/repository");
+exports.TASK_LOG_MIGRATION_HELP = `Usage:
+  crewx db migrate-task-logs --dry-run [--db PATH]
+  crewx db migrate-task-logs --apply [--db PATH] [--batch-tasks N]
+  crewx db migrate-task-logs --verify [--db PATH]
+
+Modes:
+  --dry-run  Read and validate legacy blobs without writing or creating a backup.
+  --apply    Create a consistent SQLite backup, then migrate one task per transaction.
+  --verify   Check source invariants, event sequences, counts, and orphan rows.
+
+Apply policy:
+  Only blob tasks with status success, failed, or completed are migrated.
+  pending, running, paused, and unknown statuses are deferred for a later run.
+  There is no --force or --include-active option. Apply requires the estimated
+  database/event growth plus a 10 GiB free-space reserve.
+
+Exit codes:
+  0  Completed with no malformed rows or invariant failures.
+  1  Safe tasks completed but a row/invariant failed, or apply was blocked.
+  2  Invalid command-line arguments.
+
+The command never runs automatically at server startup and never runs VACUUM.`;
 function defaultDbPath() {
     return path_1.default.join(os_1.default.homedir(), '.crewx', 'crewx.db');
 }
@@ -57,6 +81,12 @@ function formatPreview(result, dbPath) {
 function hasChanges(result) {
     return result.created.length > 0 || result.altered.length > 0;
 }
+function formatStatusCounts(counts) {
+    const entries = Object.entries(counts ?? {});
+    return entries.length > 0
+        ? entries.map(([status, count]) => `${status}=${count}`).join(', ')
+        : '(none)';
+}
 function prompt(question) {
     const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
     return new Promise((resolve) => {
@@ -68,13 +98,173 @@ function prompt(question) {
 }
 async function handleDb(args) {
     const subcommand = args[0];
+    if (subcommand === 'migrate-task-logs') {
+        await handleTaskLogMigration(args.slice(1));
+        return;
+    }
+    if (subcommand === '--help' || subcommand === '-h') {
+        console.log('Usage: crewx db push [--force] [--dry-run]');
+        console.log(exports.TASK_LOG_MIGRATION_HELP);
+        return;
+    }
     if (!subcommand || subcommand === 'push') {
         await handleDbPush(args.slice(subcommand === 'push' ? 1 : 0));
         return;
     }
     console.error(`Unknown db subcommand: ${subcommand}`);
     console.error('Usage: crewx db push [--force] [--dry-run]');
-    process.exit(1);
+    console.error(exports.TASK_LOG_MIGRATION_HELP);
+    process.exitCode = 2;
+}
+class TaskLogMigrationUsageError extends Error {
+}
+function parseTaskLogMigrationArgs(args) {
+    let mode;
+    let dbPath;
+    let batchTasks;
+    const setMode = (next) => {
+        if (mode)
+            throw new TaskLogMigrationUsageError('Choose exactly one of --dry-run, --apply, or --verify.');
+        mode = next;
+    };
+    const requireValue = (args, index, flag) => {
+        const value = args[index + 1];
+        if (!value || value.startsWith('--'))
+            throw new TaskLogMigrationUsageError(`${flag} requires a value.`);
+        return value;
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--help' || arg === '-h') {
+            throw new TaskLogMigrationUsageError(exports.TASK_LOG_MIGRATION_HELP);
+        }
+        if (arg === '--dry-run') {
+            setMode('dry-run');
+            continue;
+        }
+        if (arg === '--apply') {
+            setMode('apply');
+            continue;
+        }
+        if (arg === '--verify') {
+            setMode('verify');
+            continue;
+        }
+        if (arg === '--db') {
+            dbPath = requireValue(args, index, '--db');
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--db=')) {
+            dbPath = arg.slice('--db='.length);
+            if (!dbPath)
+                throw new TaskLogMigrationUsageError('--db requires a value.');
+            continue;
+        }
+        if (arg === '--batch-tasks') {
+            const value = requireValue(args, index, '--batch-tasks');
+            const parsed = Number(value);
+            if (!Number.isSafeInteger(parsed) || parsed < 1) {
+                throw new TaskLogMigrationUsageError('--batch-tasks must be a positive integer.');
+            }
+            batchTasks = parsed;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--batch-tasks=')) {
+            const value = arg.slice('--batch-tasks='.length);
+            const parsed = Number(value);
+            if (!Number.isSafeInteger(parsed) || parsed < 1) {
+                throw new TaskLogMigrationUsageError('--batch-tasks must be a positive integer.');
+            }
+            batchTasks = parsed;
+            continue;
+        }
+        throw new TaskLogMigrationUsageError(`Unknown option: ${arg}`);
+    }
+    if (!mode)
+        throw new TaskLogMigrationUsageError('Choose one of --dry-run, --apply, or --verify.');
+    if (batchTasks !== undefined && mode !== 'apply') {
+        throw new TaskLogMigrationUsageError('--batch-tasks is only valid with --apply.');
+    }
+    return { mode, dbPath, batchTasks };
+}
+function formatMigrationReport(report) {
+    const modeLabel = report.mode === 'dry-run' ? 'Dry-run' : report.mode === 'apply' ? 'Apply' : 'Verify';
+    const lines = [
+        `[crewx] Task-log migration — ${modeLabel}`,
+        `  Database: ${report.dbPath}`,
+        `  Tasks scanned: ${report.taskCount}`,
+        `  Blob candidates: ${report.candidateTaskCount}`,
+        `  Eligible terminal blobs: ${report.eligibleTaskCount}`,
+        `  Status counts: ${formatStatusCounts(report.statusCounts)}`,
+        `  Deferred blob tasks: ${report.deferredTaskCount}`,
+        `  Deferred statuses: ${formatStatusCounts(report.deferredStatusCounts)}`,
+        `  Entries: ${report.entryCount}`,
+        `  Source bytes: ${report.sourceBytes}`,
+        `  Estimated free-space need: ${report.estimatedFreeSpaceBytes}`,
+        `  Required free space (with reserve): ${report.requiredFreeSpaceBytes}`,
+        `  Available free space: ${report.availableFreeSpaceBytes}`,
+        `  Free-space gate: ${report.freeSpaceGatePassed ? 'PASS' : 'FAIL'}`,
+        `  Migrated: ${report.migratedTasks} task(s), ${report.migratedEntries} entr${report.migratedEntries === 1 ? 'y' : 'ies'}`,
+        `  Skipped event-source tasks: ${report.skippedTasks}`,
+        `  Failed tasks: ${report.failedTasks}`,
+        `  Logical source bytes removed: ${report.logicalSourceBytesRemoved}`,
+    ];
+    if (report.remainingTaskCount !== undefined)
+        lines.push(`  Remaining blob tasks: ${report.remainingTaskCount}`);
+    if (report.backupPath) {
+        lines.push(`  Backup: ${report.backupPath}`);
+        if (report.backupMethod)
+            lines.push(`  Backup method: ${report.backupMethod}`);
+    }
+    if (report.verification) {
+        lines.push(`  Event rows checked: ${report.verification.eventCount}`);
+        lines.push(`  Verification issues: ${report.verification.issues.length}`);
+    }
+    if (report.blockedReason)
+        lines.push(`  Blocked: ${report.blockedReason}`);
+    for (const warning of report.warnings ?? [])
+        lines.push(`  Warning: ${warning}`);
+    return lines.join('\n');
+}
+async function handleTaskLogMigration(args) {
+    let parsed;
+    try {
+        parsed = parseTaskLogMigrationArgs(args);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message === exports.TASK_LOG_MIGRATION_HELP) {
+            console.log(message);
+        }
+        else {
+            console.error(message);
+            console.error(exports.TASK_LOG_MIGRATION_HELP);
+            process.exitCode = 2;
+        }
+        return;
+    }
+    try {
+        const report = await (0, repository_3.runTaskLogMigration)(parsed);
+        console.log(formatMigrationReport(report));
+        if (!report.ok) {
+            if (report.blockedReason)
+                console.error(report.blockedReason);
+            const failures = report.failures ?? report.malformedRows ?? [];
+            for (const failure of failures) {
+                console.error(`  ${failure.taskId}: ${failure.reason}`);
+            }
+            process.exitCode = 1;
+        }
+        else {
+            process.exitCode = 0;
+        }
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
 }
 async function handleDbPush(args) {
     const force = args.includes('--force');

package/dist/commands/doctor.d.ts

@@ -6,7 +6,24 @@
  *   crewx doctor                  Run full diagnosis
  *   crewx doctor --config <path>  Use specific config file
  */
+interface DiagnosticResult {
+    name: string;
+    status: 'success' | 'warning' | 'error';
+    message: string;
+    details?: string;
+}
+export interface CliProviderInfo {
+    cmd: string;
+    install: string;
+}
+/** CLI diagnostics keyed by the bare provider name used in PROVIDER_ORDER. */
+export declare const CLI_PROVIDER_INFO: Record<string, CliProviderInfo>;
+/**
+ * Check CLI provider availability in the canonical PROVIDER_ORDER.
+ */
+export declare function checkCliProviders(): DiagnosticResult[];
 /**
  * Handle `crewx doctor` command.
  */
 export declare function handleDoctor(args: string[]): Promise<void>;
+export {};

package/dist/commands/doctor.js

@@ -8,12 +8,23 @@
  *   crewx doctor --config <path>  Use specific config file
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_PROVIDER_INFO = void 0;
+exports.checkCliProviders = checkCliProviders;
 exports.handleDoctor = handleDoctor;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const child_process_1 = require("child_process");
 const sdk_1 = require("@crewx/sdk");
 const parse_common_flags_1 = require("./parse-common-flags");
+/** CLI diagnostics keyed by the bare provider name used in PROVIDER_ORDER. */
+exports.CLI_PROVIDER_INFO = {
+    codex: { cmd: 'codex', install: 'npm install -g @openai/codex' },
+    claude: { cmd: 'claude', install: 'npm install -g @anthropic-ai/claude-code' },
+    grok: { cmd: 'grok', install: 'curl -fsSL https://x.ai/cli/install.sh | bash' },
+    opencode: { cmd: 'opencode', install: 'npm install -g opencode' },
+    antigravity: { cmd: 'antigravity', install: 'npm install -g antigravity' },
+    copilot: { cmd: 'gh', install: 'brew install gh  # or visit cli.github.com' },
+};
 function statusIcon(status) {
     switch (status) {
         case 'success': return '✅';
@@ -99,20 +110,19 @@ function checkLogsDir() {
     };
 }
 /**
- * Check CLI provider availability.
- * Providers are checked in PROVIDER_ORDER: codex → claude → opencode → antigravity → copilot.
+ * Check CLI provider availability in the canonical PROVIDER_ORDER.
  */
 function checkCliProviders() {
-    // Map each provider (in PROVIDER_ORDER) to its CLI command and install hint.
-    const providerInfo = {
-        codex: { cmd: 'codex', install: 'npm install -g @openai/codex' },
-        claude: { cmd: 'claude', install: 'npm install -g @anthropic-ai/claude-code' },
-        opencode: { cmd: 'opencode', install: 'npm install -g opencode' },
-        antigravity: { cmd: 'antigravity', install: 'npm install -g antigravity' },
-        copilot: { cmd: 'gh', install: 'brew install gh  # or visit cli.github.com' },
-    };
     return sdk_1.PROVIDER_ORDER.map(provider => {
-        const info = providerInfo[provider];
+        const info = exports.CLI_PROVIDER_INFO[provider];
+        if (!info) {
+            return {
+                name: `${provider.toUpperCase()} CLI`,
+                status: 'error',
+                message: 'Diagnostic metadata is missing',
+                details: `Add ${provider} to CLI_PROVIDER_INFO.`,
+            };
+        }
         const displayName = provider === 'copilot' ? 'copilot (gh)' : provider;
         const available = isCommandAvailable(info.cmd);
         return {

package/dist/commands/execute.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,6 +13,9 @@
  *   --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).
  *
  * Stdin support:
  *   Pipe or redirect content into crewx x to supply the task body via stdin.