@webpresso/agent-kit 0.21.4 → 0.23.0

package/dist/esm/mcp/server.js

@@ -8,42 +8,25 @@
  */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { CallToolRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, RootsListChangedNotificationSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { discoverTools, } from './auto-discover.js';
+import { discoverTools, registerToolDescriptors, } from './auto-discover.js';
 import { registerBlueprintServer } from './blueprint-server.js';
+import { COMPILED_TOOL_REGISTRY } from './tools/_registry.js';
+import { readOwnedPackageVersion } from '#runtime/package-version.js';
 const SERVER_NAME = 'webpresso';
-// Walk upward from this module's location until we find package.json. Works
-// for both src/mcp/server.ts (dev) and dist/esm/mcp/server.js (built) without
-// hardcoding asymmetric `../../..` counts.
-const MAX_UPWARD_LEVELS = 8;
-function readPackageVersion() {
-    let dir = dirname(fileURLToPath(import.meta.url));
-    for (let i = 0; i < MAX_UPWARD_LEVELS; i++) {
-        const candidate = join(dir, 'package.json');
-        if (existsSync(candidate)) {
-            const pkg = JSON.parse(readFileSync(candidate, 'utf-8'));
-            // Some build outputs emit a marker `package.json` (e.g. `{ "type": "module" }`)
-            // without a version. Skip those and keep walking so we land on the real
-            // package root, instead of throwing the moment we see any package.json.
-            if (typeof pkg.version === 'string' && pkg.version.length > 0)
-                return pkg.version;
-        }
-        const parent = dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    throw new Error('Cannot locate a versioned package.json relative to webpresso MCP server module');
-}
-const SERVER_VERSION = readPackageVersion();
+const SERVER_VERSION = readOwnedPackageVersion(import.meta.url);
 function defaultToolsDir() {
     // import.meta.url resolves to either src/mcp/server.ts (dev/test via vitest)
     // or dist/esm/mcp/server.js (built). The tools directory is colocated.
     const here = dirname(fileURLToPath(import.meta.url));
     return join(here, 'tools');
 }
+function resolveDefaultToolLoadMode() {
+    return process.env.WP_MCP_TOOL_MODE === 'registry' || process.env.WP_COMPILED_RUNTIME === '1'
+        ? 'registry'
+        : 'filesystem';
+}
 export async function createServer(options = {}) {
     const server = new Server({ name: SERVER_NAME, version: SERVER_VERSION }, {
         capabilities: {
@@ -60,7 +43,13 @@ export async function createServer(options = {}) {
             tools.set(name, { name, description, inputSchema, outputSchema, handler, annotations });
         },
     };
-    await discoverTools(registrar, options.toolsDir ?? defaultToolsDir());
+    const toolLoadMode = options.toolLoadMode ?? resolveDefaultToolLoadMode();
+    if (toolLoadMode === 'registry') {
+        registerToolDescriptors(registrar, COMPILED_TOOL_REGISTRY);
+    }
+    else {
+        await discoverTools(registrar, options.toolsDir ?? defaultToolsDir());
+    }
     // Task 2.1: register the blueprint structured-store tools AFTER auto-discover
     // so any tool-name collision surfaces here as a thrown error rather than
     // silent shadowing. Roots are looked up lazily via `server.listRoots()`; the

package/dist/esm/mcp/tools/_registry.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDescriptor } from '#mcp/auto-discover';
+export declare const COMPILED_TOOL_REGISTRY: readonly ToolDescriptor[];
+//# sourceMappingURL=_registry.d.ts.map

package/dist/esm/mcp/tools/_registry.js

@@ -0,0 +1,21 @@
+import audit from './audit.js';
+import ciAct from './ci-act.js';
+import e2e from './e2e.js';
+import format from './format.js';
+import lint from './lint.js';
+import qa from './qa.js';
+import test from './test.js';
+import typecheck from './typecheck.js';
+import workerTail from './worker-tail.js';
+export const COMPILED_TOOL_REGISTRY = [
+    audit,
+    ciAct,
+    e2e,
+    format,
+    lint,
+    qa,
+    test,
+    typecheck,
+    workerTail,
+];
+//# sourceMappingURL=_registry.js.map

package/dist/esm/mcp/tools/audit.d.ts

@@ -32,6 +32,7 @@ declare const inputSchema: z.ZodObject<{
         "catalog-drift": "catalog-drift";
         "package-surface": "package-surface";
         "architecture-drift": "architecture-drift";
+        "cloudflare-deploy-contract": "cloudflare-deploy-contract";
         "absolute-path-policy": "absolute-path-policy";
         "ai-contracts": "ai-contracts";
     }>;

package/dist/esm/mcp/tools/audit.js

@@ -15,9 +15,8 @@
  * — the handler never throws out, so the MCP server stays responsive.
  */
 import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
 import { z } from 'zod';
-import { resolvePackageAsset } from '#utils/package-assets';
+import { resolveAuditScriptPath } from '#audit/resolve-audit-script';
 import { applyOutputTransform } from '#output-transforms/index';
 import { createSummaryOutputSchema, createSummaryResult } from './_shared/result.js';
 const KINDS = [
@@ -29,6 +28,7 @@ const KINDS = [
     'docs-frontmatter',
     'blueprint-lifecycle',
     'architecture-drift',
+    'cloudflare-deploy-contract',
     'absolute-path-policy',
     'roadmap-links',
     'bundle-budget',
@@ -62,12 +62,7 @@ const outputSchema = createSummaryOutputSchema({
     kind: z.enum(KINDS),
 });
 function resolveAuditScript(name) {
-    // Source layout: `src/mcp/tools/audit.ts` → `../../audit/<name>`.
-    const fromSource = new URL(`../../audit/${name}`, import.meta.url);
-    if (existsSync(fromSource)) {
-        return fromSource.pathname;
-    }
-    return resolvePackageAsset(`src/audit/${name}`);
+    return resolveAuditScriptPath(name, { moduleUrl: import.meta.url });
 }
 async function runScript(script) {
     return new Promise((resolve) => {
@@ -161,6 +156,16 @@ async function dispatch(input) {
                 details: auditResult,
             };
         }
+        case 'cloudflare-deploy-contract': {
+            const { auditCloudflareDeployContract } = await import('#audit/cloudflare-deploy-contract');
+            const auditResult = await auditCloudflareDeployContract(input.cwd ?? input.directory ?? process.cwd());
+            return {
+                passed: auditResult.ok,
+                summary: summarizeRepoAudit(kind, auditResult),
+                kind,
+                details: auditResult,
+            };
+        }
         case 'absolute-path-policy': {
             const { auditAbsolutePathPolicy } = await import('#audit/absolute-path-policy');
             const auditResult = auditAbsolutePathPolicy(input.cwd ?? input.directory ?? process.cwd());

package/dist/esm/mcp/tools/typecheck.js

@@ -14,6 +14,7 @@ import { join } from 'node:path';
 import { globSync } from 'glob';
 import { z } from 'zod';
 import { applyOutputTransform } from '#output-transforms/index';
+import { getManagedRunner } from '#tool-runtime';
 import { resolveProjectRoot } from './_shared/project-root.js';
 import { createSummaryOutputSchema, createSummaryResult } from './_shared/result.js';
 import { isRunFailure, runCommand } from './_shared/run-command.js';
@@ -143,11 +144,12 @@ const tool = {
         // current resolution treats each entry as a relative path either way.
         const workspaceGlobs = targets ? readWorkspaceGlobs(cwd) : null;
         const runs = [];
+        const resolution = getManagedRunner('tsc', { outputPolicy: 'structured' });
         if (targets) {
             for (const pkg of targets) {
                 const resolvedTarget = resolveTypecheckTarget(cwd, pkg, workspaceGlobs);
                 const tsconfig = join(resolvedTarget, 'tsconfig.json');
-                const outcome = await runCommand('tsc', ['--noEmit', '-p', tsconfig], runOptions);
+                const outcome = await runCommand(resolution.command, [...resolution.args, '--noEmit', '-p', tsconfig], runOptions);
                 if (isRunFailure(outcome)) {
                     throw outcome.error;
                 }
@@ -155,7 +157,7 @@ const tool = {
             }
         }
         else {
-            const outcome = await runCommand('tsc', ['--noEmit'], runOptions);
+            const outcome = await runCommand(resolution.command, [...resolution.args, '--noEmit'], runOptions);
             if (isRunFailure(outcome)) {
                 throw outcome.error;
             }

package/dist/esm/mutation/affected.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Run Stryker only on packages changed vs. the base branch.
+ * Returns 0 on success, 1 if any package fails its break threshold.
+ *
+ * Reads GITHUB_BASE_REF (set by GitHub Actions on pull_request events) to
+ * determine the base branch; falls back to "main".
+ */
+export declare function runAffectedMutation(): 0 | 1;
+//# sourceMappingURL=affected.d.ts.map

package/dist/esm/mutation/affected.js

@@ -0,0 +1,36 @@
+import { execSync } from 'node:child_process';
+/**
+ * Run Stryker only on packages changed vs. the base branch.
+ * Returns 0 on success, 1 if any package fails its break threshold.
+ *
+ * Reads GITHUB_BASE_REF (set by GitHub Actions on pull_request events) to
+ * determine the base branch; falls back to "main".
+ */
+export function runAffectedMutation() {
+    const base = process.env.GITHUB_BASE_REF ?? 'main';
+    const changed = execSync(`git diff --name-only origin/${base}...HEAD`)
+        .toString()
+        .trim()
+        .split('\n')
+        .filter(Boolean);
+    const affectedPkgs = new Set();
+    for (const file of changed) {
+        const match = file.match(/^(apps\/[^/]+|packages\/[^/]+)\//);
+        if (match)
+            affectedPkgs.add(match[1]);
+    }
+    if (affectedPkgs.size === 0) {
+        console.log('No affected packages — skipping mutation.');
+        return 0;
+    }
+    for (const pkg of affectedPkgs) {
+        try {
+            execSync(`pnpm --filter ./${pkg} mutation --if-present`, { stdio: 'inherit' });
+        }
+        catch {
+            return 1;
+        }
+    }
+    return 0;
+}
+//# sourceMappingURL=affected.js.map

package/dist/esm/package.json

@@ -48,6 +48,14 @@
     "#mcp/*": "./mcp/*.js",
     "#content/*.js": "./content/*.js",
     "#content/*": "./content/*.js",
+    "#tool-runtime": "./tool-runtime/index.js",
+    "#tool-runtime/*.js": "./tool-runtime/*.js",
+    "#tool-runtime/*": "./tool-runtime/*.js",
+    "#wp-extension": "./wp-extension/index.js",
+    "#wp-extension/*.js": "./wp-extension/*.js",
+    "#wp-extension/*": "./wp-extension/*.js",
+    "#runtime/*.js": "./runtime/*.js",
+    "#runtime/*": "./runtime/*.js",
     "#output-transforms/*.js": "./output-transforms/*.js",
     "#output-transforms/*": "./output-transforms/*.js",
     "#lint/*.js": "./lint/*.js",

package/dist/esm/runtime/package-version.d.ts

@@ -0,0 +1,2 @@
+export declare function readOwnedPackageVersion(moduleUrl: string): string;
+//# sourceMappingURL=package-version.d.ts.map

package/dist/esm/runtime/package-version.js

@@ -0,0 +1,43 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const ACCEPTED_PACKAGE_PREFIXES = ['@webpresso/agent-kit', 'webpresso'];
+const MAX_UPWARD_LEVELS = 8;
+function matchesOwnedPackageName(name) {
+    return (typeof name === 'string' &&
+        ACCEPTED_PACKAGE_PREFIXES.some((prefix) => name === prefix || name.startsWith(`${prefix}-`)));
+}
+function readVersionFromDir(startDir) {
+    let dir = path.resolve(startDir);
+    for (let i = 0; i < MAX_UPWARD_LEVELS; i++) {
+        const candidate = path.join(dir, 'package.json');
+        if (existsSync(candidate)) {
+            try {
+                const parsed = JSON.parse(readFileSync(candidate, 'utf8'));
+                if (matchesOwnedPackageName(parsed.name) && typeof parsed.version === 'string') {
+                    return parsed.version;
+                }
+            }
+            catch {
+                // keep walking
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+export function readOwnedPackageVersion(moduleUrl) {
+    const fromModule = readVersionFromDir(path.dirname(fileURLToPath(moduleUrl)));
+    if (fromModule)
+        return fromModule;
+    if (process.execPath) {
+        const fromExec = readVersionFromDir(path.dirname(process.execPath));
+        if (fromExec)
+            return fromExec;
+    }
+    return '0.0.0';
+}
+//# sourceMappingURL=package-version.js.map

package/dist/esm/test/command-builder.d.ts

@@ -1,4 +1,5 @@
 import type { ResolvedTestTarget } from './target-resolver.js';
+import { type ManagedRunnerOutputPolicy } from '#tool-runtime';
 export interface CommandConfig {
     command: string;
     args: string[];
@@ -6,6 +7,7 @@ export interface CommandConfig {
 }
 export type VpRunLogMode = 'interleaved' | 'labeled' | 'grouped';
 export interface TestCommandOptions {
+    cwd?: string;
     watch?: boolean;
     coverage?: boolean;
     testNamePattern?: string;
@@ -17,6 +19,8 @@ export interface TestCommandOptions {
     concurrencyLimit?: number;
     log?: VpRunLogMode;
     passthrough?: readonly string[];
+    filterOutput?: boolean;
+    outputPolicy?: ManagedRunnerOutputPolicy;
 }
 export declare function buildTestCommand(target: ResolvedTestTarget, options?: TestCommandOptions): CommandConfig;
 export declare function buildVpTestCommand(filters: readonly string[], options?: TestCommandOptions): CommandConfig;

package/dist/esm/test/command-builder.js

@@ -1,4 +1,9 @@
+import { getManagedRunner } from '#tool-runtime';
+import { getPackageScript, isRecursiveWpScript, packageUsesVitest } from '#cli/package-scripts.js';
 export function buildTestCommand(target, options = {}) {
+    if (target.type === 'all' && shouldBypassRecursiveWpTest(options.cwd ?? process.cwd())) {
+        return buildVitestCommand([], options);
+    }
     if (target.type === 'file') {
         return buildVitestCommand(target.values, options);
     }
@@ -7,7 +12,7 @@ export function buildTestCommand(target, options = {}) {
 export function buildVpTestCommand(filters, options = {}) {
     const task = getVpTestTask(options);
     const resolvedFilters = filters.map((filter) => formatVpRunFilter(filter, task));
-    const explicitTargets = resolvedFilters.every(isExplicitVpTaskTarget);
+    const explicitTargets = resolvedFilters.length > 0 && resolvedFilters.every(isExplicitVpTaskTarget);
     const args = ['run', ...resolvedFilters];
     appendVpRunOptions(args, options);
     if (!explicitTargets) {
@@ -17,8 +22,14 @@ export function buildVpTestCommand(filters, options = {}) {
     if (passthrough.length > 0) {
         args.push('--', ...passthrough);
     }
+    const resolution = getManagedRunner('vp', {
+        outputPolicy: resolveOutputPolicy(options.outputPolicy, options.filterOutput),
+    });
     const env = buildVpRunEnv(options);
-    return env ? { command: 'vp', args, env } : { command: 'vp', args };
+    const mergedArgs = [...resolution.args, ...args];
+    return env
+        ? { command: resolution.command, args: mergedArgs, env }
+        : { command: resolution.command, args: mergedArgs };
 }
 export function buildVitestCommand(files, options = {}) {
     const args = [options.watch ? '--watch' : 'run'];
@@ -40,7 +51,10 @@ export function buildVitestCommand(files, options = {}) {
         args.push('--config', configFile);
     }
     args.push(...buildVitestPassthrough(options), ...testFiles);
-    return { command: 'vitest', args };
+    const resolution = getManagedRunner('vitest', {
+        outputPolicy: resolveOutputPolicy(options.outputPolicy, options.filterOutput),
+    });
+    return { command: resolution.command, args: [...resolution.args, ...args] };
 }
 export function getVpTestTask(options) {
     if (options.mutation)
@@ -95,4 +109,15 @@ function buildVitestPassthrough(options) {
 function isVitestConfigFile(file) {
     return /^vitest(?:\.[\w-]+)?\.config\.(?:ts|mts|cts|js|mjs|cjs)$/u.test(file);
 }
+function resolveOutputPolicy(outputPolicy, filterOutput) {
+    if (outputPolicy)
+        return outputPolicy;
+    return filterOutput === false ? 'structured' : 'rtk-filtered';
+}
+function shouldBypassRecursiveWpTest(cwd) {
+    const testScript = getPackageScript(cwd, 'test');
+    if (!testScript || !isRecursiveWpScript(testScript, 'test'))
+        return false;
+    return packageUsesVitest(cwd);
+}
 //# sourceMappingURL=command-builder.js.map

package/dist/esm/test-helpers/hermetic-env.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Hermetic environment baseline for the whole test suite.
+ *
+ * agent-kit's suite is routinely run *inside* an agent session (Claude Code,
+ * Codex), and those sessions export ambient variables that the production code
+ * legitimately honors at runtime:
+ *
+ * - `CLAUDE_PROJECT_DIR` — `resolveProjectRoot` (src/mcp/tools/_shared/project-root.ts)
+ *   ranks this above the discovered cwd, so a leaked value makes blueprint-server
+ *   tests target the real repo + its shared SQLite DB instead of their temp dir,
+ *   producing wrong-data assertions and lock-contention timeouts.
+ * - `WP_SKIP_UPDATE_CHECK` — suppresses the managed-CLI refresh spawn that the
+ *   init scaffolder tests assert fires; a leaked value (exported by the shell or
+ *   left behind by a sibling test file under the shared forks worker) drops the
+ *   expected spawn and fails spawn-count assertions.
+ *
+ * The fix is isolation, not changing the runtime precedence: reset these before
+ * every test so the suite is deterministic regardless of the launching
+ * environment. Tests that exercise these variables set them explicitly in their
+ * own body (which runs after this hook), so behavior coverage is unaffected.
+ */
+export declare const LEAKY_ENV_KEYS: readonly ["CLAUDE_PROJECT_DIR", "WP_SKIP_UPDATE_CHECK"];
+/** Delete every agent-session-leaked env var so each test starts hermetic. */
+export declare function resetLeakyEnv(): void;
+//# sourceMappingURL=hermetic-env.d.ts.map

package/dist/esm/test-helpers/hermetic-env.js

@@ -0,0 +1,31 @@
+import { beforeEach } from 'vitest';
+/**
+ * Hermetic environment baseline for the whole test suite.
+ *
+ * agent-kit's suite is routinely run *inside* an agent session (Claude Code,
+ * Codex), and those sessions export ambient variables that the production code
+ * legitimately honors at runtime:
+ *
+ * - `CLAUDE_PROJECT_DIR` — `resolveProjectRoot` (src/mcp/tools/_shared/project-root.ts)
+ *   ranks this above the discovered cwd, so a leaked value makes blueprint-server
+ *   tests target the real repo + its shared SQLite DB instead of their temp dir,
+ *   producing wrong-data assertions and lock-contention timeouts.
+ * - `WP_SKIP_UPDATE_CHECK` — suppresses the managed-CLI refresh spawn that the
+ *   init scaffolder tests assert fires; a leaked value (exported by the shell or
+ *   left behind by a sibling test file under the shared forks worker) drops the
+ *   expected spawn and fails spawn-count assertions.
+ *
+ * The fix is isolation, not changing the runtime precedence: reset these before
+ * every test so the suite is deterministic regardless of the launching
+ * environment. Tests that exercise these variables set them explicitly in their
+ * own body (which runs after this hook), so behavior coverage is unaffected.
+ */
+export const LEAKY_ENV_KEYS = ['CLAUDE_PROJECT_DIR', 'WP_SKIP_UPDATE_CHECK'];
+/** Delete every agent-session-leaked env var so each test starts hermetic. */
+export function resetLeakyEnv() {
+    for (const key of LEAKY_ENV_KEYS) {
+        delete process.env[key];
+    }
+}
+beforeEach(resetLeakyEnv);
+//# sourceMappingURL=hermetic-env.js.map

package/dist/esm/tool-runtime/index.d.ts

@@ -0,0 +1,5 @@
+import { type ManagedRunnerResolution, type ResolveRunnerOptions, type ManagedRunnerOutputPolicy } from './resolve-runner.js';
+export declare function getManagedRunner(tool: string, options?: ResolveRunnerOptions): ManagedRunnerResolution;
+export declare function clearManagedRunnerCache(): void;
+export type { ManagedRunnerOutputPolicy, ManagedRunnerResolution, ResolveRunnerOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/tool-runtime/index.js

@@ -0,0 +1,24 @@
+import { resolveRunner, } from './resolve-runner.js';
+const runtimeCache = new Map();
+function cacheKey(tool, options) {
+    const outputPolicy = options.outputPolicy ?? (options.filterOutput === false ? 'structured' : 'rtk-filtered');
+    return JSON.stringify({
+        tool,
+        outputPolicy,
+        fallbackCommand: options.fallbackCommand ?? null,
+        fallbackArgs: options.fallbackArgs ?? [],
+    });
+}
+export function getManagedRunner(tool, options = {}) {
+    const key = cacheKey(tool, options);
+    const cached = runtimeCache.get(key);
+    if (cached)
+        return cached;
+    const resolved = resolveRunner(tool, options);
+    runtimeCache.set(key, resolved);
+    return resolved;
+}
+export function clearManagedRunnerCache() {
+    runtimeCache.clear();
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/tool-runtime/resolve-runner.d.ts

@@ -0,0 +1,16 @@
+export interface ManagedRunnerResolution {
+    readonly tool: string;
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly source: 'managed' | 'fallback';
+}
+export type ManagedRunnerOutputPolicy = 'rtk-filtered' | 'structured';
+export interface ResolveRunnerOptions {
+    readonly fallbackCommand?: string;
+    readonly fallbackArgs?: readonly string[];
+    /** @deprecated Use {@link outputPolicy} for explicit output routing. */
+    readonly filterOutput?: boolean;
+    readonly outputPolicy?: ManagedRunnerOutputPolicy;
+}
+export declare function resolveRunner(tool: string, options?: ResolveRunnerOptions): ManagedRunnerResolution;
+//# sourceMappingURL=resolve-runner.d.ts.map

package/dist/esm/tool-runtime/resolve-runner.js

@@ -0,0 +1,42 @@
+const MANAGED_TOOL_PREFIX = {
+    oxfmt: { command: 'vp', args: ['exec', 'oxfmt'] },
+    playwright: { command: 'vp', args: ['exec', 'playwright'] },
+    tsc: { command: 'vp', args: ['exec', 'tsc'] },
+    vitest: { command: 'vp', args: ['exec', 'vitest'] },
+    vp: { command: 'vp', args: [] },
+};
+function withOptionalRtk(resolution, outputPolicy) {
+    if (outputPolicy !== 'rtk-filtered')
+        return resolution;
+    return {
+        ...resolution,
+        command: 'rtk',
+        args: [resolution.command, ...resolution.args],
+    };
+}
+export function resolveRunner(tool, options = {}) {
+    const normalized = tool.trim();
+    if (!normalized) {
+        throw new Error('tool runtime resolution requires a non-empty tool name');
+    }
+    const outputPolicy = options.outputPolicy ?? (options.filterOutput === false ? 'structured' : 'rtk-filtered');
+    const managed = MANAGED_TOOL_PREFIX[normalized];
+    if (managed) {
+        return withOptionalRtk({
+            tool: normalized,
+            command: managed.command,
+            args: [...managed.args],
+            source: 'managed',
+        }, outputPolicy);
+    }
+    if (options.fallbackCommand) {
+        return withOptionalRtk({
+            tool: normalized,
+            command: options.fallbackCommand,
+            args: [...(options.fallbackArgs ?? [])],
+            source: 'fallback',
+        }, outputPolicy);
+    }
+    throw new Error(`No managed runtime runner is defined for tool "${normalized}"`);
+}
+//# sourceMappingURL=resolve-runner.js.map

package/dist/esm/typecheck/index.js

@@ -12,6 +12,7 @@ import { join } from 'node:path';
 import { globSync } from 'glob';
 import { isRunFailure, runCommand } from '#mcp/tools/_shared/run-command';
 import { resolveProjectRoot } from '#mcp/tools/_shared/project-root';
+import { getManagedRunner } from '#tool-runtime';
 const DEFAULT_TYPECHECK_TIMEOUT_MS = 10 * 60 * 1_000;
 // Matches both standard tsc formats:
 //   src/foo.ts(5,12): error TS2304: Cannot find name 'bar'.
@@ -99,11 +100,12 @@ export async function runTypecheck(options = {}) {
     const targets = options.packages && options.packages.length > 0 ? options.packages : null;
     const workspaceGlobs = targets ? readWorkspaceGlobs(cwd) : null;
     const runs = [];
+    const resolution = getManagedRunner('tsc', { outputPolicy: 'structured' });
     if (targets) {
         for (const pkg of targets) {
             const resolvedTarget = resolveTypecheckTarget(cwd, pkg, workspaceGlobs);
             const tsconfig = join(resolvedTarget, 'tsconfig.json');
-            const outcome = await runCommand('tsc', ['--noEmit', '-p', tsconfig], runOptions);
+            const outcome = await runCommand(resolution.command, [...resolution.args, '--noEmit', '-p', tsconfig], runOptions);
             if (isRunFailure(outcome)) {
                 throw outcome.error;
             }
@@ -111,7 +113,7 @@ export async function runTypecheck(options = {}) {
         }
     }
     else {
-        const outcome = await runCommand('tsc', ['--noEmit'], runOptions);
+        const outcome = await runCommand(resolution.command, [...resolution.args, '--noEmit'], runOptions);
         if (isRunFailure(outcome)) {
             throw outcome.error;
         }

package/dist/esm/wp-extension/index.d.ts

@@ -0,0 +1,50 @@
+import type { CAC } from 'cac';
+export interface WpExtensionContext {
+    readonly cwd: string;
+    readonly env: NodeJS.ProcessEnv;
+}
+export interface WpExtensionCommandV1 {
+    readonly name: string;
+    readonly description: string;
+    readonly register: (cli: CAC) => void;
+}
+export interface WpExtensionAliasV1 {
+    readonly name: string;
+    readonly commandName: string;
+}
+export interface WpExtensionV1 {
+    readonly apiVersion: '1';
+    readonly name: string;
+    readonly version: string;
+    readonly hostRange: string;
+    readonly detect: (context: WpExtensionContext) => boolean | Promise<boolean>;
+    readonly commands: readonly WpExtensionCommandV1[];
+    readonly aliases?: readonly WpExtensionAliasV1[];
+}
+export interface LoadedWpExtension {
+    readonly packageName: string;
+    readonly specifier: string;
+    readonly extension?: WpExtensionV1;
+    readonly compatible: boolean;
+    readonly detected: boolean;
+    readonly warnings: readonly string[];
+}
+export interface WpExtensionAliasResolution {
+    readonly aliases: ReadonlyMap<string, WpExtensionAliasV1>;
+    readonly warnings: readonly string[];
+    readonly acceptedCommandNames: readonly string[];
+}
+export interface LoadWpExtensionsOptions {
+    readonly cwd?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly hostVersion: string;
+    readonly importModule?: (specifier: string) => Promise<{
+        default?: unknown;
+    }>;
+    readonly resolveFrom?: (fromFile: string, specifier: string) => string;
+    readonly readJsonFile?: (path: string) => unknown;
+}
+export declare function loadWpExtensions(options: LoadWpExtensionsOptions): Promise<readonly LoadedWpExtension[]>;
+export declare function resolveAcceptedExtensionAliases(extensions: readonly LoadedWpExtension[], baseCommands: Iterable<string>, acceptedCommandNames: Iterable<string>): WpExtensionAliasResolution;
+export declare function isWpExtensionV1(value: unknown): value is WpExtensionV1;
+//# sourceMappingURL=index.d.ts.map