@crewx/cli 0.9.0-rc.86 → 0.9.0-rc.87

package/dist/commands/doctor.d.ts

@@ -16,8 +16,44 @@ export interface CliProviderInfo {
     cmd: string;
     install: string;
 }
+export interface DoctorArtifact {
+    directory: string;
+    sizeBytes: number;
+    details: string[];
+}
+export interface NpxCacheReport {
+    cacheRoot: string;
+    zeroByteLockfileDirectories: DoctorArtifact[];
+    staleFileCacheDirectories: DoctorArtifact[];
+    cleanableDirectories: DoctorArtifact[];
+}
+export interface HookCommandIssue {
+    provider: 'claude' | 'codex';
+    settingsPath: string;
+    command: string;
+    reason: 'launcher' | 'non-absolute';
+}
+export interface HookCommandReport {
+    inspectedFiles: string[];
+    issues: HookCommandIssue[];
+}
+export interface CrewxShimReport {
+    shimRoot: string;
+    currentFingerprint?: string;
+    staleDirectories: Array<DoctorArtifact & {
+        fingerprint: string;
+    }>;
+}
 /** CLI diagnostics keyed by the bare provider name used in PROVIDER_ORDER. */
 export declare const CLI_PROVIDER_INFO: Record<string, CliProviderInfo>;
+/** Format a byte count for diagnostic output. */
+export declare function formatBytes(bytes: number): string;
+/** Inspect npm's persistent `_npx` cache without modifying it. */
+export declare function inspectNpxCache(cacheRoot?: string): NpxCacheReport;
+/** Inspect installed CrewX hooks without rewriting provider settings. */
+export declare function inspectHookCommands(projectRoot: string): HookCommandReport;
+/** Inspect orphaned CrewX PATH shim directories without modifying them. */
+export declare function inspectCrewxShims(crewxHome?: string, resolvedFingerprint?: string | undefined): CrewxShimReport;
 /**
  * Check CLI provider availability in the canonical PROVIDER_ORDER.
  */

package/dist/commands/doctor.js

@@ -9,13 +9,20 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLI_PROVIDER_INFO = void 0;
+exports.formatBytes = formatBytes;
+exports.inspectNpxCache = inspectNpxCache;
+exports.inspectHookCommands = inspectHookCommands;
+exports.inspectCrewxShims = inspectCrewxShims;
 exports.checkCliProviders = checkCliProviders;
 exports.handleDoctor = handleDoctor;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const child_process_1 = require("child_process");
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
 const sdk_1 = require("@crewx/sdk");
 const parse_common_flags_1 = require("./parse-common-flags");
+const command_marker_1 = require("./hook/command-marker");
 /** 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' },
@@ -37,18 +44,357 @@ function statusIcon(status) {
  */
 function isCommandAvailable(cmd) {
     try {
-        (0, child_process_1.execSync)(`which ${cmd}`, { stdio: 'ignore' });
+        (0, node_child_process_1.execSync)(`which ${cmd}`, { stdio: 'ignore' });
         return true;
     }
     catch {
         return false;
     }
 }
+/** Format a byte count for diagnostic output. */
+function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes <= 0)
+        return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    let value = bytes;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+        value /= 1024;
+        unitIndex += 1;
+    }
+    const rounded = unitIndex === 0 || value >= 10 ? Math.round(value) : value.toFixed(1);
+    return `${rounded} ${units[unitIndex]}`;
+}
+function directorySize(path) {
+    try {
+        const stats = (0, node_fs_1.lstatSync)(path);
+        if (!stats.isDirectory())
+            return stats.size;
+        return (0, node_fs_1.readdirSync)(path, { withFileTypes: true }).reduce((total, entry) => {
+            return total + directorySize((0, node_path_1.join)(path, entry.name));
+        }, 0);
+    }
+    catch {
+        return 0;
+    }
+}
+function immediateDirectories(root) {
+    try {
+        return (0, node_fs_1.readdirSync)(root, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => (0, node_path_1.join)(root, entry.name))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function readJsonObject(filePath) {
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(filePath, 'utf8'));
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getNpxCacheRoot(env = process.env) {
+    const configuredCache = env.NPM_CONFIG_CACHE ?? env.npm_config_cache;
+    const npmCache = configuredCache?.trim() || (0, node_path_1.join)((0, node_os_1.homedir)(), '.npm');
+    const resolvedCache = (0, node_path_1.resolve)(npmCache);
+    return (0, node_path_1.basename)(resolvedCache) === '_npx'
+        ? resolvedCache
+        : (0, node_path_1.join)(resolvedCache, '_npx');
+}
+const DEPENDENCY_SECTIONS = [
+    'dependencies',
+    'devDependencies',
+    'optionalDependencies',
+    'peerDependencies',
+];
+function staleFileDependencies(cacheDirectory) {
+    const packageJson = readJsonObject((0, node_path_1.join)(cacheDirectory, 'package.json'));
+    if (!packageJson)
+        return [];
+    const missing = [];
+    for (const section of DEPENDENCY_SECTIONS) {
+        const dependencies = packageJson[section];
+        if (typeof dependencies !== 'object' || dependencies === null || Array.isArray(dependencies))
+            continue;
+        for (const [name, specifier] of Object.entries(dependencies)) {
+            if (typeof specifier !== 'string' || !specifier.startsWith('file:'))
+                continue;
+            const target = (0, node_path_1.resolve)(cacheDirectory, specifier.slice('file:'.length));
+            if (!(0, node_fs_1.existsSync)(target)) {
+                missing.push(`${section}.${name}=${specifier} (missing ${target})`);
+            }
+        }
+    }
+    return missing;
+}
+function addArtifact(artifacts, directory, details) {
+    const existing = artifacts.get(directory);
+    if (existing) {
+        existing.details.push(...details);
+        return existing;
+    }
+    const artifact = {
+        directory,
+        sizeBytes: directorySize(directory),
+        details: [...details],
+    };
+    artifacts.set(directory, artifact);
+    return artifact;
+}
+/** Inspect npm's persistent `_npx` cache without modifying it. */
+function inspectNpxCache(cacheRoot = getNpxCacheRoot()) {
+    const resolvedRoot = (0, node_path_1.resolve)(cacheRoot);
+    const zeroByteLockfileDirectories = [];
+    const staleFileCacheDirectories = [];
+    const cleanable = new Map();
+    for (const directory of immediateDirectories(resolvedRoot)) {
+        const lockfile = (0, node_path_1.join)(directory, 'package-lock.json');
+        try {
+            const lockfileStats = (0, node_fs_1.statSync)(lockfile);
+            if (lockfileStats.isFile() && lockfileStats.size === 0) {
+                const entry = addArtifact(cleanable, directory, [`0-byte lockfile: ${lockfile}`]);
+                zeroByteLockfileDirectories.push(entry);
+            }
+        }
+        catch {
+            // A cache entry can disappear while doctor is inspecting it.
+        }
+        const missing = staleFileDependencies(directory);
+        if (missing.length > 0) {
+            const entry = addArtifact(cleanable, directory, missing);
+            staleFileCacheDirectories.push(entry);
+        }
+    }
+    return {
+        cacheRoot: resolvedRoot,
+        zeroByteLockfileDirectories,
+        staleFileCacheDirectories,
+        cleanableDirectories: [...cleanable.values()],
+    };
+}
+function asRecord(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function hookCommandsFromSettings(settings) {
+    const hookContainer = asRecord(settings.hooks) ?? settings;
+    const preToolUse = hookContainer.PreToolUse;
+    if (!Array.isArray(preToolUse))
+        return [];
+    const commands = [];
+    for (const entry of preToolUse) {
+        const entryRecord = asRecord(entry);
+        const hooks = entryRecord?.hooks;
+        if (!Array.isArray(hooks))
+            continue;
+        for (const hook of hooks) {
+            const command = asRecord(hook)?.command;
+            if (typeof command === 'string' && command_marker_1.CREWX_HOOK_COMMAND_RE.test(command)) {
+                commands.push(command);
+            }
+        }
+    }
+    return commands;
+}
+function firstShellToken(command) {
+    const value = command.trim();
+    if (!value)
+        return '';
+    if (value.startsWith("'") || value.startsWith('"')) {
+        const quote = value[0];
+        const closing = value.indexOf(quote, 1);
+        return closing === -1 ? value.slice(1) : value.slice(1, closing);
+    }
+    return value.split(/\s+/, 1)[0];
+}
+function isAbsoluteExecutableToken(token) {
+    return (0, node_path_1.isAbsolute)(token) || /^[A-Za-z]:[\\/]/.test(token) || token.startsWith('\\\\');
+}
+function hookCommandIssue(command) {
+    const executable = firstShellToken(command);
+    if (/^(?:npx|pnpm|yarn)$/i.test(executable))
+        return 'launcher';
+    if (!isAbsoluteExecutableToken(executable))
+        return 'non-absolute';
+    return undefined;
+}
+/** Inspect installed CrewX hooks without rewriting provider settings. */
+function inspectHookCommands(projectRoot) {
+    const candidates = [
+        { provider: 'claude', settingsPath: (0, node_path_1.join)((0, node_path_1.resolve)(projectRoot), '.claude', 'settings.json') },
+        { provider: 'codex', settingsPath: (0, node_path_1.join)((0, node_path_1.resolve)(projectRoot), '.codex', 'hooks.json') },
+    ];
+    const inspectedFiles = [];
+    const issues = [];
+    for (const candidate of candidates) {
+        if (!(0, node_fs_1.existsSync)(candidate.settingsPath))
+            continue;
+        inspectedFiles.push(candidate.settingsPath);
+        const settings = readJsonObject(candidate.settingsPath);
+        if (!settings)
+            continue;
+        for (const command of hookCommandsFromSettings(settings)) {
+            const reason = hookCommandIssue(command);
+            if (reason) {
+                issues.push({
+                    provider: candidate.provider,
+                    settingsPath: candidate.settingsPath,
+                    command,
+                    reason,
+                });
+            }
+        }
+    }
+    return { inspectedFiles, issues };
+}
+function currentShimFingerprint() {
+    const resolution = (0, sdk_1.resolveCrewxExecutable)();
+    if (!resolution.ok)
+        return undefined;
+    return (0, node_crypto_1.createHash)('sha256')
+        .update(JSON.stringify(resolution.argv))
+        .digest('hex')
+        .slice(0, 16);
+}
+/** Inspect orphaned CrewX PATH shim directories without modifying them. */
+function inspectCrewxShims(crewxHome = (0, sdk_1.getCrewxHome)(), resolvedFingerprint = currentShimFingerprint()) {
+    const shimRoot = (0, node_path_1.join)((0, node_path_1.resolve)(crewxHome), 'bin-shim');
+    const staleDirectories = [];
+    if (resolvedFingerprint) {
+        for (const directory of immediateDirectories(shimRoot)) {
+            const fingerprint = directory.slice(shimRoot.length + 1);
+            if (fingerprint === resolvedFingerprint)
+                continue;
+            staleDirectories.push({
+                fingerprint,
+                directory,
+                sizeBytes: directorySize(directory),
+                details: [`not current fingerprint (${resolvedFingerprint})`],
+            });
+        }
+    }
+    return { shimRoot, currentFingerprint: resolvedFingerprint, staleDirectories };
+}
+function checkNpxCache(report) {
+    const corrupt = report.zeroByteLockfileDirectories.length;
+    const stale = report.staleFileCacheDirectories.length;
+    const cleanable = report.cleanableDirectories.length;
+    if (corrupt === 0 && stale === 0) {
+        return {
+            name: 'npx Cache',
+            status: 'success',
+            message: `No stale entries found in ${report.cacheRoot}`,
+        };
+    }
+    const details = [];
+    if (corrupt > 0) {
+        details.push(`0-byte package-lock.json: ${report.zeroByteLockfileDirectories.map((entry) => entry.directory).join(', ')}`);
+    }
+    if (stale > 0) {
+        details.push(`stale file: cache: ${report.staleFileCacheDirectories.map((entry) => entry.directory).join(', ')}`);
+    }
+    details.push('Run `crewx doctor --clean-npx-cache` to remove these cache directories explicitly.');
+    return {
+        name: 'npx Cache',
+        status: 'warning',
+        message: `Found ${cleanable} problematic npx cache director${cleanable === 1 ? 'y' : 'ies'}`,
+        details: details.join('\n'),
+    };
+}
+function checkHookCommands(report) {
+    if (report.issues.length === 0) {
+        return {
+            name: 'CrewX Hooks',
+            status: 'success',
+            message: report.inspectedFiles.length > 0
+                ? 'Installed CrewX hook commands use absolute entrypoints'
+                : 'No installed CrewX hooks found',
+        };
+    }
+    const details = report.issues
+        .map((issue) => `${issue.settingsPath}: ${issue.command} (${issue.reason})`)
+        .join('\n');
+    return {
+        name: 'CrewX Hooks',
+        status: 'warning',
+        message: `Found ${report.issues.length} hook command(s) that need an absolute CrewX entrypoint`,
+        details: `${details}\nRun \`crewx hook install\` to refresh the hook after reviewing the change.`,
+    };
+}
+function checkCrewxShims(report) {
+    if (!report.currentFingerprint) {
+        return {
+            name: 'CrewX PATH Shims',
+            status: 'warning',
+            message: 'Could not resolve the current CrewX executable; skipped orphan shim cleanup',
+            details: `Shim root: ${report.shimRoot}`,
+        };
+    }
+    if (report.staleDirectories.length === 0) {
+        return {
+            name: 'CrewX PATH Shims',
+            status: 'success',
+            message: 'No orphaned CrewX PATH shims found',
+        };
+    }
+    return {
+        name: 'CrewX PATH Shims',
+        status: 'warning',
+        message: `Found ${report.staleDirectories.length} orphaned CrewX PATH shim director${report.staleDirectories.length === 1 ? 'y' : 'ies'}`,
+        details: `${report.staleDirectories.map((entry) => entry.directory).join(', ')}\nRun \`crewx doctor --clean-npx-cache\` to remove stale shims explicitly.`,
+    };
+}
+function safelyRemoveDirectories(directories, parent) {
+    const expectedParent = (0, node_path_1.resolve)(parent);
+    let removed = 0;
+    const failed = [];
+    for (const entry of directories) {
+        const directory = (0, node_path_1.resolve)(entry.directory);
+        if ((0, node_path_1.dirname)(directory) !== expectedParent) {
+            failed.push(`${directory} (unexpected parent)`);
+            continue;
+        }
+        try {
+            (0, node_fs_1.rmSync)(directory, { recursive: true, force: true });
+            if (!(0, node_fs_1.existsSync)(directory))
+                removed += 1;
+            else
+                failed.push(directory);
+        }
+        catch {
+            failed.push(directory);
+        }
+    }
+    return { removed, failed };
+}
+function cleanDoctorArtifacts(npxCache, shims) {
+    const npxTargets = npxCache.cleanableDirectories;
+    const shimTargets = shims.staleDirectories;
+    const allTargets = [...npxTargets, ...shimTargets];
+    const totalBytes = allTargets.reduce((sum, entry) => sum + entry.sizeBytes, 0);
+    console.log(`⚠️  --clean-npx-cache: before cleanup, ${npxTargets.length} npx cache director${npxTargets.length === 1 ? 'y' : 'ies'} ` +
+        `and ${shimTargets.length} orphan shim director${shimTargets.length === 1 ? 'y' : 'ies'} (${formatBytes(totalBytes)}).`);
+    const npxResult = safelyRemoveDirectories(npxTargets, npxCache.cacheRoot);
+    const shimResult = safelyRemoveDirectories(shimTargets, shims.shimRoot);
+    const failures = [...npxResult.failed, ...shimResult.failed];
+    console.log(`   Removed ${npxResult.removed + shimResult.removed} director${npxResult.removed + shimResult.removed === 1 ? 'y' : 'ies'}.`);
+    if (failures.length > 0) {
+        console.log(`   Could not remove: ${failures.join(', ')}`);
+    }
+}
 /**
  * Check crewx.yaml configuration file.
  */
 function checkConfig(configPath) {
-    if (!(0, fs_1.existsSync)(configPath)) {
+    if (!(0, node_fs_1.existsSync)(configPath)) {
         return {
             name: 'Configuration File',
             status: 'error',
@@ -94,8 +440,8 @@ function checkConfig(configPath) {
  * Check .crewx/logs directory.
  */
 function checkLogsDir() {
-    const logsDir = (0, path_1.join)(process.cwd(), '.crewx', 'logs');
-    if (!(0, fs_1.existsSync)(logsDir)) {
+    const logsDir = (0, node_path_1.join)(process.cwd(), '.crewx', 'logs');
+    if (!(0, node_fs_1.existsSync)(logsDir)) {
         return {
             name: 'Logs Directory',
             status: 'warning',
@@ -148,7 +494,7 @@ function checkEnvVars() {
     return {
         name: 'CREWX_CLI',
         status: 'warning',
-        message: 'Not set — defaulting to "npx crewx"',
+        message: 'Not set — defaulting to "crewx"',
         details: 'This is auto-set at CLI startup; no action needed.',
     };
 }
@@ -171,14 +517,28 @@ function assessHealth(diagnostics) {
  * Handle `crewx doctor` command.
  */
 async function handleDoctor(args) {
-    const { config } = (0, parse_common_flags_1.parseCommonFlags)(args);
-    const configPath = config ?? process.env.CREWX_CONFIG ?? (0, path_1.join)(process.cwd(), 'crewx.yaml');
+    const cleanNpxCache = args.includes('--clean-npx-cache');
+    const commonArgs = args.filter((arg) => arg !== '--clean-npx-cache');
+    const { config } = (0, parse_common_flags_1.parseCommonFlags)(commonArgs);
+    const configPath = config ?? process.env.CREWX_CONFIG ?? (0, node_path_1.join)(process.cwd(), 'crewx.yaml');
     console.log('🩺 Starting CrewX system diagnosis...\n');
+    let npxCache = inspectNpxCache();
+    let shims = inspectCrewxShims();
+    const projectRoot = (0, node_path_1.dirname)((0, node_path_1.resolve)(configPath));
+    const hooks = inspectHookCommands(projectRoot);
+    if (cleanNpxCache) {
+        cleanDoctorArtifacts(npxCache, shims);
+        npxCache = inspectNpxCache();
+        shims = inspectCrewxShims();
+    }
     const diagnostics = [
         checkConfig(configPath),
         checkLogsDir(),
         checkEnvVars(),
         ...checkCliProviders(),
+        checkNpxCache(npxCache),
+        checkHookCommands(hooks),
+        checkCrewxShims(shims),
     ];
     // Print diagnostics
     diagnostics.forEach(d => {

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,13 @@ function getProviderConfigs(projectRoot, providers, crewxBin) {
     }));
 }
 function resolveCrewxBinary() {
-    if (process.env.CREWX_CLI)
-        return process.env.CREWX_CLI;
-    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;
+    const resolution = (0, sdk_1.resolveCrewxExecutable)();
+    if (!resolution.ok) {
+        throw new Error((0, sdk_1.formatCrewxExecutableFailure)(resolution));
     }
-    catch { }
-    if (process.argv[1]) {
-        const scriptPath = (0, path_1.resolve)(process.argv[1]);
-        if ((0, fs_1.existsSync)(scriptPath)) {
-            return `${process.execPath} ${scriptPath}`;
-        }
-    }
-    return 'crewx';
+    const stableEntrypoint = (0, sdk_1.materializeCrewxStableEntrypoint)(resolution);
+    const useStable = stableEntrypoint && resolution.argv.some(sdk_1.isRotatingInstallPath);
+    return (0, sdk_1.formatCrewxExecutableArgv)(useStable ? [stableEntrypoint] : resolution.argv);
 }
 function readSettingsTyped(settingsPath) {
     return (0, paths_1.readSettings)(settingsPath);
@@ -88,10 +42,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 +62,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 +102,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 +115,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 +141,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewx/cli",
-  "version": "0.9.0-rc.86",
+  "version": "0.9.0-rc.87",
   "license": "UNLICENSED",
   "engines": {
     "node": ">=20.19.0"
@@ -25,18 +25,18 @@
     "better-sqlite3": "*",
     "dotenv": "17.2.3",
     "isomorphic-git": "1.37.1",
-    "@crewx/doc": "0.1.9-rc.79",
-    "@crewx/search": "0.1.10-rc.82",
-    "@crewx/wbs": "0.1.10-rc.112",
-    "@crewx/sdk": "0.9.0-rc.86",
-    "@crewx/memory": "0.1.23-rc.103",
-    "@crewx/cron": "0.1.10-rc.121",
-    "@crewx/notify": "0.1.0-rc.57",
-    "@crewx/skill": "0.1.20",
-    "@crewx/workflow": "0.3.22-rc.132",
-    "@crewx/wi": "0.1.10-rc.106",
-    "@crewx/chromex": "0.1.0-rc.119",
-    "@crewx/shared": "0.0.6"
+    "@crewx/sdk": "0.9.0-rc.87",
+    "@crewx/wbs": "0.1.10-rc.113",
+    "@crewx/memory": "0.1.23-rc.104",
+    "@crewx/search": "0.1.10-rc.83",
+    "@crewx/cron": "0.1.10-rc.122",
+    "@crewx/doc": "0.1.9-rc.80",
+    "@crewx/workflow": "0.3.22-rc.133",
+    "@crewx/wi": "0.1.10-rc.107",
+    "@crewx/chromex": "0.1.0-rc.120",
+    "@crewx/notify": "0.1.0-rc.58",
+    "@crewx/shared": "0.0.6",
+    "@crewx/skill": "0.1.20"
   },
   "devDependencies": {
     "@types/better-sqlite3": "*",