@webpresso/agent-kit 0.21.4 → 0.23.0

package/dist/esm/build/sync-catalog-doc-templates.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env bun
+/**
+ * sync-catalog-doc-templates.ts
+ *
+ * `docs/templates/` (repo root) is the editable source of truth for the
+ * blueprint / doc templates. `catalog/docs/templates/` is the published +
+ * scaffolded mirror: the npm `files` list ships `catalog/` but NOT repo-root
+ * `docs/` (which holds internal docs that must stay private), and `wp init`
+ * scaffolds templates into a consumer from `catalog/docs/templates/`.
+ *
+ * The two MUST stay byte-identical. Nothing synced them before, so they
+ * drifted — this script regenerates the mirror from the source and is wired
+ * into the build. The colocated drift test fails CI if they ever diverge.
+ *
+ * Default: regenerate the mirror from the source.
+ * `--check`: exit non-zero and list drift without writing (CI / pre-publish).
+ */
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { argv, exit } from 'node:process';
+import { fileURLToPath } from 'node:url';
+const PACKAGE_ROOT = dirname(dirname(import.meta.dirname));
+const SOURCE_DIR = join(PACKAGE_ROOT, 'docs', 'templates');
+const MIRROR_DIR = join(PACKAGE_ROOT, 'catalog', 'docs', 'templates');
+function listFiles(dir) {
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir, { withFileTypes: true })
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name)
+        .sort();
+}
+/**
+ * Names that are out of sync between source and mirror: content mismatch,
+ * missing from the mirror, or orphaned in the mirror.
+ */
+export function diffDocTemplateMirror() {
+    const sourceFiles = listFiles(SOURCE_DIR);
+    const mirrorFiles = listFiles(MIRROR_DIR);
+    const names = [...new Set([...sourceFiles, ...mirrorFiles])].sort();
+    const drift = [];
+    for (const name of names) {
+        const inSource = sourceFiles.includes(name);
+        const inMirror = mirrorFiles.includes(name);
+        if (!inSource || !inMirror) {
+            drift.push(name);
+            continue;
+        }
+        if (readFileSync(join(SOURCE_DIR, name), 'utf8') !== readFileSync(join(MIRROR_DIR, name), 'utf8')) {
+            drift.push(name);
+        }
+    }
+    return drift;
+}
+/** Regenerate the mirror from the source: copy every file, drop orphans. */
+function syncDocTemplateMirror() {
+    mkdirSync(MIRROR_DIR, { recursive: true });
+    const sourceFiles = listFiles(SOURCE_DIR);
+    for (const name of listFiles(MIRROR_DIR)) {
+        if (!sourceFiles.includes(name))
+            rmSync(join(MIRROR_DIR, name));
+    }
+    for (const name of sourceFiles) {
+        cpSync(join(SOURCE_DIR, name), join(MIRROR_DIR, name));
+    }
+    return sourceFiles.length;
+}
+function main() {
+    if (!existsSync(SOURCE_DIR)) {
+        console.error(`doc templates source not found: ${SOURCE_DIR}`);
+        exit(1);
+    }
+    if (argv.includes('--check')) {
+        const drift = diffDocTemplateMirror();
+        if (drift.length > 0) {
+            console.error([
+                'catalog/docs/templates/ is out of sync with docs/templates/:',
+                ...drift.map((name) => `  - ${name}`),
+                'Run `bun src/build/sync-catalog-doc-templates.ts` and commit the result.',
+            ].join('\n'));
+            exit(1);
+        }
+        console.log('catalog/docs/templates/ is in sync with docs/templates/');
+        return;
+    }
+    const count = syncDocTemplateMirror();
+    console.log(`Synced ${count} template(s) → catalog/docs/templates/`);
+}
+// Run as a script, but stay side-effect-free when imported (e.g. by the test).
+if (fileURLToPath(import.meta.url) === argv[1]) {
+    main();
+}
+//# sourceMappingURL=sync-catalog-doc-templates.js.map

package/dist/esm/cli/auto-update/detect-pm.d.ts

@@ -28,6 +28,21 @@ export interface DetectAbort {
 export type DetectResult = DetectSuccess | DetectAbort;
 export declare const PUBLIC_PACKAGE_NAME = "@webpresso/agent-kit";
 export declare const PUBLIC_NPM_REGISTRY = "https://registry.npmjs.org";
+/**
+ * Canonical global-install command for the public agent-kit.
+ *
+ * No `--registry` flag: npmjs.org is already the default registry, and a global
+ * `--registry` does NOT override a scoped `@webpresso:registry` mapping
+ * (npm/pnpm resolve the scope first). The flag was therefore redundant when no
+ * scope override exists and ineffective when one does. To force-public inside a
+ * repo that scopes `@webpresso` to a private registry, use the scoped form
+ * `--@webpresso:registry=${PUBLIC_NPM_REGISTRY}` instead.
+ *
+ * Exported so the `wp setup` self-update scaffolder reuses the exact same
+ * command (single source of truth — see `ensureAgentKitGlobal`).
+ */
+export declare function buildVpGlobalInstallCommand(): [string, ...string[]];
+export declare function formatLegacyCommandReplacementMessage(legacyCommand: string): string | null;
 /**
  * Detect whether argv1 is a symlink pointing into a supported source clone.
  * Returns the git worktree root if so, null otherwise.

package/dist/esm/cli/auto-update/detect-pm.js

@@ -20,17 +20,26 @@
 import { execFileSync } from 'node:child_process';
 import { realpathSync } from 'node:fs';
 import { delimiter, dirname, sep } from 'node:path';
+import { getLegacyAgentCommandReplacement } from '#cli/bundle/agent-command-inventory.js';
 export const PUBLIC_PACKAGE_NAME = '@webpresso/agent-kit';
 export const PUBLIC_NPM_REGISTRY = 'https://registry.npmjs.org';
-const VP_INSTALL_COMMAND = [
-    'vp',
-    'install',
-    '-g',
-    PUBLIC_PACKAGE_NAME,
-    '--',
-    '--registry',
-    PUBLIC_NPM_REGISTRY,
-];
+/**
+ * Canonical global-install command for the public agent-kit.
+ *
+ * No `--registry` flag: npmjs.org is already the default registry, and a global
+ * `--registry` does NOT override a scoped `@webpresso:registry` mapping
+ * (npm/pnpm resolve the scope first). The flag was therefore redundant when no
+ * scope override exists and ineffective when one does. To force-public inside a
+ * repo that scopes `@webpresso` to a private registry, use the scoped form
+ * `--@webpresso:registry=${PUBLIC_NPM_REGISTRY}` instead.
+ *
+ * Exported so the `wp setup` self-update scaffolder reuses the exact same
+ * command (single source of truth — see `ensureAgentKitGlobal`).
+ */
+export function buildVpGlobalInstallCommand() {
+    return ['vp', 'install', '-g', PUBLIC_PACKAGE_NAME];
+}
+const VP_INSTALL_COMMAND = buildVpGlobalInstallCommand();
 const INSTALL_COMMANDS = {
     npm: VP_INSTALL_COMMAND,
     pnpm: VP_INSTALL_COMMAND,
@@ -38,6 +47,12 @@ const INSTALL_COMMANDS = {
     bun: VP_INSTALL_COMMAND,
     vp: VP_INSTALL_COMMAND,
 };
+export function formatLegacyCommandReplacementMessage(legacyCommand) {
+    const replacement = getLegacyAgentCommandReplacement(legacyCommand);
+    if (replacement === null)
+        return null;
+    return `Legacy agent-kit command \`${legacyCommand}\` has a future replacement: \`${replacement}\`.`;
+}
 /**
  * Detect whether argv1 is a symlink pointing into a supported source clone.
  * Returns the git worktree root if so, null otherwise.

package/dist/esm/cli/auto-update/skip.js

@@ -37,7 +37,7 @@ export const CI_ENV_KEYS = [
     'DRONE',
     'JENKINS_URL',
 ];
-const SKIP_SUBCOMMANDS = new Set(['mcp']);
+const SKIP_SUBCOMMANDS = new Set(['mcp', 'hook']);
 export function shouldSkipUpdateCheck(env, argv) {
     if (hasInformationalFlag(argv))
         return true;
@@ -45,6 +45,8 @@ export function shouldSkipUpdateCheck(env, argv) {
         return true;
     if (env.WP_SKIP_UPDATE_CHECK === '1')
         return true;
+    if (isPackageLifecycleEnvironment(env))
+        return true;
     if (isCiEnvironment(env))
         return true;
     return false;
@@ -81,4 +83,10 @@ function isCiEnvironment(env) {
     }
     return false;
 }
+function isPackageLifecycleEnvironment(env) {
+    const lifecycleEvent = env.npm_lifecycle_event;
+    const packageJsonPath = env.npm_package_json;
+    return Boolean((lifecycleEvent && lifecycleEvent.trim().length > 0) ||
+        (packageJsonPath && packageJsonPath.trim().length > 0));
+}
 //# sourceMappingURL=skip.js.map

package/dist/esm/cli/bundle/agent-command-inventory.d.ts

@@ -0,0 +1,120 @@
+export type AgentCommandVisibility = 'public' | 'internal';
+export interface LegacyAgentCommandAlias {
+    legacyCommand: string;
+    replacementCommand: string;
+}
+export interface AgentCommandInventoryEntry {
+    id: string;
+    namespace: 'agent';
+    visibility: AgentCommandVisibility;
+    replacementCommand: string;
+    legacyAliases: readonly LegacyAgentCommandAlias[];
+}
+export declare const AGENT_COMMAND_INVENTORY: readonly [{
+    readonly id: "agent setup";
+    readonly namespace: "agent";
+    readonly visibility: "public";
+    readonly replacementCommand: "webpresso agent setup";
+    readonly legacyAliases: readonly [{
+        readonly legacyCommand: "wp setup";
+        readonly replacementCommand: "webpresso agent setup";
+    }, {
+        readonly legacyCommand: "wp init";
+        readonly replacementCommand: "webpresso agent setup";
+    }];
+}, {
+    readonly id: "agent sync";
+    readonly namespace: "agent";
+    readonly visibility: "public";
+    readonly replacementCommand: "webpresso agent sync";
+    readonly legacyAliases: readonly [{
+        readonly legacyCommand: "wp sync";
+        readonly replacementCommand: "webpresso agent sync";
+    }];
+}, {
+    readonly id: "agent audit";
+    readonly namespace: "agent";
+    readonly visibility: "public";
+    readonly replacementCommand: "webpresso agent audit";
+    readonly legacyAliases: readonly [{
+        readonly legacyCommand: "wp audit";
+        readonly replacementCommand: "webpresso agent audit";
+    }];
+}, {
+    readonly id: "agent skills";
+    readonly namespace: "agent";
+    readonly visibility: "public";
+    readonly replacementCommand: "webpresso agent skills";
+    readonly legacyAliases: readonly [{
+        readonly legacyCommand: "wp skill";
+        readonly replacementCommand: "webpresso agent skills";
+    }, {
+        readonly legacyCommand: "wp skills";
+        readonly replacementCommand: "webpresso agent skills";
+    }];
+}, {
+    readonly id: "agent docs lint";
+    readonly namespace: "agent";
+    readonly visibility: "public";
+    readonly replacementCommand: "webpresso agent docs lint";
+    readonly legacyAliases: readonly [{
+        readonly legacyCommand: "wp docs";
+        readonly replacementCommand: "webpresso agent docs lint";
+    }, {
+        readonly legacyCommand: "wp docs lint";
+        readonly replacementCommand: "webpresso agent docs lint";
+    }];
+}, {
+    readonly id: "agent hooks doctor";
+    readonly namespace: "agent";
+    readonly visibility: "public";
+    readonly replacementCommand: "webpresso agent hooks doctor";
+    readonly legacyAliases: readonly [{
+        readonly legacyCommand: "wp hooks";
+        readonly replacementCommand: "webpresso agent hooks doctor";
+    }, {
+        readonly legacyCommand: "wp hooks doctor";
+        readonly replacementCommand: "webpresso agent hooks doctor";
+    }, {
+        readonly legacyCommand: "wp doctor";
+        readonly replacementCommand: "webpresso agent hooks doctor";
+    }];
+}, {
+    readonly id: "agent blueprint";
+    readonly namespace: "agent";
+    readonly visibility: "public";
+    readonly replacementCommand: "webpresso agent blueprint";
+    readonly legacyAliases: readonly [{
+        readonly legacyCommand: "wp blueprint";
+        readonly replacementCommand: "webpresso agent blueprint";
+    }];
+}, {
+    readonly id: "agent test";
+    readonly namespace: "agent";
+    readonly visibility: "public";
+    readonly replacementCommand: "webpresso agent test";
+    readonly legacyAliases: readonly [{
+        readonly legacyCommand: "wp test";
+        readonly replacementCommand: "webpresso agent test";
+    }];
+}, {
+    readonly id: "agent e2e";
+    readonly namespace: "agent";
+    readonly visibility: "public";
+    readonly replacementCommand: "webpresso agent e2e";
+    readonly legacyAliases: readonly [{
+        readonly legacyCommand: "wp e2e";
+        readonly replacementCommand: "webpresso agent e2e";
+    }];
+}, {
+    readonly id: "agent tech-debt";
+    readonly namespace: "agent";
+    readonly visibility: "public";
+    readonly replacementCommand: "webpresso agent tech-debt";
+    readonly legacyAliases: readonly [{
+        readonly legacyCommand: "wp tech-debt";
+        readonly replacementCommand: "webpresso agent tech-debt";
+    }];
+}];
+export declare function getLegacyAgentCommandReplacement(legacyCommand: string): string | null;
+//# sourceMappingURL=agent-command-inventory.d.ts.map

package/dist/esm/cli/bundle/agent-command-inventory.js

@@ -0,0 +1,100 @@
+export const AGENT_COMMAND_INVENTORY = [
+    {
+        id: 'agent setup',
+        namespace: 'agent',
+        visibility: 'public',
+        replacementCommand: 'webpresso agent setup',
+        legacyAliases: [
+            { legacyCommand: 'wp setup', replacementCommand: 'webpresso agent setup' },
+            { legacyCommand: 'wp init', replacementCommand: 'webpresso agent setup' },
+        ],
+    },
+    {
+        id: 'agent sync',
+        namespace: 'agent',
+        visibility: 'public',
+        replacementCommand: 'webpresso agent sync',
+        legacyAliases: [{ legacyCommand: 'wp sync', replacementCommand: 'webpresso agent sync' }],
+    },
+    {
+        id: 'agent audit',
+        namespace: 'agent',
+        visibility: 'public',
+        replacementCommand: 'webpresso agent audit',
+        legacyAliases: [{ legacyCommand: 'wp audit', replacementCommand: 'webpresso agent audit' }],
+    },
+    {
+        id: 'agent skills',
+        namespace: 'agent',
+        visibility: 'public',
+        replacementCommand: 'webpresso agent skills',
+        legacyAliases: [
+            { legacyCommand: 'wp skill', replacementCommand: 'webpresso agent skills' },
+            { legacyCommand: 'wp skills', replacementCommand: 'webpresso agent skills' },
+        ],
+    },
+    {
+        id: 'agent docs lint',
+        namespace: 'agent',
+        visibility: 'public',
+        replacementCommand: 'webpresso agent docs lint',
+        legacyAliases: [
+            { legacyCommand: 'wp docs', replacementCommand: 'webpresso agent docs lint' },
+            { legacyCommand: 'wp docs lint', replacementCommand: 'webpresso agent docs lint' },
+        ],
+    },
+    {
+        id: 'agent hooks doctor',
+        namespace: 'agent',
+        visibility: 'public',
+        replacementCommand: 'webpresso agent hooks doctor',
+        legacyAliases: [
+            { legacyCommand: 'wp hooks', replacementCommand: 'webpresso agent hooks doctor' },
+            { legacyCommand: 'wp hooks doctor', replacementCommand: 'webpresso agent hooks doctor' },
+            { legacyCommand: 'wp doctor', replacementCommand: 'webpresso agent hooks doctor' },
+        ],
+    },
+    {
+        id: 'agent blueprint',
+        namespace: 'agent',
+        visibility: 'public',
+        replacementCommand: 'webpresso agent blueprint',
+        legacyAliases: [
+            { legacyCommand: 'wp blueprint', replacementCommand: 'webpresso agent blueprint' },
+        ],
+    },
+    {
+        id: 'agent test',
+        namespace: 'agent',
+        visibility: 'public',
+        replacementCommand: 'webpresso agent test',
+        legacyAliases: [{ legacyCommand: 'wp test', replacementCommand: 'webpresso agent test' }],
+    },
+    {
+        id: 'agent e2e',
+        namespace: 'agent',
+        visibility: 'public',
+        replacementCommand: 'webpresso agent e2e',
+        legacyAliases: [{ legacyCommand: 'wp e2e', replacementCommand: 'webpresso agent e2e' }],
+    },
+    {
+        id: 'agent tech-debt',
+        namespace: 'agent',
+        visibility: 'public',
+        replacementCommand: 'webpresso agent tech-debt',
+        legacyAliases: [
+            { legacyCommand: 'wp tech-debt', replacementCommand: 'webpresso agent tech-debt' },
+        ],
+    },
+];
+export function getLegacyAgentCommandReplacement(legacyCommand) {
+    const normalized = legacyCommand.trim().replace(/\s+/gu, ' ').toLowerCase();
+    for (const entry of AGENT_COMMAND_INVENTORY) {
+        for (const alias of entry.legacyAliases) {
+            if (alias.legacyCommand.toLowerCase() === normalized)
+                return alias.replacementCommand;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=agent-command-inventory.js.map

package/dist/esm/cli/bundle/index.d.ts

@@ -0,0 +1,17 @@
+import { type AgentCommandInventoryEntry } from '#cli/bundle/agent-command-inventory.js';
+export interface AgentBundleCommandDefinition {
+    readonly id: AgentCommandInventoryEntry['id'];
+    readonly namespace: AgentCommandInventoryEntry['namespace'];
+    readonly visibility: AgentCommandInventoryEntry['visibility'];
+    readonly replacementCommand: AgentCommandInventoryEntry['replacementCommand'];
+    readonly legacyAliases: AgentCommandInventoryEntry['legacyAliases'];
+}
+export interface AgentBundleDefinition {
+    readonly bundleId: 'agent-kit';
+    readonly commandRoot: 'agent';
+    readonly sourcePackage: '@webpresso/agent-kit';
+    readonly intendedHostPackage: '@repo/cli';
+    readonly commands: readonly AgentBundleCommandDefinition[];
+}
+export declare const AGENT_BUNDLE: AgentBundleDefinition;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/cli/bundle/index.js

@@ -0,0 +1,15 @@
+import { AGENT_COMMAND_INVENTORY, } from '#cli/bundle/agent-command-inventory.js';
+export const AGENT_BUNDLE = {
+    bundleId: 'agent-kit',
+    commandRoot: 'agent',
+    sourcePackage: '@webpresso/agent-kit',
+    intendedHostPackage: '@repo/cli',
+    commands: AGENT_COMMAND_INVENTORY.map((entry) => ({
+        id: entry.id,
+        namespace: entry.namespace,
+        visibility: entry.visibility,
+        replacementCommand: entry.replacementCommand,
+        legacyAliases: entry.legacyAliases,
+    })),
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/cli/cli.d.ts

@@ -5,7 +5,7 @@
  * Lazy-loads subcommand modules based on the first argv to keep startup
  * cheap. Modeled on apps/cli-wp/src/cli.ts.
  */
-declare const SUPPORTED_COMMANDS: readonly ["blueprint", "config", "roadmap", "sync", "audit", "compile", "rule", "skill", "skills", "docs", "setup", "init", "dev", "doctor", "err", "test", "e2e", "ci", "typecheck", "lint", "format", "tech-debt", "worktree", "mcp", "hooks", "gain", "bench"];
+declare const SUPPORTED_COMMANDS: readonly ["blueprint", "config", "roadmap", "sync", "audit", "compile", "rule", "skill", "skills", "docs", "setup", "init", "dev", "doctor", "err", "test", "e2e", "ci", "typecheck", "lint", "format", "tech-debt", "worktree", "mcp", "hook", "hooks", "gain", "bench", "install", "add", "remove", "update", "exec", "run"];
 export { SUPPORTED_COMMANDS };
 export declare function main(): Promise<number>;
 //# sourceMappingURL=cli.d.ts.map

package/dist/esm/cli/cli.js

@@ -11,6 +11,7 @@ import { resolve as pathResolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { bootstrapAk } from './bootstrap.js';
 import { formatUnknownCommandError, normalizeArgv, readPackageVersion } from './utils.js';
+import { registerWpExtensions, resolveWpCommandAlias } from './wp-extensions.js';
 const VERSION = readPackageVersion(import.meta.url);
 const SUPPORTED_COMMANDS = [
     'blueprint',
@@ -37,9 +38,16 @@ const SUPPORTED_COMMANDS = [
     'tech-debt',
     'worktree',
     'mcp',
+    'hook',
     'hooks',
     'gain',
     'bench',
+    'install',
+    'add',
+    'remove',
+    'update',
+    'exec',
+    'run',
 ];
 const ROOT_HELP = [
     'Usage: wp [command] [options]',
@@ -52,6 +60,12 @@ const ROOT_HELP = [
     '  gain                  Show token savings from RTK — run after any AI session',
     '  sync                  Sync agent rules + skills across IDE surfaces (--kind, --check)',
     '  bench                 Run the session-memory benchmark harness',
+    '  install               Install dependencies through the managed vp facade',
+    '  add                   Add dependencies through the managed vp facade',
+    '  remove                Remove dependencies through the managed vp facade',
+    '  update                Update dependencies through the managed vp facade',
+    '  exec                  Run a binary through the managed vp facade',
+    '  run                   Run a package script through the managed vp facade',
     '',
     'Quality:',
     '  audit                 Run packaged audits (bundle budgets, repo guardrails, TPH, tech-debt)',
@@ -123,7 +137,17 @@ export async function main() {
         return 0;
     }
     await bootstrapAk(VERSION, argv);
-    switch (command) {
+    const extensionRuntime = await registerWpExtensions({
+        cli,
+        cwd: process.cwd(),
+        env: process.env,
+        hostVersion: VERSION,
+        baseCommands: [...SUPPORTED_COMMANDS],
+    });
+    for (const warning of extensionRuntime.warnings)
+        console.error(warning);
+    const resolvedCommand = resolveWpCommandAlias(command, extensionRuntime.aliasMap);
+    switch (resolvedCommand) {
         case 'blueprint': {
             const { registerBlueprintRouter } = await import('./commands/blueprint/router.js');
             registerBlueprintRouter(cli);
@@ -177,7 +201,7 @@ export async function main() {
         case 'setup':
         case 'init': {
             const { registerInitCommand } = await import('./commands/init/index.js');
-            registerInitCommand(cli, command);
+            registerInitCommand(cli, resolvedCommand);
             break;
         }
         case 'dev': {
@@ -235,6 +259,11 @@ export async function main() {
             registerMcpCommand(cli);
             break;
         }
+        case 'hook': {
+            const { registerHookCommand } = await import('./commands/hook.js');
+            registerHookCommand(cli);
+            break;
+        }
         case 'hooks': {
             const { registerHooksCommand } = await import('./commands/hooks.js');
             registerHooksCommand(cli);
@@ -250,20 +279,35 @@ export async function main() {
             registerBenchCommand(cli);
             break;
         }
+        case 'install':
+        case 'add':
+        case 'remove':
+        case 'update':
+        case 'exec':
+        case 'run': {
+            const { registerPackageManagerCommand } = await import('./commands/package-manager.js');
+            registerPackageManagerCommand(cli, resolvedCommand);
+            break;
+        }
         case 'worktree': {
             const { registerWorktreeRouter } = await import('./commands/worktree/router.js');
             registerWorktreeRouter(cli);
             break;
         }
         default: {
-            console.error(formatUnknownCommandError(command, SUPPORTED_COMMANDS));
-            return 1;
+            if (!resolvedCommand || !extensionRuntime.commandNames.includes(resolvedCommand)) {
+                console.error(formatUnknownCommandError(command, SUPPORTED_COMMANDS));
+                return 1;
+            }
         }
     }
     cli.help();
     cli.version(VERSION);
     try {
-        cli.parse(argv, { run: false });
+        const effectiveArgv = resolvedCommand && resolvedCommand !== command
+            ? [argv[0] ?? 'node', argv[1] ?? 'wp', resolvedCommand, ...argv.slice(3)]
+            : argv;
+        cli.parse(effectiveArgv, { run: false });
         const result = await cli.runMatchedCommand();
         return typeof result === 'number' ? result : 0;
     }

package/dist/esm/cli/commands/audit-core.d.ts

@@ -1,5 +1,5 @@
 import type { RepoAuditResult } from '#audit/repo-guardrails';
-export type AuditKind = 'tph' | 'tph-e2e' | 'bundle-budget' | 'commit-message' | 'blueprint-lifecycle' | 'roadmap-links' | 'docs-frontmatter' | 'catalog-drift' | 'package-surface' | 'agents' | 'tech-debt' | 'no-relative-parent-imports' | 'no-link-protocol' | 'vision' | 'bucket-boundary' | 'skill-sizes' | 'broken-refs' | 'memory-rotation' | 'gitignore-agent-surfaces' | 'memory-unified' | 'compile-drift' | 'architecture-drift' | 'absolute-path-policy' | 'agent-cost' | 'blueprint-db-consistency' | 'blueprint-lifecycle-sql' | 'tech-debt-cadence' | 'cross-repo-correlation' | 'ai-contracts' | 'mutation' | 'quality' | 'guardrails' | 'hook-surface' | 'no-relative-package-scripts';
+export type AuditKind = 'tph' | 'tph-e2e' | 'bundle-budget' | 'commit-message' | 'blueprint-lifecycle' | 'roadmap-links' | 'docs-frontmatter' | 'catalog-drift' | 'package-surface' | 'agents' | 'tech-debt' | 'no-relative-parent-imports' | 'no-link-protocol' | 'vision' | 'bucket-boundary' | 'skill-sizes' | 'broken-refs' | 'memory-rotation' | 'gitignore-agent-surfaces' | 'memory-unified' | 'compile-drift' | 'architecture-drift' | 'cloudflare-deploy-contract' | 'absolute-path-policy' | 'agent-cost' | 'blueprint-db-consistency' | 'blueprint-lifecycle-sql' | 'tech-debt-cadence' | 'cross-repo-correlation' | 'ai-contracts' | 'mutation' | 'quality' | 'guardrails' | 'hook-surface' | 'no-relative-package-scripts';
 export type AuditOutcome = {
     kind: 'invalid-usage';
     message: string;

package/dist/esm/cli/commands/audit.js

@@ -9,6 +9,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { runAuditDispatch } from './audit-core.js';
 import { runStryker } from '#audit/run-stryker';
+import { resolveAuditScriptPath } from '#audit/resolve-audit-script';
 const REPO_AUDIT_REGISTRY = {
     'catalog-drift': async (root) => (await import('#audit/repo-guardrails')).auditCatalogDrift(root),
     'package-surface': async (root) => (await import('#audit/package-surface')).auditPackageSurface(root),
@@ -55,7 +56,9 @@ const REPO_AUDIT_REGISTRY = {
     'gitignore-agent-surfaces': async (root) => (await import('#audit/gitignore-agent-surfaces')).auditGitignoreAgentSurfaces(root),
     'memory-unified': async (root) => (await import('#audit/memory-unified')).auditMemoryUnified(root),
     'compile-drift': async (root) => (await import('#audit/compile-drift')).auditCompileDrift(root),
+    'no-legacy-cli-bin': async (root) => (await import('#audit/no-legacy-cli-bin')).auditNoLegacyCliBin(root),
     'architecture-drift': async (root) => (await import('#audit/architecture-drift')).auditArchitectureDrift(root),
+    'cloudflare-deploy-contract': async (root) => (await import('#audit/cloudflare-deploy-contract')).auditCloudflareDeployContract(root),
     'absolute-path-policy': async (root) => (await import('#audit/absolute-path-policy')).auditAbsolutePathPolicy(root),
     'agent-cost': async (root) => (await import('#audit/agent-cost')).auditAgentCost(root),
     'blueprint-db-consistency': async (root) => (await import('#audit/blueprint-db-consistency')).auditBlueprintDbConsistency(root),
@@ -119,13 +122,7 @@ const AUDIT_KINDS = [
 ];
 const AUDIT_KIND_LIST = AUDIT_KINDS.join(', ');
 function resolveAuditScript(name) {
-    const fromSource = new URL(`../../audit/${name}`, import.meta.url);
-    if (existsSync(fromSource)) {
-        return fromSource.pathname;
-    }
-    const bundleDir = path.dirname(new URL(import.meta.url).pathname);
-    const packageRoot = path.resolve(bundleDir, '..');
-    return path.join(packageRoot, 'src', 'audit', name);
+    return resolveAuditScriptPath(name, { moduleUrl: import.meta.url });
 }
 async function runAuditScript(script, extraArgs) {
     const runtime = process.env.BUN_INSTALL ? 'bun' : 'bun';