@webpresso/agent-kit 0.21.4 → 0.23.0

package/dist/esm/config/docs-lint/schemas/implementation-plan.d.ts

@@ -15,8 +15,8 @@ export declare const implementationPlanFrontmatter: z.ZodObject<{
         completed: "completed";
         draft: "draft";
         planned: "planned";
-        "in-progress": "in-progress";
         parked: "parked";
+        "in-progress": "in-progress";
         archived: "archived";
         current: "current";
         complete: "complete";
@@ -40,8 +40,8 @@ export declare const implementationPlanFrontmatter: z.ZodObject<{
             completed: "completed";
             draft: "draft";
             planned: "planned";
-            "in-progress": "in-progress";
             parked: "parked";
+            "in-progress": "in-progress";
             archived: "archived";
             current: "current";
             complete: "complete";

package/dist/esm/config/docs-lint/schemas/parent-roadmap.d.ts

@@ -14,8 +14,8 @@ export declare const parentRoadmapFrontmatter: z.ZodObject<{
         completed: "completed";
         draft: "draft";
         planned: "planned";
-        "in-progress": "in-progress";
         parked: "parked";
+        "in-progress": "in-progress";
         archived: "archived";
         current: "current";
         complete: "complete";

package/dist/esm/config/stryker/index.d.ts

@@ -40,5 +40,90 @@ export declare const baseConfig: {
     incremental: boolean;
     incrementalFile: string;
 };
+/**
+ * Extends baseConfig with TypeScript checker defaults.
+ * Use this in any TypeScript package instead of baseConfig directly.
+ *
+ * @example
+ * import { typescriptBaseConfig } from '@webpresso/agent-kit/stryker'
+ *
+ * export default { ...typescriptBaseConfig }
+ * // or, for packages with a CF-pool vitest config:
+ * export default { ...typescriptBaseConfig, vitest: { configFile: 'vitest.stryker.config.ts' } }
+ */
+export declare const typescriptBaseConfig: {
+    checkers: string[];
+    tsconfigFile: string;
+    packageManager: string;
+    testRunner: string;
+    plugins: string[];
+    ignorePatterns: string[];
+    mutate: string[];
+    concurrency: number;
+    timeoutMS: number;
+    dryRunTimeoutMinutes: number;
+    ignoreStatic: boolean;
+    thresholds: {
+        high: number;
+        low: number;
+        break: number;
+    };
+    mutator: {
+        excludedMutations: string[];
+    };
+    reporters: string[];
+    htmlReporter: {
+        fileName: string;
+    };
+    jsonReporter: {
+        fileName: string;
+    };
+    incremental: boolean;
+    incrementalFile: string;
+};
+/**
+ * Extends typescriptBaseConfig for Cloudflare Workers packages whose vitest config
+ * uses @cloudflare/vitest-pool-workers (incompatible with Stryker's pool injection).
+ * Points to a per-package vitest.stryker.config.ts that uses the standard forks pool
+ * and excludes any tests that require CF runtime globals (cloudflare:test).
+ *
+ * @example
+ * import { typescriptWorkersBaseConfig } from '@webpresso/agent-kit/stryker'
+ *
+ * export default { ...typescriptWorkersBaseConfig }
+ */
+export declare const typescriptWorkersBaseConfig: {
+    vitest: {
+        configFile: string;
+    };
+    checkers: string[];
+    tsconfigFile: string;
+    packageManager: string;
+    testRunner: string;
+    plugins: string[];
+    ignorePatterns: string[];
+    mutate: string[];
+    concurrency: number;
+    timeoutMS: number;
+    dryRunTimeoutMinutes: number;
+    ignoreStatic: boolean;
+    thresholds: {
+        high: number;
+        low: number;
+        break: number;
+    };
+    mutator: {
+        excludedMutations: string[];
+    };
+    reporters: string[];
+    htmlReporter: {
+        fileName: string;
+    };
+    jsonReporter: {
+        fileName: string;
+    };
+    incremental: boolean;
+    incrementalFile: string;
+};
 export default baseConfig;
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/config/stryker/index.js

@@ -75,5 +75,36 @@ export const baseConfig = {
     incremental: true,
     incrementalFile: 'reports/stryker-incremental.json',
 };
+/**
+ * Extends baseConfig with TypeScript checker defaults.
+ * Use this in any TypeScript package instead of baseConfig directly.
+ *
+ * @example
+ * import { typescriptBaseConfig } from '@webpresso/agent-kit/stryker'
+ *
+ * export default { ...typescriptBaseConfig }
+ * // or, for packages with a CF-pool vitest config:
+ * export default { ...typescriptBaseConfig, vitest: { configFile: 'vitest.stryker.config.ts' } }
+ */
+export const typescriptBaseConfig = {
+    ...baseConfig,
+    checkers: ['typescript'],
+    tsconfigFile: 'tsconfig.json',
+};
+/**
+ * Extends typescriptBaseConfig for Cloudflare Workers packages whose vitest config
+ * uses @cloudflare/vitest-pool-workers (incompatible with Stryker's pool injection).
+ * Points to a per-package vitest.stryker.config.ts that uses the standard forks pool
+ * and excludes any tests that require CF runtime globals (cloudflare:test).
+ *
+ * @example
+ * import { typescriptWorkersBaseConfig } from '@webpresso/agent-kit/stryker'
+ *
+ * export default { ...typescriptWorkersBaseConfig }
+ */
+export const typescriptWorkersBaseConfig = {
+    ...typescriptBaseConfig,
+    vitest: { configFile: 'vitest.stryker.config.ts' },
+};
 export default baseConfig;
 //# sourceMappingURL=index.js.map

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

@@ -1,3 +1,4 @@
+import { getManagedRunner } from '#tool-runtime';
 import path from 'node:path';
 export function buildE2eCommand(options) {
     switch (options.step.runner) {
@@ -15,10 +16,13 @@ function buildPlaywrightCommand(options) {
         throw new Error(`Step ${step.logName} uses runner "playwright" but does not define configPath.`);
     }
     const { baseDir, configArg, files } = resolveRunnerPaths(step.configPath, options.files ?? []);
-    const args = [...buildPnpmExecPrefix(baseDir), 'playwright', 'test', '--config', configArg];
+    const resolution = withBaseDir(getManagedRunner('playwright', {
+        outputPolicy: resolveOutputPolicy(options.outputPolicy, options.filterOutput),
+    }), baseDir);
+    const args = [...resolution.args, 'test', '--config', configArg];
     appendPlaywrightFlags(args, options);
     args.push(...(step.fixedArgs ?? []), ...files, ...(options.passthrough ?? []));
-    return { command: 'pnpm', args };
+    return { command: resolution.command, args };
 }
 function buildVitestE2eCommand(options) {
     const { step } = options;
@@ -26,12 +30,15 @@ function buildVitestE2eCommand(options) {
         throw new Error(`Step ${step.logName} uses runner "vitest" but does not define configPath.`);
     }
     const { baseDir, configArg, files } = resolveRunnerPaths(step.configPath, options.files ?? []);
-    const args = [...buildPnpmExecPrefix(baseDir), 'vitest', 'run', '--config', configArg];
+    const resolution = withBaseDir(getManagedRunner('vitest', {
+        outputPolicy: resolveOutputPolicy(options.outputPolicy, options.filterOutput),
+    }), baseDir);
+    const args = [...resolution.args, 'run', '--config', configArg];
     if (options.workers !== undefined) {
         args.push('--poolOptions.threads.maxThreads', String(options.workers));
     }
     args.push(...(step.fixedArgs ?? []), ...files, ...(options.passthrough ?? []));
-    return { command: 'pnpm', args };
+    return { command: resolution.command, args };
 }
 function buildCustomCommand(options) {
     const { step } = options;
@@ -69,9 +76,6 @@ function appendPlaywrightFlags(args, options) {
         args.push('--test-list', options.testList);
     }
 }
-function buildPnpmExecPrefix(baseDir) {
-    return baseDir === '.' ? ['exec'] : ['--dir', baseDir, 'exec'];
-}
 function resolveRunnerPaths(configPath, files) {
     const normalizedConfigPath = configPath.replace(/\\/gu, '/');
     const baseDir = path.posix.dirname(normalizedConfigPath);
@@ -95,4 +99,28 @@ function resolveRunnerPaths(configPath, files) {
         }),
     };
 }
+function withBaseDir(resolution, baseDir) {
+    if (baseDir === '.') {
+        return { command: resolution.command, args: [...resolution.args] };
+    }
+    if (resolution.command === 'vp') {
+        return {
+            command: resolution.command,
+            args: ['--dir', baseDir, ...resolution.args],
+        };
+    }
+    const [wrappedCommand, ...wrappedArgs] = resolution.args;
+    if (resolution.command === 'rtk' && wrappedCommand === 'vp') {
+        return {
+            command: resolution.command,
+            args: ['vp', '--dir', baseDir, ...wrappedArgs],
+        };
+    }
+    return { command: resolution.command, args: [...resolution.args] };
+}
+function resolveOutputPolicy(outputPolicy, filterOutput) {
+    if (outputPolicy)
+        return outputPolicy;
+    return filterOutput === false ? 'structured' : 'rtk-filtered';
+}
 //# sourceMappingURL=command-builder.js.map

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

@@ -6,6 +6,62 @@ declare const webpressoConfigSchema: z.ZodObject<{
         hostAdapterModule: z.ZodString;
         hostAdapterExport: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    deploy: z.ZodOptional<z.ZodObject<{
+        cloudflare: z.ZodOptional<z.ZodObject<{
+            lanes: z.ZodObject<{
+                dev: z.ZodObject<{
+                    wranglerEnvName: z.ZodString;
+                }, z.core.$strict>;
+                preview_main: z.ZodObject<{
+                    wranglerEnvName: z.ZodString;
+                }, z.core.$strict>;
+                preview_pr: z.ZodObject<{
+                    wranglerEnvNamePattern: z.ZodString;
+                }, z.core.$strict>;
+                prd: z.ZodObject<{
+                    wranglerEnvName: z.ZodString & z.ZodType<"production", string, z.core.$ZodTypeInternals<"production", string>>;
+                    deployedWorkerNameMode: z.ZodLiteral<"top_level_name">;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            production: z.ZodObject<{
+                metadataPath: z.ZodLiteral<"infra/release-metadata.production.json">;
+            }, z.core.$strict>;
+            targets: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodEnum<{
+                    single_worker: "single_worker";
+                    worker_plus_assets: "worker_plus_assets";
+                    monorepo_multi_target: "monorepo_multi_target";
+                }>;
+                topLevelWorkerName: z.ZodString;
+                previewTransport: z.ZodEnum<{
+                    custom_domain_env: "custom_domain_env";
+                    workers_dev_env: "workers_dev_env";
+                }>;
+                routeSpec: z.ZodOptional<z.ZodObject<{
+                    pattern: z.ZodString;
+                }, z.core.$strict>>;
+                durableObjectBindings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    className: z.ZodString;
+                    scriptName: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                vars: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                requiredSecrets: z.ZodArray<z.ZodString>;
+                storageMode: z.ZodEnum<{
+                    isolated: "isolated";
+                    shared_via_script_name: "shared_via_script_name";
+                }>;
+                destroyMode: z.ZodLiteral<"wrangler_delete_env">;
+                repoCleanupHook: z.ZodOptional<z.ZodString>;
+                blastRadiusDoc: z.ZodOptional<z.ZodString>;
+                productionStrategyDefault: z.ZodEnum<{
+                    direct: "direct";
+                    gradual: "gradual";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type WebpressoConfig = z.infer<typeof webpressoConfigSchema>;
 export type WebpressoE2eConfig = NonNullable<WebpressoConfig['e2e']>;

package/dist/esm/e2e/config.js

@@ -1,15 +1,129 @@
 import { z } from 'zod';
 export const WEBPRESSO_CONFIG_FILE_NAME = 'webpresso.config.ts';
 export const WEBPRESSO_CONFIG_EXPORT_NAME = 'webpressoConfig';
+const wranglerEnvNameSchema = z
+    .string()
+    .min(1, 'wranglerEnvName must not be empty.')
+    .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, 'wranglerEnvName must be dash-safe lowercase letters, numbers, and hyphens only.');
 const e2eWebpressoConfigSchema = z
     .object({
     hostAdapterModule: z.string().min(1, 'e2e.hostAdapterModule must not be empty.'),
     hostAdapterExport: z.string().min(1, 'e2e.hostAdapterExport must not be empty.').optional(),
 })
     .strict();
+const cloudflareDeployLaneSchema = z
+    .object({
+    wranglerEnvName: wranglerEnvNameSchema,
+})
+    .strict();
+const previewPrCloudflareDeployLaneSchema = z
+    .object({
+    wranglerEnvNamePattern: z
+        .string()
+        .min(1, 'wranglerEnvNamePattern must not be empty.')
+        .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*-<n>$/, 'wranglerEnvNamePattern must be dash-safe and end with -<n>.'),
+})
+    .strict();
+const productionCloudflareDeployLaneSchema = cloudflareDeployLaneSchema.extend({
+    wranglerEnvName: wranglerEnvNameSchema.refine((value) => value === 'production', {
+        message: 'deploy.cloudflare.lanes.prd.wranglerEnvName must be "production".',
+    }),
+    deployedWorkerNameMode: z.literal('top_level_name'),
+});
+const cloudflareRouteSpecSchema = z
+    .object({
+    pattern: z.string().min(1, 'routeSpec.pattern must not be empty.'),
+})
+    .strict();
+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(),
+})
+    .strict();
+const cloudflareTargetSchema = z
+    .object({
+    id: z.string().min(1, 'deploy.cloudflare.targets[].id must not be empty.'),
+    type: z.enum(['single_worker', 'worker_plus_assets', 'monorepo_multi_target']),
+    topLevelWorkerName: z.string().min(1, 'topLevelWorkerName must not be empty.'),
+    previewTransport: z.enum(['custom_domain_env', 'workers_dev_env']),
+    routeSpec: cloudflareRouteSpecSchema.optional(),
+    durableObjectBindings: z.array(cloudflareDurableObjectBindingSchema).optional(),
+    vars: z.record(z.string(), z.unknown()),
+    requiredSecrets: z.array(z.string().min(1, 'requiredSecrets[] must not be empty.')),
+    storageMode: z.enum(['isolated', 'shared_via_script_name']),
+    destroyMode: z.literal('wrangler_delete_env'),
+    repoCleanupHook: z.string().min(1, 'repoCleanupHook must not be empty.').optional(),
+    blastRadiusDoc: z.string().min(1, 'blastRadiusDoc must not be empty.').optional(),
+    productionStrategyDefault: z.enum(['direct', 'gradual']),
+})
+    .strict()
+    .superRefine((target, ctx) => {
+    const isDurableObjectTarget = (target.durableObjectBindings?.length ?? 0) > 0;
+    if (target.previewTransport === 'custom_domain_env' && !target.routeSpec) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['routeSpec'],
+            message: 'routeSpec is required when previewTransport is "custom_domain_env".',
+        });
+    }
+    if (isDurableObjectTarget && target.previewTransport !== 'custom_domain_env') {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['previewTransport'],
+            message: 'Durable Object targets must use previewTransport "custom_domain_env" unless a future explicit exception contract is introduced.',
+        });
+    }
+    if (isDurableObjectTarget && Object.keys(target.vars).length === 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['vars'],
+            message: 'Durable Object targets must declare at least one env-specific var.',
+        });
+    }
+    if (isDurableObjectTarget && target.requiredSecrets.length === 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['requiredSecrets'],
+            message: 'Durable Object targets must declare at least one required secret name.',
+        });
+    }
+    if (target.storageMode === 'shared_via_script_name' && !target.blastRadiusDoc) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['blastRadiusDoc'],
+            message: 'blastRadiusDoc is required when storageMode is "shared_via_script_name".',
+        });
+    }
+});
+const cloudflareDeployConfigSchema = z
+    .object({
+    lanes: z
+        .object({
+        dev: cloudflareDeployLaneSchema,
+        preview_main: cloudflareDeployLaneSchema,
+        preview_pr: previewPrCloudflareDeployLaneSchema,
+        prd: productionCloudflareDeployLaneSchema,
+    })
+        .strict(),
+    production: z
+        .object({
+        metadataPath: z.literal('infra/release-metadata.production.json'),
+    })
+        .strict(),
+    targets: z.array(cloudflareTargetSchema),
+})
+    .strict();
+const deployWebpressoConfigSchema = z
+    .object({
+    cloudflare: cloudflareDeployConfigSchema.optional(),
+})
+    .strict();
 const webpressoConfigSchema = z
     .object({
     e2e: e2eWebpressoConfigSchema.optional(),
+    deploy: deployWebpressoConfigSchema.optional(),
 })
     .strict();
 export class WebpressoConfigValidationError extends Error {

package/dist/esm/e2e/execution.js

@@ -18,6 +18,8 @@ export async function createE2eExecutionPlan(input, cwd = process.cwd()) {
             workers: input.workers,
             testList: input.testList,
             passthrough: input.passthrough,
+            outputPolicy: input.outputPolicy,
+            filterOutput: input.filterOutput,
         });
     }
     const hostAdapter = await loadConfiguredHostAdapter(cwd);
@@ -35,6 +37,8 @@ export async function createE2eExecutionPlan(input, cwd = process.cwd()) {
             workers: input.workers,
             testList: input.testList,
             passthrough: input.passthrough,
+            outputPolicy: input.outputPolicy,
+            filterOutput: input.filterOutput,
         });
     }
     if (hostAdapter.adapter.buildExecutionPlan) {
@@ -49,6 +53,8 @@ export async function createE2eExecutionPlan(input, cwd = process.cwd()) {
             workers: input.workers,
             testList: input.testList,
             passthrough: input.passthrough,
+            outputPolicy: input.outputPolicy,
+            filterOutput: input.filterOutput,
         });
     }
     return planE2eRun({
@@ -60,6 +66,8 @@ export async function createE2eExecutionPlan(input, cwd = process.cwd()) {
         workers: input.workers,
         testList: input.testList,
         passthrough: input.passthrough,
+        outputPolicy: input.outputPolicy,
+        filterOutput: input.filterOutput,
     });
 }
 export function plannedGroupsToCommandConfigs(groups) {

package/dist/esm/e2e/run-planner.js

@@ -76,6 +76,8 @@ function planE2eRunsFromSuites(options) {
                 workers: options.request.workers,
                 testList: options.request.testList,
                 passthrough: options.request.passthrough,
+                outputPolicy: options.request.outputPolicy,
+                filterOutput: options.request.filterOutput,
             });
             runs.push({
                 suiteId: suite.id,

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

@@ -1,3 +1,4 @@
+import type { ManagedRunnerOutputPolicy } from '#tool-runtime';
 export type E2eRunnerKind = 'playwright' | 'vitest' | 'command';
 export interface CommandConfig {
     command: string;
@@ -48,6 +49,8 @@ export interface E2eCommandRequest {
     workers?: number | string;
     testList?: string;
     passthrough?: readonly string[];
+    filterOutput?: boolean;
+    outputPolicy?: ManagedRunnerOutputPolicy;
 }
 export interface E2eExecutionRequest extends E2eCommandRequest {
     suite?: string;

package/dist/esm/format/index.js

@@ -8,6 +8,7 @@
  */
 import { isMissingBinary, isRunFailure, runCommand } from '#mcp/tools/_shared/run-command';
 import { resolveProjectRoot } from '#mcp/tools/_shared/project-root';
+import { getManagedRunner } from '#tool-runtime';
 const DEFAULT_FORMAT_TIMEOUT_MS = 5 * 60 * 1_000;
 /**
  * Run formatter and return a structured result. Throws a clear error when
@@ -33,7 +34,10 @@ export async function runFormat(options = {}) {
     args.push('--ignore-path', '.gitignore');
     if (options.files && options.files.length > 0)
         args.push(...options.files);
-    const outcome = await runCommand('oxfmt', args, runOptions);
+    const resolution = getManagedRunner('oxfmt', {
+        outputPolicy: 'structured',
+    });
+    const outcome = await runCommand(resolution.command, [...resolution.args, ...args], runOptions);
     if (isRunFailure(outcome)) {
         if (isMissingBinary(outcome)) {
             throw new Error("oxfmt binary not found on PATH. Install it as a devDependency: 'vp install -D oxfmt'");

package/dist/esm/hooks/guard-switch/index.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env bun
-export {};
+export declare function main(): Promise<void>;
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/hooks/guard-switch/index.js

@@ -1,18 +1,26 @@
 #!/usr/bin/env bun
 import { runHook } from '#hooks/shared/hook-bootstrap';
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import { setGuardEnabled } from './state.js';
-runHook((input) => {
-    const normalized = (input.prompt ?? '').toLowerCase().trim();
-    if (normalized === 'guard off') {
-        setGuardEnabled(false);
-        console.error('🛡️ Guard disabled — pretool validators will be skipped');
-        process.exit(2);
-    }
-    if (normalized === 'guard on') {
-        setGuardEnabled(true);
-        console.error('🛡️ Guard enabled — pretool validators active');
-        process.exit(2);
-    }
-    return null;
-}, () => '{}');
+export async function main() {
+    runHook((input) => {
+        const normalized = (input.prompt ?? '').toLowerCase().trim();
+        if (normalized === 'guard off') {
+            setGuardEnabled(false);
+            console.error('🛡️ Guard disabled — pretool validators will be skipped');
+            process.exit(2);
+        }
+        if (normalized === 'guard on') {
+            setGuardEnabled(true);
+            console.error('🛡️ Guard enabled — pretool validators active');
+            process.exit(2);
+        }
+        return null;
+    }, () => '{}');
+}
+if (process.argv[1] &&
+    realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1])) {
+    void main();
+}
 //# sourceMappingURL=index.js.map

package/dist/esm/hooks/post-tool/lint-after-edit.d.ts

@@ -14,4 +14,5 @@ export declare function shouldLintFile(input: ToolInput): boolean;
  */
 export declare function lintFile(filePath: string, _projectDir: string): boolean;
 export declare function processPostToolUse(input: ToolInput, projectDir: string): boolean;
+export declare function main(): Promise<void>;
 //# sourceMappingURL=lint-after-edit.d.ts.map

package/dist/esm/hooks/post-tool/lint-after-edit.js

@@ -46,12 +46,15 @@ export function processPostToolUse(input, projectDir) {
     const filePath = input.tool_input.file_path;
     return lintFile(filePath, projectDir);
 }
-if (process.argv[1] &&
-    realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1])) {
+export async function main() {
     runHook((input) => {
         const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
         processPostToolUse(input, projectDir);
         return null;
     }, () => '{}');
 }
+if (process.argv[1] &&
+    realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1])) {
+    void main();
+}
 //# sourceMappingURL=lint-after-edit.js.map

package/dist/esm/hooks/pretool-guard/validators/file-conventions.js

@@ -46,7 +46,7 @@ export function validateFileConventions(input) {
     if (nonCanonicalPlanningViolation) {
         return { validator: 'file-conventions', passed: false, message: nonCanonicalPlanningViolation };
     }
-    const blueprintPathViolation = getBlueprintPathViolation(normalized);
+    const blueprintPathViolation = getBlueprintPathViolation(normalized, undefined, input.cwd);
     if (blueprintPathViolation) {
         return { validator: 'file-conventions', passed: false, message: blueprintPathViolation };
     }

package/dist/esm/hooks/pretool-guard/validators/forbidden-commands.d.ts

@@ -29,6 +29,11 @@ interface BlockedScriptSpec {
     category: CommandCategory;
     suggestion: string;
 }
+interface BlockedRawNodeModulesToolSpec {
+    modulePath: string;
+    category: CommandCategory;
+    suggestion: string;
+}
 interface RedirectOptions {
     mcpReady?: boolean;
     mcp?: MCPRedirectConfig;
@@ -39,6 +44,7 @@ export declare const AUDIT_MODE_ENV = "FORBIDDEN_COMMANDS_AUDIT";
 export declare const DOCS_REF = "AGENTS.md \"Forbidden Commands (CRITICAL)\" section";
 export declare const BLOCKED_TOOLS: BlockedToolSpec[];
 export declare const BLOCKED_SCRIPTS: BlockedScriptSpec[];
+export declare const BLOCKED_RAW_NODE_MODULE_TOOLS: BlockedRawNodeModulesToolSpec[];
 export declare function generateRules(): CommandRule[];
 export declare const COMMAND_RULES: CommandRule[];
 export declare const SUGGESTION_MODIFIERS: SuggestionModifier[];

package/dist/esm/hooks/pretool-guard/validators/forbidden-commands.js

@@ -19,8 +19,18 @@ const TYPECHECK_HINT = 'wp_typecheck MCP tool with package/file scope';
 const E2E_HINT = 'wp_e2e MCP tool';
 const ENV_HINT = 'Use the repo-approved environment wrapper for secret-bearing commands';
 const TASK_TARGET_HINT = 'Use the repo-approved vp facade or MCP tool instead of raw execution';
-const EXEC_RUNNERS = ['vp exec'];
-const DIRECT_RUNNERS = ['vp'];
+const EXEC_RUNNERS = [
+    'vp exec',
+    'pnpm exec',
+    'npm exec',
+    'npm exec --',
+    'npx',
+    'pnpx',
+    'yarn exec',
+    'yarn dlx',
+    'bunx',
+];
+const DIRECT_RUNNERS = ['vp', 'pnpm', 'yarn', 'yarnpkg'];
 const SCRIPT_RUNNERS = ['vp run', 'vp', 'pnpm', 'pnpm run', 'just'];
 export const BLOCKED_TOOLS = [
     {
@@ -59,6 +69,11 @@ export const BLOCKED_SCRIPTS = [
     { script: 'e2e', category: 'e2e', suggestion: E2E_HINT },
     { script: 'qa', category: 'unknown', suggestion: QA_HINT },
 ];
+export const BLOCKED_RAW_NODE_MODULE_TOOLS = [
+    { modulePath: 'vitest/vitest.mjs', category: 'test', suggestion: TEST_HINT },
+    { modulePath: 'typescript/bin/tsc', category: 'typecheck', suggestion: TYPECHECK_HINT },
+    { modulePath: 'oxlint/bin/oxlint', category: 'lint', suggestion: LINT_HINT },
+];
 function escapeRegex(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -66,6 +81,9 @@ function buildToolPattern(prefix, tool) {
     const escaped = prefix ? `${escapeRegex(prefix)} ${escapeRegex(tool)}` : escapeRegex(tool);
     return new RegExp(`^${escaped}(\\s|$)`);
 }
+function buildRawNodeModulesToolPattern(modulePath) {
+    return new RegExp(`^node\\s+(?:\\.\\/)?node_modules\\/${escapeRegex(modulePath)}(?:\\s|$)`);
+}
 export function generateRules() {
     const rules = [];
     for (const spec of BLOCKED_TOOLS) {
@@ -104,6 +122,13 @@ export function generateRules() {
             });
         }
     }
+    for (const spec of BLOCKED_RAW_NODE_MODULE_TOOLS) {
+        rules.push({
+            pattern: buildRawNodeModulesToolPattern(spec.modulePath),
+            category: spec.category,
+            suggestion: spec.suggestion,
+        });
+    }
     rules.push({
         pattern: /^vp exec markdownlint-cli2\b/,
         category: 'unknown',