@webpresso/agent-kit 3.3.1 → 3.3.3

package/dist/esm/compose/ops-report-schema.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+/** Flat section only — no nesting (plan Fx17). */
+export declare const opsReportSectionSchema: z.ZodObject<{
+    heading: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    list: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const opsReportMetricSchema: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+}, z.core.$strict>;
+export declare const opsReportTableSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    headers: z.ZodArray<z.ZodString>;
+    rows: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+}, z.core.$strict>;
+/**
+ * Minimal ops-report IR. Not a general page AST.
+ * Nesting under sections is rejected by the section schema (flat only).
+ */
+/** Flat ops-report only; section objects are `.strict()` so nested keys fail at the section boundary. */
+export declare const opsReportSpecSchema: z.ZodObject<{
+    title: z.ZodString;
+    generatedAt: z.ZodString;
+    metrics: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    }, z.core.$strict>>>>;
+    tables: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        headers: z.ZodArray<z.ZodString>;
+        rows: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    }, z.core.$strict>>>>;
+    warnings: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    sections: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        heading: z.ZodString;
+        body: z.ZodOptional<z.ZodString>;
+        list: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>;
+export type OpsReportSpec = z.infer<typeof opsReportSpecSchema>;
+export type OpsReportSection = z.infer<typeof opsReportSectionSchema>;

package/dist/esm/compose/ops-report-schema.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+/** Flat section only — no nesting (plan Fx17). */
+export const opsReportSectionSchema = z
+    .object({
+    heading: z.string().min(1),
+    body: z.string().optional(),
+    list: z.array(z.string()).optional(),
+})
+    .strict()
+    .superRefine((section, ctx) => {
+    if (section.body === undefined && section.list === undefined) {
+        ctx.addIssue({
+            code: "custom",
+            message: "section requires body and/or list",
+            path: ["body"],
+        });
+    }
+});
+export const opsReportMetricSchema = z
+    .object({
+    label: z.string().min(1),
+    value: z.union([z.string(), z.number()]),
+})
+    .strict();
+export const opsReportTableSchema = z
+    .object({
+    title: z.string().optional(),
+    headers: z.array(z.string()).min(1),
+    rows: z.array(z.array(z.union([z.string(), z.number()]))),
+})
+    .strict();
+/**
+ * Minimal ops-report IR. Not a general page AST.
+ * Nesting under sections is rejected by the section schema (flat only).
+ */
+/** Flat ops-report only; section objects are `.strict()` so nested keys fail at the section boundary. */
+export const opsReportSpecSchema = z
+    .object({
+    title: z.string().min(1),
+    generatedAt: z.string().min(1),
+    metrics: z.array(opsReportMetricSchema).optional().default([]),
+    tables: z.array(opsReportTableSchema).optional().default([]),
+    warnings: z.array(z.string()).optional().default([]),
+    sections: z.array(opsReportSectionSchema).optional().default([]),
+})
+    .strict();

package/dist/esm/compose/preview.d.ts

@@ -0,0 +1,14 @@
+export interface PreviewOpsReportOptions {
+    readonly cwd?: string;
+    readonly spec: unknown;
+    /** Override output path (tests). */
+    readonly outputPath?: string;
+}
+export interface PreviewOpsReportResult {
+    readonly path: string;
+}
+/**
+ * Validate ops-report spec, write HTML under state-root (or override), return path only.
+ * No browser open.
+ */
+export declare function previewOpsReport(options: PreviewOpsReportOptions): PreviewOpsReportResult;

package/dist/esm/compose/preview.js

@@ -0,0 +1,32 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getSurfacePath, NotInGitRepoError } from "#paths/state-root.js";
+import { composeValidate } from "./compose.js";
+import { renderOpsReportHtml } from "./ops-report-render.js";
+/**
+ * Validate ops-report spec, write HTML under state-root (or override), return path only.
+ * No browser open.
+ */
+export function previewOpsReport(options) {
+    const composed = composeValidate({ profile: "ops-report", spec: options.spec }, { cwd: options.cwd });
+    if (!composed.ok) {
+        const detail = composed.diagnostics.map((d) => `${d.path}: ${d.message}`).join("; ");
+        throw new Error(`ops-report compose failed: ${detail}`);
+    }
+    const html = renderOpsReportHtml(composed.spec);
+    const path = options.outputPath ??
+        (() => {
+            try {
+                return getSurfacePath("compose/ops-report.html", "worktree", options.cwd);
+            }
+            catch (error) {
+                if (error instanceof NotInGitRepoError) {
+                    return join(options.cwd ?? process.cwd(), ".webpresso", "compose", "ops-report.html");
+                }
+                throw error;
+            }
+        })();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, html, "utf8");
+    return { path };
+}

package/dist/esm/compose/registry-resolve.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+export declare const blockRegistrySchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    version: z.ZodString;
+    minVersion: z.ZodOptional<z.ZodString>;
+    blocks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        view: z.ZodEnum<{
+            detail: "detail";
+            form: "form";
+            list: "list";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        props: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        variants: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        slots: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        permissions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        deprecated: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export type BlockRegistry = z.infer<typeof blockRegistrySchema>;
+export type RegistrySource = "project" | "snapshot";
+export interface ResolvedBlockRegistry {
+    readonly registry: BlockRegistry;
+    readonly source: RegistrySource;
+    readonly registryVersion: string;
+    readonly path: string;
+    readonly warnings: readonly string[];
+    /** True when a `.webpresso/` tree was found but project registry was missing. */
+    readonly webpressoPresentWithoutRegistry: boolean;
+}
+export declare function defaultSnapshotPath(): string;
+/**
+ * Two-tier registry resolution (v0):
+ * 1. Nearest project `.webpresso/` (within git/webpressorc boundary) — if it has
+ *    generated blocks registry, use it
+ * 2. Else catalog snapshot (with warning when that project `.webpresso/` lacks registry)
+ *
+ * Never dynamically imports @webpresso/schema.
+ * Never climbs past the project boundary into `~/.webpresso` (managed worktree host)
+ * or other ancestor projects (avoids silent wrong-project catalog).
+ */
+export declare function resolveBlockRegistry(options?: {
+    readonly cwd?: string;
+    readonly snapshotPath?: string;
+}): ResolvedBlockRegistry;
+export declare function blockNamesForView(registry: BlockRegistry, view: "list" | "detail" | "form"): ReadonlySet<string>;

package/dist/esm/compose/registry-resolve.js

@@ -0,0 +1,133 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { resolvePackageAssetPreferred } from "#utils/package-assets.js";
+import { z } from "zod";
+const REGISTRY_RELATIVE = join("generated", "frontend", "blocks", "registry.json");
+const MAX_WALK = 48;
+/** Stop climbing past these markers (mirrors project-root clamps elsewhere). */
+function isProjectBoundary(dir) {
+    return existsSync(join(dir, ".git")) || existsSync(join(dir, ".webpressorc.json"));
+}
+/**
+ * `~/.webpresso` is the managed-worktree host, never a product project root.
+ * Matching it would mis-label every uninitialized checkout under $HOME.
+ */
+function isManagedHostWebpresso(candidate) {
+    return resolve(candidate) === resolve(join(homedir(), ".webpresso"));
+}
+const blockDefinitionSchema = z
+    .object({
+    name: z.string(),
+    view: z.enum(["list", "detail", "form"]),
+    description: z.string().optional(),
+    props: z.array(z.unknown()).optional(),
+    variants: z.array(z.string()).optional(),
+    slots: z.array(z.unknown()).optional(),
+    permissions: z.array(z.unknown()).optional(),
+    deprecated: z.boolean().optional(),
+})
+    .passthrough();
+export const blockRegistrySchema = z.object({
+    $schema: z.string().optional(),
+    version: z.string(),
+    minVersion: z.string().optional(),
+    blocks: z.array(blockDefinitionSchema).min(1),
+});
+/**
+ * Walk up for nearest project `.webpresso` directory (not a file).
+ * Clamped at the enclosing project boundary (`.git` / `.webpressorc.json`)
+ * and never treats `~/.webpresso` (managed worktree host) as a project root.
+ */
+function walkUpForWebpressoDir(startDir) {
+    let dir = resolve(startDir);
+    for (let i = 0; i < MAX_WALK; i++) {
+        const candidate = join(dir, ".webpresso");
+        if (existsSync(candidate)) {
+            try {
+                if (statSync(candidate).isDirectory() && !isManagedHostWebpresso(candidate)) {
+                    return candidate;
+                }
+            }
+            catch {
+                // ignore unreadable markers
+            }
+        }
+        // Do not climb past the repo / consumer root into $HOME tooling dirs.
+        if (isProjectBoundary(dir))
+            return null;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+    return null;
+}
+export function defaultSnapshotPath() {
+    // Portable across src/ and dist/esm/ via package-root walk (no fixed-depth joins).
+    const assetPath = resolvePackageAssetPreferred(["catalog/compose/admin-blocks-registry.json"]);
+    if (!existsSync(assetPath)) {
+        throw new Error(`admin-blocks-registry.json snapshot not found at package asset path: ${assetPath}`);
+    }
+    return assetPath;
+}
+function loadRegistryFile(path) {
+    try {
+        const raw = readFileSync(path, "utf8");
+        const parsed = JSON.parse(raw);
+        return blockRegistrySchema.parse(parsed);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to load block registry at ${path}: ${detail}`, { cause: error });
+    }
+}
+/**
+ * Two-tier registry resolution (v0):
+ * 1. Nearest project `.webpresso/` (within git/webpressorc boundary) — if it has
+ *    generated blocks registry, use it
+ * 2. Else catalog snapshot (with warning when that project `.webpresso/` lacks registry)
+ *
+ * Never dynamically imports @webpresso/schema.
+ * Never climbs past the project boundary into `~/.webpresso` (managed worktree host)
+ * or other ancestor projects (avoids silent wrong-project catalog).
+ */
+export function resolveBlockRegistry(options = {}) {
+    const start = options.cwd
+        ? isAbsolute(options.cwd)
+            ? options.cwd
+            : resolve(process.cwd(), options.cwd)
+        : process.cwd();
+    const webpressoRoot = walkUpForWebpressoDir(start);
+    const warnings = [];
+    if (webpressoRoot) {
+        const projectPath = join(webpressoRoot, REGISTRY_RELATIVE);
+        if (existsSync(projectPath)) {
+            const registry = loadRegistryFile(projectPath);
+            return {
+                registry,
+                source: "project",
+                registryVersion: registry.version,
+                path: projectPath,
+                warnings,
+                webpressoPresentWithoutRegistry: false,
+            };
+        }
+    }
+    const snapshotPath = options.snapshotPath ?? defaultSnapshotPath();
+    const registry = loadRegistryFile(snapshotPath);
+    if (webpressoRoot) {
+        warnings.push(`Project has .webpresso/ at ${webpressoRoot} but no ${join(".webpresso", REGISTRY_RELATIVE)}; using catalog snapshot ${registry.version}. Run schema frontend codegen / converge to materialize a project registry.`);
+    }
+    return {
+        registry,
+        source: "snapshot",
+        registryVersion: registry.version,
+        path: snapshotPath,
+        warnings,
+        webpressoPresentWithoutRegistry: webpressoRoot !== null,
+    };
+}
+export function blockNamesForView(registry, view) {
+    return new Set(registry.blocks.filter((block) => block.view === view).map((block) => block.name));
+}

package/dist/esm/git/changed-files.d.ts

@@ -5,6 +5,26 @@ export interface ChangedFilesResult {
     readonly reason: ChangedFilesReason;
 }
 export declare function defaultBranchBaseRef(env?: NodeJS.ProcessEnv): string;
+/**
+ * Latest fork point of `HEAD` from the base branch, given a caller-supplied base.
+ *
+ * CI passes `--base "$PR_BASE_SHA"` (`github.event.pull_request.base.sha`),
+ * which is pinned when the pull request is opened and does NOT advance as the
+ * base branch does. Once the branch is rebased onto a newer base — the
+ * documented recovery flow for a stale branch — that pinned SHA is no longer the
+ * fork point, so `<pinned>...HEAD` reports every commit merged into the base
+ * branch since the PR opened as if this branch had authored it. Scoped gates
+ * then fail a branch for unrelated, already-merged work.
+ *
+ * `git merge-base` against the LIVE base branch ref is recomputed from current
+ * history, so it tracks the rebase and yields the true fork point. Prefer it,
+ * but only when it is provably a descendant of the caller's base (never widen
+ * the range the caller asked for) and does not swallow `HEAD` (a base branch
+ * that already contains `HEAD` would otherwise empty the scope). Otherwise the
+ * caller's base is returned verbatim, so an unrelated or unresolvable live ref
+ * can never silently replace an explicit base.
+ */
+export declare function resolveBranchDiffBase(cwd?: string, base?: string, liveBaseRef?: string): string;
 export declare function getGitTopLevel(cwd?: string): string | null;
 export declare function getStagedFiles(cwd?: string): ChangedFilesResult;
 export declare function getBranchChangedFiles(cwd?: string, base?: string): ChangedFilesResult;

package/dist/esm/git/changed-files.js

@@ -5,6 +5,69 @@ export function defaultBranchBaseRef(env = process.env) {
     const githubBaseRef = env.GITHUB_BASE_REF?.trim();
     return `origin/${githubBaseRef && githubBaseRef.length > 0 ? githubBaseRef : "main"}`;
 }
+/**
+ * Latest fork point of `HEAD` from the base branch, given a caller-supplied base.
+ *
+ * CI passes `--base "$PR_BASE_SHA"` (`github.event.pull_request.base.sha`),
+ * which is pinned when the pull request is opened and does NOT advance as the
+ * base branch does. Once the branch is rebased onto a newer base — the
+ * documented recovery flow for a stale branch — that pinned SHA is no longer the
+ * fork point, so `<pinned>...HEAD` reports every commit merged into the base
+ * branch since the PR opened as if this branch had authored it. Scoped gates
+ * then fail a branch for unrelated, already-merged work.
+ *
+ * `git merge-base` against the LIVE base branch ref is recomputed from current
+ * history, so it tracks the rebase and yields the true fork point. Prefer it,
+ * but only when it is provably a descendant of the caller's base (never widen
+ * the range the caller asked for) and does not swallow `HEAD` (a base branch
+ * that already contains `HEAD` would otherwise empty the scope). Otherwise the
+ * caller's base is returned verbatim, so an unrelated or unresolvable live ref
+ * can never silently replace an explicit base.
+ */
+export function resolveBranchDiffBase(cwd = process.cwd(), base = defaultBranchBaseRef(), liveBaseRef = defaultBranchBaseRef()) {
+    const forkPoint = readMergeBase(cwd, liveBaseRef, "HEAD");
+    if (forkPoint === null || forkPoint === readCommit(cwd, "HEAD"))
+        return base;
+    return isAncestorCommit(cwd, base, forkPoint) ? forkPoint : base;
+}
+function readCommit(cwd, ref) {
+    try {
+        const output = execFileSync("git", ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return output.length > 0 ? output : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readMergeBase(cwd, left, right) {
+    try {
+        const output = execFileSync("git", ["merge-base", left, right], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return output.length > 0 ? output : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isAncestorCommit(cwd, ancestor, descendant) {
+    try {
+        execFileSync("git", ["merge-base", "--is-ancestor", ancestor, descendant], {
+            cwd,
+            stdio: ["ignore", "ignore", "ignore"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function getGitTopLevel(cwd = process.cwd()) {
     try {
         const output = execFileSync("git", ["rev-parse", "--show-toplevel"], {

package/dist/esm/hooks/pretool-guard/validators/plan-frontmatter.js

@@ -1,5 +1,6 @@
 import { parse as parseYaml } from "yaml";
 import { getContent, getFilePath } from "#hooks/shared/types";
+import { buildTaskHeadingRegex, buildWrongDepthTaskHeadingRegex } from "#markdown/task-heading";
 import { getNonCanonicalPlanningPathViolation, isBlueprintPath, isCanonicalBlueprintDocumentPath, } from "./path-contract.js";
 import { createSkipResult } from "./skip-result.js";
 // Keep aligned with webpresso/blueprint planStatusSchema + plan type enum.
@@ -53,10 +54,10 @@ export function collectFieldViolations(data) {
     return violations;
 }
 export function countTaskHeadings(content) {
-    return content.match(/^####\s+Task\s+\d+(?:\.\d+)+:/gm)?.length ?? 0;
+    return content.match(buildTaskHeadingRegex("gm"))?.length ?? 0;
 }
 export function detectWrongTaskFormat(content) {
-    return content.match(/^###\s+Task\s+\d+(?:\.\d+)+:/gm)?.length ?? 0;
+    return content.match(buildWrongDepthTaskHeadingRegex("gm"))?.length ?? 0;
 }
 export function validatePlanFrontmatter(input) {
     const filePath = getFilePath(input);

package/dist/esm/hooks/stop/qa-changed-files.js

@@ -45,12 +45,17 @@ export function filterQaFiles(files) {
 export function getTypecheckFiles(files) {
     return files.filter((f) => TYPECHECKABLE_EXTENSIONS.has(extname(f)));
 }
+const TEST_SOURCE_EXTENSIONS = new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx"]);
 export function findTestFiles(sourceFile, projectDir) {
     const ext = extname(sourceFile);
     const base = basename(sourceFile, ext);
     const dir = dirname(sourceFile);
-    if (base.endsWith(".test") || base.endsWith(".integration.test"))
+    // Only treat real test modules as tests. Names like `tsconfig.test.json` end
+    // with `.test` after stripping the extension and must not become vitest filters.
+    if (TEST_SOURCE_EXTENSIONS.has(ext) &&
+        (base.endsWith(".test") || base.endsWith(".integration.test"))) {
         return [sourceFile];
+    }
     const pattern = join(dir, `${base}.{test,integration.test}{.ts,.tsx}`);
     return globSync(pattern, { cwd: projectDir, withFileTypes: false });
 }

package/dist/esm/mcp/blueprint/handlers/document-mutations.js

@@ -4,6 +4,7 @@ import { z } from "zod";
 import matter from "gray-matter";
 import { parseBlueprint } from "#core/parser";
 import { taskIdSchema } from "#core/schema";
+import { formatTaskHeading } from "#markdown/task-heading";
 import { evaluateApprovalGate, formatApprovalGateRequirement } from "#lifecycle/audit";
 import { canonicalizeBlueprint } from "#lifecycle/canonicalize.js";
 import { BlueprintCreationService } from "#service/BlueprintCreationService";
@@ -290,7 +291,7 @@ function renderBlueprintMarkdownFromDocument(slug, document) {
         "",
     ];
     const taskBlocks = document.tasks.flatMap((task) => [
-        `#### Task ${task.id}: ${task.title}`,
+        formatTaskHeading(task.id, task.title),
         "",
         `**Status:** ${task.status}`,
         ...(task.wave ? [`**Wave:** ${task.wave}`] : []),

package/dist/esm/mcp/blueprint/handlers/task-advance.js

@@ -11,23 +11,13 @@ import { toStr } from "#mcp/blueprint/_shared/payload";
 import { findBlueprintDir, resolveToolProject } from "#mcp/blueprint/_shared/project";
 import { resolveSyncAdapter, runPlatformMutationSync } from "#mcp/blueprint/_shared/sync";
 import { writeFileAtomic } from "#shared-utils/write-json-file.js";
-import { escapeRegex } from "#utils/string";
+import { buildTaskHeaderRegexForId } from "#markdown/task-heading";
 import { withMarkdownWriteLock } from "#db/paths.js";
 import { resolveBlueprintRoot } from "#utils/blueprint-root.js";
 const ALL_STATES = ["draft", "planned", "in-progress", "parked", "archived", "completed"];
-/**
- * Matches the canonical task-heading grammar `parser.ts`'s `extractTasks`
- * uses (`^####\s+(?:\[lane\]\s+)?Task\s+<id>:`), not a looser ad hoc pattern.
- * The id is anchored on a trailing colon so "1.1" cannot match "1.10", and
- * an optional `[lane]` prefix is accepted the same way the canonical parser
- * does.
- */
-function buildTaskHeadingPattern(taskId) {
-    return new RegExp(`^####\\s+(?:\\[[^\\]]+\\]\\s+)?Task\\s+${escapeRegex(taskId)}:`, "u");
-}
 function findTaskStatusLine(markdown, taskId) {
     const lines = markdown.split("\n");
-    const headingPattern = buildTaskHeadingPattern(taskId);
+    const headingPattern = buildTaskHeaderRegexForId(taskId);
     let inBlock = false;
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i] ?? "";

package/dist/esm/mcp/blueprint/handlers/validate.js

@@ -41,6 +41,12 @@ export function runValidate(filePath) {
         gaps.push(`Invalid frontmatter field: last_updated (${lastUpdated})`);
     }
     const body = fm.content;
+    // Deliberately LOOSER than the canonical grammar in `#markdown/task-heading`
+    // (`Task\s+\S` accepts any id, not just `\d+(?:\.\d+)+`, and needs no title).
+    // This is a gap REPORTER: it has to see a malformed heading in order to tell
+    // the author about it. Converging it onto the strict matcher would make
+    // exactly the malformed tasks it exists to catch invisible again — the
+    // reported gaps would silently drop to zero. Do not "de-duplicate" this.
     const taskHeaderRegex = /^####\s+(?:\[[^\]]+\]\s+)?Task\s+\S/m;
     if (!taskHeaderRegex.test(body))
         gaps.push('No "#### Task" sections found');

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

@@ -8,4 +8,4 @@
  * is enforced by `_names.test.ts` against `COMPILED_TOOL_REGISTRY`, so this list
  * cannot silently drift.
  */
-export declare const WP_TOOL_NAMES: readonly ["wp_audit", "wp_audits", "wp_bench", "wp_ci_act", "wp_ci_preflight", "wp_e2e", "wp_fleet_status", "wp_format", "wp_gain", "wp_lint", "wp_pr_status", "wp_pr_upsert", "wp_pr_wait", "wp_qa", "wp_release_readiness", "wp_review_run", "wp_run_wait", "wp_session_batch_execute", "wp_session_capture", "wp_session_context", "wp_session_doctor", "wp_session_execute", "wp_session_execute_file", "wp_session_fetch_and_index", "wp_session_id", "wp_session_index", "wp_session_info", "wp_session_purge", "wp_session_retrieve", "wp_session_restore", "wp_session_search", "wp_session_snapshot", "wp_session_stats", "wp_test", "wp_typecheck", "wp_ultragoal_cancel", "wp_ultragoal_handoff", "wp_ultragoal_new", "wp_ultragoal_run", "wp_ultragoal_status", "wp_worker_tail", "wp_worktree"];
+export declare const WP_TOOL_NAMES: readonly ["wp_audit", "wp_audits", "wp_bench", "wp_ci_act", "wp_ci_preflight", "wp_e2e", "wp_fleet_status", "wp_format", "wp_gain", "wp_lint", "wp_pr_status", "wp_pr_upsert", "wp_pr_wait", "wp_qa", "wp_release_progress", "wp_release_readiness", "wp_review_run", "wp_run_wait", "wp_session_batch_execute", "wp_session_capture", "wp_session_context", "wp_session_doctor", "wp_session_execute", "wp_session_execute_file", "wp_session_fetch_and_index", "wp_session_id", "wp_session_index", "wp_session_info", "wp_session_purge", "wp_session_retrieve", "wp_session_restore", "wp_session_search", "wp_session_snapshot", "wp_session_stats", "wp_test", "wp_typecheck", "wp_ui_blocks_list", "wp_ui_compose", "wp_ui_preview", "wp_ultragoal_cancel", "wp_ultragoal_handoff", "wp_ultragoal_new", "wp_ultragoal_run", "wp_ultragoal_status", "wp_worker_tail", "wp_worktree"];

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

@@ -23,6 +23,7 @@ export const WP_TOOL_NAMES = [
     "wp_pr_upsert",
     "wp_pr_wait",
     "wp_qa",
+    "wp_release_progress",
     "wp_release_readiness",
     "wp_review_run",
     "wp_run_wait",
@@ -44,6 +45,9 @@ export const WP_TOOL_NAMES = [
     "wp_session_stats",
     "wp_test",
     "wp_typecheck",
+    "wp_ui_blocks_list",
+    "wp_ui_compose",
+    "wp_ui_preview",
     "wp_ultragoal_cancel",
     "wp_ultragoal_handoff",
     "wp_ultragoal_new",

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

@@ -12,6 +12,7 @@ import prStatus from "./pr-status.js";
 import prUpsert from "./pr-upsert.js";
 import prWait from "./pr-wait.js";
 import qa from "./qa.js";
+import releaseProgress from "./release-progress.js";
 import releaseReadiness from "./release-readiness.js";
 import reviewRun from "./review-run.js";
 import runWait from "./run-wait.js";
@@ -33,6 +34,9 @@ import sessionSnapshot from "./session-snapshot.js";
 import sessionStats from "./session-stats.js";
 import test from "./test.js";
 import typecheck from "./typecheck.js";
+import uiBlocksList from "./wp-ui-blocks-list.js";
+import uiCompose from "./wp-ui-compose.js";
+import uiPreview from "./wp-ui-preview.js";
 import ultragoalCancel from "./ultragoal-cancel.js";
 import ultragoalHandoff from "./ultragoal-handoff.js";
 import ultragoalNew from "./ultragoal-new.js";
@@ -55,6 +59,7 @@ export const COMPILED_TOOL_REGISTRY = [
     prUpsert,
     prWait,
     qa,
+    releaseProgress,
     releaseReadiness,
     reviewRun,
     runWait,
@@ -76,6 +81,9 @@ export const COMPILED_TOOL_REGISTRY = [
     sessionStats,
     test,
     typecheck,
+    uiBlocksList,
+    uiCompose,
+    uiPreview,
     ultragoalCancel,
     ultragoalHandoff,
     ultragoalNew,

package/dist/esm/mcp/tools/release-progress.d.ts

@@ -0,0 +1,9 @@
+import type { ToolDescriptor } from "#mcp/auto-discover";
+import { type RunReleaseProgressOptions } from "#cli/commands/release-progress.js";
+export type ReleaseProgressToolDeps = Pick<RunReleaseProgressOptions, "fetchJobs" | "resolveLatestRunId">;
+/**
+ * Build the tool descriptor. Tests inject gh seams; production uses defaults.
+ */
+export declare function createReleaseProgressTool(deps?: ReleaseProgressToolDeps): ToolDescriptor;
+declare const tool: ToolDescriptor;
+export default tool;