@webpresso/agent-kit 0.25.0 → 0.26.0

package/dist/esm/deploy/schema.js

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+export const DEPLOY_PLAN_SCHEMA_VERSION = 1;
+const deployLaneSchema = z.union([
+    z.literal('dev'),
+    z.literal('preview_main'),
+    z.literal('prd'),
+    z.string().regex(/^preview_pr_\d+$/u, 'preview PR lanes must be preview_pr_<n>'),
+]);
+const envSchema = z.record(z.string(), z.string().optional());
+const commandStepSchema = z
+    .object({
+    kind: z.literal('command'),
+    id: z.string().min(1),
+    label: z.string().min(1).optional(),
+    command: z.string().min(1),
+    args: z.array(z.string()).optional(),
+    cwd: z.string().min(1).optional(),
+    env: envSchema.optional(),
+})
+    .strict();
+const managedToolStepSchema = z
+    .object({
+    kind: z.literal('managed-tool'),
+    id: z.string().min(1),
+    label: z.string().min(1).optional(),
+    tool: z.string().min(1),
+    args: z.array(z.string()).optional(),
+    cwd: z.string().min(1).optional(),
+    env: envSchema.optional(),
+})
+    .strict();
+const deployPlanSchema = z
+    .object({
+    schemaVersion: z.literal(DEPLOY_PLAN_SCHEMA_VERSION),
+    lane: deployLaneSchema,
+    provider: z.string().min(1),
+    requiredCredentials: z.array(z.string().min(1)),
+    steps: z.array(z.union([commandStepSchema, managedToolStepSchema])),
+})
+    .strict();
+export function isDeployLane(value) {
+    return deployLaneSchema.safeParse(value).success;
+}
+export function parseDeployLane(value) {
+    const result = deployLaneSchema.safeParse(value);
+    if (!result.success) {
+        throw new Error(`Invalid deploy lane "${value}". Use dev, preview_main, preview_pr_<n>, or prd.`);
+    }
+    return result.data;
+}
+export function validateDeployPlan(plan) {
+    const result = deployPlanSchema.safeParse(plan);
+    if (!result.success) {
+        const issues = result.error.issues
+            .map((issue) => `  - ${issue.path.join('.') || '<root>'}: ${issue.message}`)
+            .join('\n');
+        throw new Error(`Invalid deploy plan:\n${issues}`);
+    }
+    return result.data;
+}
+//# sourceMappingURL=schema.js.map

package/dist/esm/deploy/types.d.ts

@@ -0,0 +1,43 @@
+export type DeployLane = 'dev' | 'preview_main' | `preview_pr_${number}` | 'prd';
+export type DeployStep = {
+    readonly kind: 'command';
+    readonly id: string;
+    readonly label?: string;
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly cwd?: string;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+} | {
+    readonly kind: 'managed-tool';
+    readonly id: string;
+    readonly label?: string;
+    readonly tool: string;
+    readonly args?: readonly string[];
+    readonly cwd?: string;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+};
+export interface DeployPlan {
+    readonly schemaVersion: 1;
+    readonly lane: DeployLane;
+    readonly provider: string;
+    readonly requiredCredentials: readonly string[];
+    readonly steps: readonly DeployStep[];
+}
+export interface DeployRequest {
+    readonly cwd: string;
+    readonly lane: DeployLane;
+    readonly dryRun: boolean;
+    readonly env: NodeJS.ProcessEnv;
+    readonly cloudflare?: unknown;
+}
+export interface DeployAdapter {
+    readonly createPlan: (request: DeployRequest) => DeployPlan | Promise<DeployPlan>;
+}
+export interface LoadedDeployAdapter {
+    readonly adapter: DeployAdapter;
+    readonly config: import('#e2e/config.js').WebpressoConfig;
+    readonly configPath: string;
+    readonly moduleSpecifier: string;
+    readonly exportName: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/deploy/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -15,13 +15,18 @@ function buildPlaywrightCommand(options) {
     if (!step.configPath) {
         throw new Error(`Step ${step.logName} uses runner "playwright" but does not define configPath.`);
     }
-    const { baseDir, configArg, files } = resolveRunnerPaths(step.configPath, options.files ?? []);
+    const paths = resolveRunnerPaths(step.configPath, options.files ?? []);
     const resolution = withBaseDir(getManagedRunner('playwright', {
         outputPolicy: resolveOutputPolicy(options.outputPolicy, options.filterOutput),
-    }), baseDir);
-    const args = [...resolution.args, 'test', '--config', configArg];
+    }), paths.baseDir);
+    const args = [
+        ...resolution.args,
+        'test',
+        '--config',
+        resolution.usesBaseDir ? paths.relativeConfigArg : paths.rootConfigArg,
+    ];
     appendPlaywrightFlags(args, options);
-    args.push(...(step.fixedArgs ?? []), ...files, ...(options.passthrough ?? []));
+    args.push(...(step.fixedArgs ?? []), ...(resolution.usesBaseDir ? paths.relativeFiles : paths.rootFiles), ...(options.passthrough ?? []));
     return { command: resolution.command, args };
 }
 function buildVitestE2eCommand(options) {
@@ -29,15 +34,20 @@ function buildVitestE2eCommand(options) {
     if (!step.configPath) {
         throw new Error(`Step ${step.logName} uses runner "vitest" but does not define configPath.`);
     }
-    const { baseDir, configArg, files } = resolveRunnerPaths(step.configPath, options.files ?? []);
+    const paths = resolveRunnerPaths(step.configPath, options.files ?? []);
     const resolution = withBaseDir(getManagedRunner('vitest', {
         outputPolicy: resolveOutputPolicy(options.outputPolicy, options.filterOutput),
-    }), baseDir);
-    const args = [...resolution.args, 'run', '--config', configArg];
+    }), paths.baseDir);
+    const args = [
+        ...resolution.args,
+        'run',
+        '--config',
+        resolution.usesBaseDir ? paths.relativeConfigArg : paths.rootConfigArg,
+    ];
     if (options.workers !== undefined) {
         args.push('--poolOptions.threads.maxThreads', String(options.workers));
     }
-    args.push(...(step.fixedArgs ?? []), ...files, ...(options.passthrough ?? []));
+    args.push(...(step.fixedArgs ?? []), ...(resolution.usesBaseDir ? paths.relativeFiles : paths.rootFiles), ...(options.passthrough ?? []));
     return { command: resolution.command, args };
 }
 function buildCustomCommand(options) {
@@ -79,19 +89,27 @@ function appendPlaywrightFlags(args, options) {
 function resolveRunnerPaths(configPath, files) {
     const normalizedConfigPath = configPath.replace(/\\/gu, '/');
     const baseDir = path.posix.dirname(normalizedConfigPath);
-    const configArg = path.posix.basename(normalizedConfigPath);
+    const normalizedFiles = files.map((file) => file.replace(/\\/gu, '/'));
     if (baseDir === '.') {
         return {
             baseDir,
-            configArg: normalizedConfigPath,
-            files: [...files],
+            rootConfigArg: normalizedConfigPath,
+            rootFiles: normalizedFiles,
+            relativeConfigArg: normalizedConfigPath,
+            relativeFiles: normalizedFiles,
         };
     }
     return {
         baseDir,
-        configArg,
-        files: files.map((file) => {
-            const normalizedFile = file.replace(/\\/gu, '/');
+        rootConfigArg: normalizedConfigPath,
+        rootFiles: normalizedFiles.map((normalizedFile) => {
+            if (path.posix.isAbsolute(normalizedFile) || normalizedFile.startsWith(`${baseDir}/`)) {
+                return normalizedFile;
+            }
+            return `${baseDir}/${normalizedFile}`;
+        }),
+        relativeConfigArg: path.posix.basename(normalizedConfigPath),
+        relativeFiles: normalizedFiles.map((normalizedFile) => {
             if (path.posix.isAbsolute(normalizedFile) || normalizedFile.startsWith(`${baseDir}/`)) {
                 return path.posix.relative(baseDir, normalizedFile);
             }
@@ -100,13 +118,13 @@ function resolveRunnerPaths(configPath, files) {
     };
 }
 function withBaseDir(resolution, baseDir) {
-    if (baseDir === '.') {
-        return { command: resolution.command, args: [...resolution.args] };
-    }
+    if (baseDir === '.')
+        return { command: resolution.command, args: [...resolution.args], usesBaseDir: true };
     if (resolution.command === 'vp') {
         return {
             command: resolution.command,
             args: ['--dir', baseDir, ...resolution.args],
+            usesBaseDir: true,
         };
     }
     const [wrappedCommand, ...wrappedArgs] = resolution.args;
@@ -114,9 +132,10 @@ function withBaseDir(resolution, baseDir) {
         return {
             command: resolution.command,
             args: ['vp', '--dir', baseDir, ...wrappedArgs],
+            usesBaseDir: true,
         };
     }
-    return { command: resolution.command, args: [...resolution.args] };
+    return { command: resolution.command, args: [...resolution.args], usesBaseDir: false };
 }
 function resolveOutputPolicy(outputPolicy, filterOutput) {
     if (outputPolicy)

package/dist/esm/e2e/config.d.ts

@@ -16,6 +16,8 @@ declare const webpressoConfigSchema: z.ZodObject<{
         hostAdapterExport: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     deploy: z.ZodOptional<z.ZodObject<{
+        adapterModule: z.ZodOptional<z.ZodString>;
+        adapterExport: z.ZodOptional<z.ZodString>;
         cloudflare: z.ZodOptional<z.ZodObject<{
             lanes: z.ZodObject<{
                 dev: z.ZodObject<{

package/dist/esm/e2e/config.js

@@ -51,7 +51,10 @@ const cloudflareDurableObjectBindingSchema = z
     .object({
     name: z.string().min(1, 'durableObjectBindings[].name must not be empty.'),
     className: z.string().min(1, 'durableObjectBindings[].className must not be empty.'),
-    scriptName: z.string().min(1, 'durableObjectBindings[].scriptName must not be empty.').optional(),
+    scriptName: z
+        .string()
+        .min(1, 'durableObjectBindings[].scriptName must not be empty.')
+        .optional(),
 })
     .strict();
 const cloudflareTargetSchema = z
@@ -129,6 +132,8 @@ const cloudflareDeployConfigSchema = z
     .strict();
 const deployWebpressoConfigSchema = z
     .object({
+    adapterModule: z.string().min(1, 'deploy.adapterModule must not be empty.').optional(),
+    adapterExport: z.string().min(1, 'deploy.adapterExport must not be empty.').optional(),
     cloudflare: cloudflareDeployConfigSchema.optional(),
 })
     .strict();

package/dist/esm/hooks/pretool-guard/dev-routing.d.ts

@@ -15,7 +15,13 @@ export interface RouteDecision {
 export declare function normalizeCommandForRouting(command: string): string;
 export declare function extractRoutableCommandsFromToolInput(input: {
     tool_name?: string;
+    toolName?: string;
+    tool?: string;
+    name?: string;
     tool_input?: Record<string, unknown>;
+    toolInput?: Record<string, unknown>;
+    input?: Record<string, unknown>;
+    arguments?: Record<string, unknown>;
 }): string[];
 export declare function routeCommand(command: string, _sessionId?: string): RouteDecision | null;
 //# sourceMappingURL=dev-routing.d.ts.map

package/dist/esm/hooks/pretool-guard/dev-routing.js

@@ -585,9 +585,10 @@ function isContextModeTool(toolName) {
     return /(?:^|[._-]|__)ctx_(?:batch_)?execute$/u.test(toolName);
 }
 export function extractRoutableCommandsFromToolInput(input) {
-    if (!isContextModeTool(input.tool_name))
+    const toolName = input.tool_name ?? input.toolName ?? input.tool ?? input.name;
+    if (!isContextModeTool(toolName))
         return [];
-    const toolInput = input.tool_input;
+    const toolInput = input.tool_input ?? input.toolInput ?? input.input ?? input.arguments;
     if (!toolInput || typeof toolInput !== 'object')
         return [];
     const commands = [];

package/dist/esm/hooks/pretool-guard/runner.js

@@ -101,23 +101,28 @@ export function processValidation(inputJson) {
     const input = parseToolInput(inputJson);
     const command = isBashInput(input) ? getCommand(input) : null;
     const routableCommands = [
-        ...(command ? [command] : []),
-        ...extractRoutableCommandsFromToolInput(input),
+        ...(command ? [{ command, alreadySandboxed: false }] : []),
+        ...extractRoutableCommandsFromToolInput(input).map((routedCommand) => ({
+            command: routedCommand,
+            alreadySandboxed: true,
+        })),
     ];
     for (const routedCommand of routableCommands) {
-        const decision = routeCommand(routedCommand);
+        const decision = routeCommand(routedCommand.command);
         if (decision !== null) {
             if (decision.action.action === 'deny') {
                 // Phase 1: Dev-workflow routing — always authoritative (MCP-first)
                 writeDenyDecision(decision.action.guidance);
                 process.exit(0);
             }
-            else if (decision.action.action === 'sandbox') {
-                // Phase 2: Context-mode sandbox routing — always fires
+            else if (decision.action.action === 'sandbox' && !routedCommand.alreadySandboxed) {
+                // Phase 2: Context-mode sandbox routing — fire only for raw tool calls.
+                // Commands already inside ctx_execute/ctx_batch_execute are already in
+                // the requested sandbox; re-denying them creates a ctx_execute loop.
                 writeDenyDecision(decision.action.guidance);
                 process.exit(0);
             }
-            // 'passthrough' → fall through to Phase 3
+            // 'passthrough' or already-sandboxed sandbox redirects → Phase 3
         }
     }
     // Phase 3: Security validators (existing pipeline)

package/dist/esm/mcp/tools/_shared/runner-failure.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared runner-failure bounding for the check tools (`wp_typecheck`, `wp_lint`,
+ * `wp_test`).
+ *
+ * A check that exits non-zero but yields ZERO parseable structured results is a
+ * runner/launcher failure — e.g. a missing `vp`/`tsc`/test-runner binary
+ * printing a Node `MODULE_NOT_FOUND` stack — not a genuine type/lint/test
+ * failure. Left alone, that raw output falls through each tool's transform to
+ * the generic passthrough (clipped only at 4000 chars), so it can become the
+ * leaf's measured `bytes` and blow the compact QA evidence budget (≤800/leaf),
+ * shipping an unbounded blob masquerading as tool output.
+ *
+ * `isRunnerFailure` detects the case from a count the caller already has (tsc
+ * errors / oxlint issues / parsed test failures), so it never misclassifies a
+ * real failure that produced structured results. `boundRunnerFailureEvidence`
+ * clips the evidence well under the budget and persists the full output to a log
+ * (truthful, not dropped). The caller keeps `passed: false` so the failure stays
+ * loud.
+ */
+import type { TransformResult } from '#output-transforms/index';
+export declare function stripTransform(result: TransformResult): Omit<TransformResult, 'transform'>;
+export declare function isRunnerFailure(input: {
+    passed: boolean;
+    timedOut: boolean;
+    aborted: boolean;
+    parsedCount: number;
+    output: string;
+}): boolean;
+export declare function boundRunnerFailureEvidence(output: string, toolName: string): Omit<TransformResult, 'transform'>;
+//# sourceMappingURL=runner-failure.d.ts.map

package/dist/esm/mcp/tools/_shared/runner-failure.js

@@ -0,0 +1,45 @@
+/**
+ * Shared runner-failure bounding for the check tools (`wp_typecheck`, `wp_lint`,
+ * `wp_test`).
+ *
+ * A check that exits non-zero but yields ZERO parseable structured results is a
+ * runner/launcher failure — e.g. a missing `vp`/`tsc`/test-runner binary
+ * printing a Node `MODULE_NOT_FOUND` stack — not a genuine type/lint/test
+ * failure. Left alone, that raw output falls through each tool's transform to
+ * the generic passthrough (clipped only at 4000 chars), so it can become the
+ * leaf's measured `bytes` and blow the compact QA evidence budget (≤800/leaf),
+ * shipping an unbounded blob masquerading as tool output.
+ *
+ * `isRunnerFailure` detects the case from a count the caller already has (tsc
+ * errors / oxlint issues / parsed test failures), so it never misclassifies a
+ * real failure that produced structured results. `boundRunnerFailureEvidence`
+ * clips the evidence well under the budget and persists the full output to a log
+ * (truthful, not dropped). The caller keeps `passed: false` so the failure stays
+ * loud.
+ */
+import { clipRawOutput } from './result.js';
+const RUNNER_FAILURE_EVIDENCE_BUDGET = 600;
+export function stripTransform(result) {
+    const { transform: _transform, ...rest } = result;
+    return rest;
+}
+export function isRunnerFailure(input) {
+    return (!input.passed &&
+        !input.timedOut &&
+        !input.aborted &&
+        input.parsedCount === 0 &&
+        input.output.trim().length > 0);
+}
+export function boundRunnerFailureEvidence(output, toolName) {
+    const clipped = clipRawOutput(output, RUNNER_FAILURE_EVIDENCE_BUDGET, { toolName });
+    const rawBytes = Buffer.byteLength(output);
+    const bytes = Buffer.byteLength(clipped.rawOutput ?? '');
+    return {
+        ...clipped,
+        failures: [],
+        tier: 3,
+        bytes,
+        tokensSaved: Math.max(0, rawBytes - bytes),
+    };
+}
+//# sourceMappingURL=runner-failure.js.map

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

@@ -17,6 +17,7 @@ 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 { boundRunnerFailureEvidence, isRunnerFailure, stripTransform, } from './_shared/runner-failure.js';
 import { isRunFailure, runCommand } from './_shared/run-command.js';
 const inputSchema = z.object({
     cwd: z.string().optional(),
@@ -115,6 +116,8 @@ function summarizeTypecheckResult(options) {
         return 'typecheck timed out';
     if (options.aborted)
         return 'typecheck aborted';
+    if (options.failedWithoutDiagnostics)
+        return 'typecheck failed to run (no diagnostics parsed)';
     if (options.passed)
         return 'typecheck passed';
     return `typecheck failed with ${options.errorCount} error${options.errorCount === 1 ? '' : 's'}`;
@@ -169,12 +172,26 @@ const tool = {
         const passed = runs.every((r) => r.exitCode === 0);
         const timedOut = runs.some((r) => r.timedOut);
         const aborted = runs.some((r) => r.aborted);
-        const { transform: _transform, ...compact } = applyOutputTransform([combinedStdout, combinedStderr].filter(Boolean).join(''), {
-            toolName: 'wp_typecheck',
+        const combinedOutput = [combinedStdout, combinedStderr].filter(Boolean).join('');
+        const failedWithoutDiagnostics = isRunnerFailure({
+            passed,
+            timedOut,
+            aborted,
+            parsedCount: errors.length,
+            output: combinedOutput,
         });
+        const compact = failedWithoutDiagnostics
+            ? boundRunnerFailureEvidence(combinedOutput, 'wp_typecheck')
+            : stripTransform(applyOutputTransform(combinedOutput, { toolName: 'wp_typecheck' }));
         const payload = {
             passed,
-            summary: summarizeTypecheckResult({ passed, errorCount: errors.length, timedOut, aborted }),
+            summary: summarizeTypecheckResult({
+                passed,
+                errorCount: errors.length,
+                timedOut,
+                aborted,
+                failedWithoutDiagnostics,
+            }),
             counts: { errorCount: errors.length },
             details: { errors },
             ...compact,

package/dist/esm/package.json

@@ -95,6 +95,8 @@
     "#types/execution-backend": "./blueprint/types/execution-backend.js",
     "#types/execution-backend.js": "./blueprint/types/execution-backend.js",
     "#*.js": "./blueprint/*.js",
-    "#*": "./blueprint/*.js"
+    "#*": "./blueprint/*.js",
+    "#deploy/*.js": "./deploy/*.js",
+    "#deploy/*": "./deploy/*.js"
   }
 }

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

@@ -25,5 +25,6 @@ export interface TestCommandOptions {
 export declare function buildTestCommand(target: ResolvedTestTarget, options?: TestCommandOptions): CommandConfig;
 export declare function buildVpTestCommand(filters: readonly string[], options?: TestCommandOptions): CommandConfig;
 export declare function buildVitestCommand(files: readonly string[], options?: TestCommandOptions): CommandConfig;
+export declare function buildStrykerCommand(options?: TestCommandOptions): CommandConfig;
 export declare function getVpTestTask(options: Pick<TestCommandOptions, 'mutation' | 'workers' | 'watch'>): string;
 //# sourceMappingURL=command-builder.d.ts.map

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

@@ -1,8 +1,8 @@
 import { getManagedRunner } from '#tool-runtime';
-import { getPackageScript, isRecursiveWpScript, packageUsesVitest } from '#cli/package-scripts.js';
+import { getPackageScript, isRecursiveWpScript } from '#cli/package-scripts.js';
 export function buildTestCommand(target, options = {}) {
     if (target.type === 'all' && shouldBypassRecursiveWpTest(options.cwd ?? process.cwd())) {
-        return buildVitestCommand([], options);
+        return options.mutation ? buildStrykerCommand(options) : buildVitestCommand([], options);
     }
     if (target.type === 'file') {
         return buildVitestCommand(target.values, options);
@@ -56,6 +56,12 @@ export function buildVitestCommand(files, options = {}) {
     });
     return { command: resolution.command, args: [...resolution.args, ...args] };
 }
+export function buildStrykerCommand(options = {}) {
+    const resolution = getManagedRunner('stryker', {
+        outputPolicy: resolveOutputPolicy(options.outputPolicy, options.filterOutput),
+    });
+    return { command: resolution.command, args: [...resolution.args, 'run', 'stryker.config.ts'] };
+}
 export function getVpTestTask(options) {
     if (options.mutation)
         return 'test:mutation';
@@ -116,8 +122,6 @@ function resolveOutputPolicy(outputPolicy, filterOutput) {
 }
 function shouldBypassRecursiveWpTest(cwd) {
     const testScript = getPackageScript(cwd, 'test');
-    if (!testScript || !isRecursiveWpScript(testScript, 'test'))
-        return false;
-    return packageUsesVitest(cwd);
+    return Boolean(testScript && isRecursiveWpScript(testScript, 'test'));
 }
 //# sourceMappingURL=command-builder.js.map

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

@@ -1,9 +1,18 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
 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'] },
+    oxfmt: { packageName: 'oxfmt', binName: 'oxfmt' },
+    oxlint: { packageName: 'oxlint', binName: 'oxlint' },
+    playwright: { packageName: '@playwright/test', binName: 'playwright' },
+    stryker: { packageName: '@stryker-mutator/core', binName: 'stryker' },
+    tsc: { packageName: 'typescript', binName: 'tsc' },
+    tsx: { packageName: 'tsx', binName: 'tsx' },
+    vite: { packageName: 'vite', binName: 'vite' },
+    vitest: { packageName: 'vitest', binName: 'vitest' },
     vp: { command: 'vp', args: [] },
+    wrangler: { packageName: 'wrangler', binName: 'wrangler' },
 };
 function withOptionalRtk(resolution, outputPolicy) {
     if (outputPolicy !== 'rtk-filtered')
@@ -22,12 +31,7 @@ export function resolveRunner(tool, options = {}) {
     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);
+        return withOptionalRtk(resolveManagedTool(normalized, managed), outputPolicy);
     }
     if (options.fallbackCommand) {
         return withOptionalRtk({
@@ -39,4 +43,28 @@ export function resolveRunner(tool, options = {}) {
     }
     throw new Error(`No managed runtime runner is defined for tool "${normalized}"`);
 }
+function resolveManagedTool(tool, spec) {
+    if ('command' in spec) {
+        return { tool, command: spec.command, args: [...spec.args], source: 'managed' };
+    }
+    const binPath = resolvePackageBin(spec.packageName, spec.binName);
+    if (binPath) {
+        return { tool, command: binPath, args: [...(spec.fallbackArgs ?? [])], source: 'managed' };
+    }
+    return { tool, command: 'vp', args: ['exec', spec.binName], source: 'fallback' };
+}
+function resolvePackageBin(packageName, binName) {
+    try {
+        const packageJsonPath = require.resolve(`${packageName}/package.json`);
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        const relativeBin = typeof packageJson.bin === 'string' ? packageJson.bin : packageJson.bin?.[binName];
+        if (!relativeBin)
+            return null;
+        const absoluteBin = resolve(dirname(packageJsonPath), relativeBin);
+        return existsSync(absoluteBin) ? absoluteBin : null;
+    }
+    catch {
+        return null;
+    }
+}
 //# sourceMappingURL=resolve-runner.js.map