@webpresso/agent-kit 0.21.5 → 0.24.0

package/dist/esm/blueprint/utils/document-paths.js

@@ -0,0 +1,91 @@
+import path from 'node:path';
+export const BLUEPRINT_OVERVIEW_FILENAME = '_overview.md';
+export const BLUEPRINT_STATUSES = [
+    'draft',
+    'planned',
+    'parked',
+    'in-progress',
+    'completed',
+    'archived',
+];
+const BLUEPRINT_STATUS_SET = new Set(BLUEPRINT_STATUSES);
+const BLUEPRINT_SLUG_SEGMENT_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+export function normalizeBlueprintPath(filePath) {
+    return filePath.replace(/\\/g, '/').replace(/^\/+/, '');
+}
+export function isBlueprintStatus(value) {
+    return value !== undefined && BLUEPRINT_STATUS_SET.has(value);
+}
+export function isBlueprintSlugSegment(value) {
+    return value !== undefined && BLUEPRINT_SLUG_SEGMENT_PATTERN.test(value);
+}
+export function parseBlueprintDocumentRelativePath(filePath) {
+    const normalized = normalizeBlueprintPath(filePath);
+    const parts = normalized.split('/').filter((segment) => segment.length > 0);
+    const [state, second, third] = parts;
+    if (!isBlueprintStatus(state)) {
+        return null;
+    }
+    if (parts.length === 2 && typeof second === 'string' && second.endsWith('.md')) {
+        const slug = second.slice(0, -3);
+        if (!isBlueprintSlugSegment(slug)) {
+            return null;
+        }
+        return {
+            relativePath: `${state}/${slug}.md`,
+            shape: 'flat',
+            slug,
+            state,
+        };
+    }
+    if (parts.length === 3 &&
+        isBlueprintSlugSegment(second) &&
+        third === BLUEPRINT_OVERVIEW_FILENAME) {
+        return {
+            relativePath: `${state}/${second}/${BLUEPRINT_OVERVIEW_FILENAME}`,
+            shape: 'folder',
+            slug: second,
+            state,
+        };
+    }
+    return null;
+}
+export function isBlueprintSupportingMarkdownRelativePath(filePath) {
+    const normalized = normalizeBlueprintPath(filePath);
+    const parts = normalized.split('/').filter((segment) => segment.length > 0);
+    const [state, slug, doc] = parts;
+    return (parts.length === 3 &&
+        isBlueprintStatus(state) &&
+        isBlueprintSlugSegment(slug) &&
+        typeof doc === 'string' &&
+        doc.endsWith('.md') &&
+        doc !== BLUEPRINT_OVERVIEW_FILENAME);
+}
+export function getBlueprintDocumentPaths(root, state, slug) {
+    const directory = path.join(root, state, slug);
+    return {
+        directory,
+        flat: path.join(root, state, `${slug}.md`),
+        folder: path.join(directory, BLUEPRINT_OVERVIEW_FILENAME),
+    };
+}
+export function getBlueprintDocumentCandidates(root, slug) {
+    const normalized = normalizeBlueprintPath(slug);
+    const segments = normalized.split('/').filter((segment) => segment.length > 0);
+    const [state, name] = segments;
+    if (segments.length !== 2 || !isBlueprintStatus(state) || !isBlueprintSlugSegment(name)) {
+        return [];
+    }
+    const { flat, folder } = getBlueprintDocumentPaths(root, state, name);
+    return [flat, folder];
+}
+export function getBlueprintAlternateDocumentPath(root, filePath) {
+    const normalized = normalizeBlueprintPath(path.relative(root, filePath));
+    const parsed = parseBlueprintDocumentRelativePath(normalized);
+    if (!parsed) {
+        return null;
+    }
+    const paths = getBlueprintDocumentPaths(root, parsed.state, parsed.slug);
+    return parsed.shape === 'flat' ? paths.folder : paths.flat;
+}
+//# sourceMappingURL=document-paths.js.map

package/dist/esm/build/package-manifest.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
 import { join } from 'node:path';
 import { parse as parseYaml } from 'yaml';
+import { RUNTIME_TARGETS } from './runtime-targets.js';
 const DEPENDENCY_SECTIONS = [
     'dependencies',
     'devDependencies',
@@ -74,6 +75,12 @@ export function createPackedManifest(manifest, workspaceCatalogs) {
     if ('bin' in packedManifest) {
         packedManifest.bin = normalizePackedBinField(packedManifest.bin);
     }
+    if (typeof manifest.version === 'string') {
+        packedManifest.optionalDependencies = {
+            ...packedManifest.optionalDependencies,
+            ...Object.fromEntries(RUNTIME_TARGETS.map((target) => [target.packageName, manifest.version])),
+        };
+    }
     return packedManifest;
 }
 function writeJson(filePath, value) {

package/dist/esm/build/release-policy.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Release-time policy decisions for the publish pipeline.
+ *
+ * The per-platform native runtime packages (`@webpresso/agent-kit-runtime-*`)
+ * are a deferred capability: they are not yet created on the registry, the main
+ * package declares no `optionalDependencies` on them, and the plugin manifest
+ * still launches via the node entrypoint rather than a staged native `bin/wp`.
+ *
+ * Until that native-distribution work is intentionally activated, the release
+ * MUST NOT attempt to publish the matrix: a first-time `npm publish` of a
+ * never-created scoped package returns 404, which previously aborted the entire
+ * release before the main `@webpresso/agent-kit` package published (the root
+ * cause of the 0.22.x publish stall).
+ *
+ * The matrix publish is therefore gated behind an explicit opt-in. When the
+ * native-distribution feature lands, the release workflow sets
+ * `WP_PUBLISH_RUNTIME_MATRIX=1` (after bootstrapping the scoped packages on the
+ * registry) to turn it back on.
+ */
+export declare const PUBLISH_RUNTIME_MATRIX_ENV = "WP_PUBLISH_RUNTIME_MATRIX";
+/**
+ * Whether the release pipeline should build, stage, and publish the per-platform
+ * native runtime matrix. Defaults to `false` (matrix deferred); enabled only
+ * when `WP_PUBLISH_RUNTIME_MATRIX=1` is set explicitly.
+ */
+export declare function shouldPublishRuntimeMatrix(env: NodeJS.ProcessEnv): boolean;
+//# sourceMappingURL=release-policy.d.ts.map

package/dist/esm/build/release-policy.js

@@ -0,0 +1,29 @@
+/**
+ * Release-time policy decisions for the publish pipeline.
+ *
+ * The per-platform native runtime packages (`@webpresso/agent-kit-runtime-*`)
+ * are a deferred capability: they are not yet created on the registry, the main
+ * package declares no `optionalDependencies` on them, and the plugin manifest
+ * still launches via the node entrypoint rather than a staged native `bin/wp`.
+ *
+ * Until that native-distribution work is intentionally activated, the release
+ * MUST NOT attempt to publish the matrix: a first-time `npm publish` of a
+ * never-created scoped package returns 404, which previously aborted the entire
+ * release before the main `@webpresso/agent-kit` package published (the root
+ * cause of the 0.22.x publish stall).
+ *
+ * The matrix publish is therefore gated behind an explicit opt-in. When the
+ * native-distribution feature lands, the release workflow sets
+ * `WP_PUBLISH_RUNTIME_MATRIX=1` (after bootstrapping the scoped packages on the
+ * registry) to turn it back on.
+ */
+export const PUBLISH_RUNTIME_MATRIX_ENV = 'WP_PUBLISH_RUNTIME_MATRIX';
+/**
+ * Whether the release pipeline should build, stage, and publish the per-platform
+ * native runtime matrix. Defaults to `false` (matrix deferred); enabled only
+ * when `WP_PUBLISH_RUNTIME_MATRIX=1` is set explicitly.
+ */
+export function shouldPublishRuntimeMatrix(env) {
+    return env[PUBLISH_RUNTIME_MATRIX_ENV] === '1';
+}
+//# sourceMappingURL=release-policy.js.map

package/dist/esm/build/runtime-targets.d.ts

@@ -0,0 +1,13 @@
+export interface RuntimeTarget {
+    readonly id: string;
+    readonly bunTarget: string;
+    readonly os: NodeJS.Platform;
+    readonly cpu: NodeJS.Architecture;
+    readonly packageName: string;
+}
+export declare const RUNTIME_BINARY_NAME = "wp";
+export declare const RUNTIME_TARGETS: readonly RuntimeTarget[];
+export declare function runtimeBinaryFilename(target: RuntimeTarget): string;
+export declare function runtimePackageDirName(packageName: string): string;
+export declare function resolveRuntimeTarget(platform?: NodeJS.Platform, arch?: NodeJS.Architecture): RuntimeTarget | undefined;
+//# sourceMappingURL=runtime-targets.d.ts.map

package/dist/esm/build/runtime-targets.js

@@ -0,0 +1,48 @@
+export const RUNTIME_BINARY_NAME = 'wp';
+export const RUNTIME_TARGETS = [
+    {
+        id: 'darwin-arm64',
+        bunTarget: 'bun-darwin-arm64',
+        os: 'darwin',
+        cpu: 'arm64',
+        packageName: '@webpresso/agent-kit-runtime-darwin-arm64',
+    },
+    {
+        id: 'darwin-x64',
+        bunTarget: 'bun-darwin-x64',
+        os: 'darwin',
+        cpu: 'x64',
+        packageName: '@webpresso/agent-kit-runtime-darwin-x64',
+    },
+    {
+        id: 'linux-x64',
+        bunTarget: 'bun-linux-x64',
+        os: 'linux',
+        cpu: 'x64',
+        packageName: '@webpresso/agent-kit-runtime-linux-x64',
+    },
+    {
+        id: 'linux-arm64',
+        bunTarget: 'bun-linux-arm64',
+        os: 'linux',
+        cpu: 'arm64',
+        packageName: '@webpresso/agent-kit-runtime-linux-arm64',
+    },
+    {
+        id: 'windows-x64',
+        bunTarget: 'bun-windows-x64',
+        os: 'win32',
+        cpu: 'x64',
+        packageName: '@webpresso/agent-kit-runtime-windows-x64',
+    },
+];
+export function runtimeBinaryFilename(target) {
+    return target.os === 'win32' ? `${RUNTIME_BINARY_NAME}.exe` : RUNTIME_BINARY_NAME;
+}
+export function runtimePackageDirName(packageName) {
+    return packageName.split('/').at(-1) ?? packageName;
+}
+export function resolveRuntimeTarget(platform = process.platform, arch = process.arch) {
+    return RUNTIME_TARGETS.find((target) => target.os === platform && target.cpu === arch);
+}
+//# sourceMappingURL=runtime-targets.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