@webpresso/agent-kit 0.21.3 → 0.21.5

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

@@ -0,0 +1,23 @@
+import { resolveRunner, } from './resolve-runner.js';
+const runtimeCache = new Map();
+function cacheKey(tool, options) {
+    return JSON.stringify({
+        tool,
+        filterOutput: options.filterOutput ?? true,
+        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,13 @@
+export interface ManagedRunnerResolution {
+    readonly tool: string;
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly source: 'managed' | 'fallback';
+}
+export interface ResolveRunnerOptions {
+    readonly fallbackCommand?: string;
+    readonly fallbackArgs?: readonly string[];
+    readonly filterOutput?: boolean;
+}
+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,40 @@
+const MANAGED_TOOL_PREFIX = {
+    playwright: { command: 'vp', args: ['exec', 'playwright'] },
+    vitest: { command: 'vp', args: ['exec', 'vitest'] },
+    vp: { command: 'vp', args: [] },
+};
+function withOptionalRtk(resolution, filterOutput) {
+    if (!filterOutput)
+        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 filterOutput = options.filterOutput ?? true;
+    const managed = MANAGED_TOOL_PREFIX[normalized];
+    if (managed) {
+        return withOptionalRtk({
+            tool: normalized,
+            command: managed.command,
+            args: [...managed.args],
+            source: 'managed',
+        }, filterOutput);
+    }
+    if (options.fallbackCommand) {
+        return withOptionalRtk({
+            tool: normalized,
+            command: options.fallbackCommand,
+            args: [...(options.fallbackArgs ?? [])],
+            source: 'fallback',
+        }, filterOutput);
+    }
+    throw new Error(`No managed runtime runner is defined for tool "${normalized}"`);
+}
+//# sourceMappingURL=resolve-runner.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpresso/agent-kit",
-  "version": "0.21.3",
+  "version": "0.21.5",
   "private": false,
   "repository": {
     "type": "git",
@@ -14,7 +14,7 @@
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "description": "One command scaffolds a repo so every AI coding agent (Claude Code, Codex CLI, Cursor, Windsurf, Gemini, OpenCode) shares the same context, hooks, and quality gates. The `wp` CLI: blueprints, skills catalog, lore commits, tech-debt lifecycle, audit composite.",
+  "description": "TypeScript infrastructure for AI-agent-driven development: the `wp` CLI + MCP server give agents planning (blueprints), tests, mutation, e2e, CI, docs, and tech-debt — summary-first so they keep context, and enforced as pre-commit/CI contracts. Manages AGENTS.md / CLAUDE.md and per-agent surfaces.",
   "keywords": [
     "agent",
     "webpresso",
@@ -113,6 +113,9 @@
     "#mcp/*": "./src/mcp/*.ts",
     "#content/*.js": "./src/content/*.ts",
     "#content/*": "./src/content/*.ts",
+    "#tool-runtime": "./src/tool-runtime/index.ts",
+    "#tool-runtime/*.js": "./src/tool-runtime/*.ts",
+    "#tool-runtime/*": "./src/tool-runtime/*.ts",
     "#output-transforms/*.js": "./src/output-transforms/*.ts",
     "#output-transforms/*": "./src/output-transforms/*.ts",
     "#lint/*.js": "./src/lint/*.ts",
@@ -167,18 +170,6 @@
         "default": "./dist/esm/blueprint/index.js"
       }
     },
-    "./blueprint/dag": {
-      "import": {
-        "types": "./dist/esm/blueprint/dag/index.d.ts",
-        "default": "./dist/esm/blueprint/dag/index.js"
-      }
-    },
-    "./blueprint/dag/local": {
-      "import": {
-        "types": "./dist/esm/blueprint/dag/local/index.d.ts",
-        "default": "./dist/esm/blueprint/dag/local/index.js"
-      }
-    },
     "./blueprint/local": {
       "import": {
         "types": "./dist/esm/blueprint/local.d.ts",
@@ -514,17 +505,21 @@
   "scripts": {
     "setup:agent": "wp setup",
     "build": "tshy && vp run chmod-bins && vp run link-self-bins",
-    "postbuild": "vp run generate-skills",
+    "postbuild": "vp run generate-skills && vp run sync-doc-templates",
     "chmod-bins": "bun scripts/chmod-bins.ts",
     "link-self-bins": "bun scripts/link-self-bins.ts",
     "dev:link": "bun scripts/link-edge-local.ts",
     "prepack": "bun src/build/package-manifest.ts prepare",
     "postpack": "bun src/build/package-manifest.ts restore",
     "generate-skills": "bun src/build/generate-skills-dir.ts",
+    "sync-doc-templates": "bun src/build/sync-catalog-doc-templates.ts",
     "sync-marketplace-version": "bun scripts/sync-marketplace-version.ts",
     "version": "changeset version && vp run sync-marketplace-version",
+    "release:publish": "bun scripts/release-publish.ts",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run",
+    "test": "vitest run --exclude '**/*.integration.test.ts' && vitest run --no-file-parallelism .integration.test.ts",
+    "test:unit": "vitest run --exclude '**/*.integration.test.ts'",
+    "test:integration": "vitest run --no-file-parallelism .integration.test.ts",
     "test:mutation": "bun stryker run stryker.config.ts",
     "eval": "bun src/runners/evals/index.ts",
     "lint": "vp lint",
@@ -539,6 +534,7 @@
     "imports:check": "WP_SKIP_UPDATE_CHECK=1 wp audit no-relative-parent-imports",
     "verify:secrets": "bun scripts/check-no-dev-vars.ts",
     "audit:secret-provider-quarantine": "bun scripts/audit-secret-provider-quarantine.ts",
+    "public:consumer-smoke": "bun scripts/public-consumer-smoke.ts",
     "public:readiness": "bun scripts/public-readiness.ts",
     "audits:check": "WP_SKIP_UPDATE_CHECK=1 wp audit guardrails && vp run hooks:doctor:ci",
     "hooks:doctor": "WP_SKIP_UPDATE_CHECK=1 wp hooks doctor",
@@ -607,8 +603,6 @@
     "exports": {
       ".": "./src/index.ts",
       "./blueprint": "./src/blueprint/index.ts",
-      "./blueprint/dag": "./src/blueprint/dag/index.ts",
-      "./blueprint/dag/local": "./src/blueprint/dag/local/index.ts",
       "./blueprint/local": "./src/blueprint/local.ts",
       "./blueprint/tech-debt": "./src/blueprint/tech-debt/index.ts",
       "./blueprint/test-utils": "./src/blueprint/test-utils/blueprint-mocks.ts",

package/skills/plan-refine/SKILL.md

@@ -16,10 +16,11 @@ description: Methodology for refining, fact-checking, and hardening implementati
 >
 > Blueprint hardening and lifecycle infrastructure are production-ready:
 >
-> - Kahn's Algorithm DAG analysis (fully tested)
-> - `ParallelExecutor` concurrency engine with abort, timeout, per-type limits
-> - Blueprint dependency format and validation
-> - Failed tasks block dependents automatically
+> - Blueprint dependency parsing, format validation, and the lifecycle state
+>   machine with evidence-gated task completion (fully tested, in-package)
+> - Parallel execution is delegated to the `/pll` runtime adapter (OMX), which
+>   batches independent tasks by dependency order and blocks dependents of
+>   failed tasks
 >
 > **Remaining gaps:** execution docs and wrappers must stay aligned with the currently shipped runtime and CLI surface.
 

package/dist/esm/blueprint/dag/cycle-detector.d.ts

@@ -1,12 +0,0 @@
-export declare class CycleDetector {
-    private edges;
-    private visited;
-    private recStack;
-    private path;
-    private cycles;
-    constructor(edges: Map<string, Set<string>>);
-    detect(nodes: IterableIterator<string>): string[][] | null;
-    private dfs;
-    private processNeighbor;
-}
-//# sourceMappingURL=cycle-detector.d.ts.map

package/dist/esm/blueprint/dag/cycle-detector.js

@@ -1,46 +0,0 @@
-export class CycleDetector {
-    edges;
-    visited = new Set();
-    recStack = new Set();
-    path = [];
-    cycles = [];
-    constructor(edges) {
-        this.edges = edges;
-    }
-    detect(nodes) {
-        for (const nodeId of nodes) {
-            if (!this.visited.has(nodeId) && this.dfs(nodeId)) {
-                return this.cycles;
-            }
-        }
-        return this.cycles.length > 0 ? this.cycles : null;
-    }
-    dfs(nodeId) {
-        this.visited.add(nodeId);
-        this.recStack.add(nodeId);
-        this.path.push(nodeId);
-        const edges = this.edges.get(nodeId);
-        if (edges) {
-            for (const neighbor of edges) {
-                if (this.processNeighbor(neighbor))
-                    return true;
-            }
-        }
-        this.path.pop();
-        this.recStack.delete(nodeId);
-        return false;
-    }
-    processNeighbor(neighbor) {
-        if (!this.visited.has(neighbor)) {
-            if (this.dfs(neighbor))
-                return true;
-        }
-        else if (this.recStack.has(neighbor)) {
-            const cycleStart = this.path.indexOf(neighbor);
-            this.cycles.push([...this.path.slice(cycleStart), neighbor]);
-            return true;
-        }
-        return false;
-    }
-}
-//# sourceMappingURL=cycle-detector.js.map

package/dist/esm/blueprint/dag/executor.d.ts

@@ -1,140 +0,0 @@
-import type { IClock } from './interfaces.js';
-import type { Task } from './types.js';
-import { TaskGraph } from './task-graph.js';
-/**
- * Task execution result
- */
-export interface TaskResult<T = unknown> {
-    taskId: string;
-    status: 'completed' | 'failed' | 'skipped';
-    output?: T;
-    error?: Error;
-    durationMs: number;
-    startedAt: number;
-    completedAt: number;
-}
-/**
- * Concurrency configuration by task type
- */
-export interface ConcurrencyConfig {
-    /** Global max concurrent tasks across all types */
-    global?: number;
-    /** Default max concurrent tasks per type (when no type-specific limit) */
-    default: number;
-    /** Per-type limits (overrides default) */
-    byType?: Record<string, number>;
-}
-/**
- * Task executor function signature
- * Receives task and returns result (or throws)
- */
-export type TaskExecutorFn<T, R> = (task: Task<T>) => Promise<R>;
-/**
- * Execution progress callback
- */
-export interface ExecutionProgress<T = unknown> {
-    totalTasks: number;
-    completedTasks: number;
-    failedTasks: number;
-    runningTasks: string[];
-    pendingTasks: number;
-    currentWave: number;
-    totalWaves: number;
-    latestResult?: TaskResult<T>;
-}
-export type ProgressCallback<T = unknown> = (progress: ExecutionProgress<T>) => void;
-/**
- * Executor options
- */
-export interface ExecutorOptions<R> {
-    concurrency?: ConcurrencyConfig;
-    onProgress?: ProgressCallback<R>;
-    /** Clock for time operations (injectable for testing) */
-    clock?: IClock;
-    /** Skip tasks whose dependencies failed */
-    skipOnFailedDependency?: boolean;
-    /** Timeout for individual tasks in milliseconds (0 = no timeout) */
-    taskTimeoutMs?: number;
-    /** AbortSignal for cancellation */
-    signal?: AbortSignal;
-}
-/**
- * Parallel DAG executor with concurrency controls.
- *
- * Uses Kahn's algorithm for topological execution order.
- * Supports per-task-type concurrency limits.
- *
- * Runtime-agnostic - works in Node.js, Bun, Deno, Cloudflare Workers.
- */
-export declare class ParallelExecutor<T = unknown, R = unknown> {
-    private graph;
-    private concurrency;
-    private executorFn;
-    private onProgress?;
-    private clock;
-    private skipOnFailedDependency;
-    private taskTimeoutMs;
-    private completed;
-    private failed;
-    private skipped;
-    private running;
-    private results;
-    private signal?;
-    private abortController?;
-    constructor(graph: TaskGraph<T>, executorFn: TaskExecutorFn<T, R>, options?: ExecutorOptions<R>);
-    /**
-     * Execute all tasks in parallel, respecting dependencies and concurrency limits.
-     * Returns results in completion order.
-     * @throws {Error} If graph is invalid or execution is aborted
-     */
-    execute(): Promise<TaskResult<R>[]>;
-    /**
-     * Check if execution has been aborted and throw if so.
-     * Checks both internal controller and external signal.
-     */
-    private throwIfAborted;
-    /**
-     * Get current execution state.
-     */
-    getState(): {
-        completed: string[];
-        failed: string[];
-        skipped: string[];
-        running: string[];
-    };
-    private executeWave;
-    private startPendingTasks;
-    private shouldSkipTask;
-    private skipTask;
-    private canStartTask;
-    private getTaskType;
-    /**
-     * Count running tasks of a specific type.
-     * FIX: Now properly tracks task types.
-     */
-    private countRunningByType;
-    private startTask;
-    /**
-     * Execute task with optional timeout support.
-     * State-of-the-art: proper timeout handling with AbortController pattern.
-     */
-    private executeWithTimeout;
-    private createTimeoutPromise;
-    private emitTaskStart;
-    private waitForAny;
-    private emitProgress;
-}
-/**
- * Create executor from task array with dependencies.
- * Convenience function for common use case.
- */
-export declare function createExecutor<T, R>(tasks: Array<{
-    task: Task<T>;
-    dependsOn?: string[];
-}>, executorFn: TaskExecutorFn<T, R>, options?: ExecutorOptions<R>): ParallelExecutor<T, R>;
-/**
- * Create executor directly from tasks using their dependencies arrays.
- * Most convenient for LLM agents.
- */
-export declare function createExecutorFromTasks<T, R>(tasks: Task<T>[], executorFn: TaskExecutorFn<T, R>, options?: ExecutorOptions<R>): ParallelExecutor<T, R>;
-//# sourceMappingURL=executor.d.ts.map

package/dist/esm/blueprint/dag/executor.js

@@ -1,292 +0,0 @@
-import { realClock } from './interfaces.js';
-import { TaskGraph } from './task-graph.js';
-/**
- * Parallel DAG executor with concurrency controls.
- *
- * Uses Kahn's algorithm for topological execution order.
- * Supports per-task-type concurrency limits.
- *
- * Runtime-agnostic - works in Node.js, Bun, Deno, Cloudflare Workers.
- */
-export class ParallelExecutor {
-    graph;
-    concurrency;
-    executorFn;
-    onProgress;
-    clock;
-    skipOnFailedDependency;
-    taskTimeoutMs;
-    // Execution state
-    completed = new Set();
-    failed = new Set();
-    skipped = new Set();
-    running = new Map();
-    results = [];
-    signal;
-    abortController;
-    constructor(graph, executorFn, options = {}) {
-        this.graph = graph;
-        this.executorFn = executorFn;
-        this.concurrency = options.concurrency ?? { default: 6 };
-        this.onProgress = options.onProgress;
-        this.clock = options.clock ?? realClock;
-        this.skipOnFailedDependency = options.skipOnFailedDependency ?? true;
-        this.taskTimeoutMs = options.taskTimeoutMs ?? 0;
-        this.signal = options.signal;
-        // Create internal abort controller for cleanup
-        this.abortController = new AbortController();
-        // Link external signal if provided
-        if (options.signal) {
-            options.signal.addEventListener('abort', () => {
-                this.abortController?.abort(options.signal?.reason);
-            });
-        }
-    }
-    /**
-     * Execute all tasks in parallel, respecting dependencies and concurrency limits.
-     * Returns results in completion order.
-     * @throws {Error} If graph is invalid or execution is aborted
-     */
-    async execute() {
-        // Check for abort before starting
-        this.throwIfAborted();
-        // Validate graph first
-        const validation = this.graph.validate();
-        if (!validation.valid) {
-            throw new Error(`Cannot execute invalid graph: ${validation.errors.join('; ')}`);
-        }
-        const waves = this.graph.getWaves();
-        const totalTasks = waves.flat().length;
-        for (let waveIdx = 0; waveIdx < waves.length; waveIdx++) {
-            this.throwIfAborted();
-            const wave = waves[waveIdx];
-            if (!wave)
-                continue;
-            await this.executeWave(wave, waveIdx + 1, waves.length, totalTasks);
-        }
-        return this.results;
-    }
-    /**
-     * Check if execution has been aborted and throw if so.
-     * Checks both internal controller and external signal.
-     */
-    throwIfAborted() {
-        // Check external signal first (passed in via options)
-        if (this.signal?.aborted) {
-            throw new Error(`Execution aborted: ${this.signal.reason || 'user request'}`);
-        }
-        // Check internal controller
-        if (this.abortController?.signal.aborted) {
-            throw new Error(`Execution aborted: ${this.abortController.signal.reason || 'user request'}`);
-        }
-    }
-    /**
-     * Get current execution state.
-     */
-    getState() {
-        return {
-            completed: Array.from(this.completed),
-            failed: Array.from(this.failed),
-            skipped: Array.from(this.skipped),
-            running: Array.from(this.running.keys()),
-        };
-    }
-    async executeWave(tasks, waveNum, totalWaves, totalTasks) {
-        const pending = [...tasks];
-        while (pending.length > 0 || this.running.size > 0) {
-            this.startPendingTasks(pending, waveNum, totalWaves, totalTasks);
-            if (this.running.size === 0)
-                break;
-            const result = await this.waitForAny();
-            this.results.push(result);
-            this.emitProgress(waveNum, totalWaves, totalTasks, result);
-        }
-    }
-    startPendingTasks(pending, waveNum, totalWaves, totalTasks) {
-        while (pending[0] && this.canStartTask(pending[0])) {
-            const task = pending.shift();
-            if (!task)
-                break;
-            if (this.shouldSkipTask(task)) {
-                this.skipTask(task, waveNum, totalWaves, totalTasks);
-            }
-            else {
-                this.startTask(task);
-            }
-        }
-    }
-    shouldSkipTask(task) {
-        if (!this.skipOnFailedDependency)
-            return false;
-        // Check if any dependency failed
-        const deps = this.graph.getDependencies(task.id);
-        for (const dep of deps) {
-            if (this.failed.has(dep) || this.skipped.has(dep)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    skipTask(task, waveNum, totalWaves, totalTasks) {
-        const now = this.clock.now();
-        this.skipped.add(task.id);
-        const result = {
-            taskId: task.id,
-            status: 'skipped',
-            durationMs: 0,
-            startedAt: now,
-            completedAt: now,
-            error: new Error('Skipped due to failed dependency'),
-        };
-        this.results.push(result);
-        this.emitProgress(waveNum, totalWaves, totalTasks, result);
-    }
-    canStartTask(task) {
-        const taskType = this.getTaskType(task);
-        const typeLimit = this.concurrency.byType?.[taskType] ?? this.concurrency.default;
-        const currentOfType = this.countRunningByType(taskType);
-        // Check type-specific limit
-        if (currentOfType >= typeLimit)
-            return false;
-        // Check global limit (defaults to default if not specified)
-        const globalLimit = this.concurrency.global ?? this.concurrency.default;
-        if (this.running.size >= globalLimit)
-            return false;
-        return true;
-    }
-    getTaskType(task) {
-        // Extract type from task metadata if available
-        const meta = task.data;
-        const typeValue = meta?.type;
-        // Validate type is a string
-        if (typeof typeValue === 'string' && typeValue.length > 0) {
-            return typeValue;
-        }
-        return 'default';
-    }
-    /**
-     * Count running tasks of a specific type.
-     * FIX: Now properly tracks task types.
-     */
-    countRunningByType(type) {
-        let count = 0;
-        for (const info of this.running.values()) {
-            if (info.taskType === type) {
-                count++;
-            }
-        }
-        return count;
-    }
-    startTask(task) {
-        const startTime = this.clock.now();
-        const taskType = this.getTaskType(task);
-        // Emit task start via progress callback (state-of-the-art observability)
-        this.emitTaskStart(task.id, taskType);
-        const promise = this.executeWithTimeout(task, startTime)
-            .then((output) => ({
-            taskId: task.id,
-            status: 'completed',
-            output,
-            durationMs: this.clock.now() - startTime,
-            startedAt: startTime,
-            completedAt: this.clock.now(),
-        }))
-            .catch((error) => ({
-            taskId: task.id,
-            status: 'failed',
-            error: error instanceof Error ? error : new Error(String(error)),
-            durationMs: this.clock.now() - startTime,
-            startedAt: startTime,
-            completedAt: this.clock.now(),
-        }))
-            .finally(() => {
-            this.running.delete(task.id);
-        });
-        // Track completion status (fire-and-forget)
-        void promise.then((r) => {
-            if (r.status === 'completed') {
-                this.completed.add(task.id);
-            }
-            else {
-                this.failed.add(task.id);
-            }
-            return;
-        });
-        this.running.set(task.id, {
-            taskId: task.id,
-            taskType,
-            promise,
-        });
-    }
-    /**
-     * Execute task with optional timeout support.
-     * State-of-the-art: proper timeout handling with AbortController pattern.
-     */
-    executeWithTimeout(task, _startTime) {
-        if (this.taskTimeoutMs <= 0) {
-            return this.executorFn(task);
-        }
-        return Promise.race([this.executorFn(task), this.createTimeoutPromise(task.id)]);
-    }
-    createTimeoutPromise(taskId) {
-        return new Promise((resolve) => {
-            setTimeout(() => resolve(), this.taskTimeoutMs);
-        }).then(() => {
-            throw new Error(`Task "${taskId}" timed out after ${this.taskTimeoutMs}ms`);
-        });
-    }
-    emitTaskStart(_taskId, _taskType) {
-        if (!this.onProgress)
-            return;
-        // Progress callback gets task start info via runningTasks update
-        // This is called before the task is added to running, so it appears in next progress update
-    }
-    waitForAny() {
-        const promises = Array.from(this.running.values()).map((info) => info.promise);
-        return Promise.race(promises);
-    }
-    emitProgress(currentWave, totalWaves, totalTasks, latestResult) {
-        if (!this.onProgress)
-            return;
-        this.onProgress({
-            totalTasks,
-            completedTasks: this.completed.size,
-            failedTasks: this.failed.size,
-            runningTasks: Array.from(this.running.keys()),
-            pendingTasks: totalTasks - this.completed.size - this.failed.size - this.skipped.size - this.running.size,
-            currentWave,
-            totalWaves,
-            latestResult,
-        });
-    }
-}
-/**
- * Create executor from task array with dependencies.
- * Convenience function for common use case.
- */
-export function createExecutor(tasks, executorFn, options) {
-    const graph = new TaskGraph();
-    // Add all tasks first
-    for (const { task } of tasks) {
-        graph.addTask(task);
-    }
-    // Add dependencies
-    for (const { task, dependsOn } of tasks) {
-        if (dependsOn) {
-            for (const dep of dependsOn) {
-                graph.addDependency(dep, task.id);
-            }
-        }
-    }
-    return new ParallelExecutor(graph, executorFn, options);
-}
-/**
- * Create executor directly from tasks using their dependencies arrays.
- * Most convenient for LLM agents.
- */
-export function createExecutorFromTasks(tasks, executorFn, options) {
-    const graph = new TaskGraph();
-    graph.addTasksWithDependencies(tasks);
-    return new ParallelExecutor(graph, executorFn, options);
-}
-//# sourceMappingURL=executor.js.map