@webpresso/agent-kit 3.1.30 → 3.2.0

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_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_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_index", "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_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"];

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

@@ -13,6 +13,7 @@ export const WP_TOOL_NAMES = [
     "wp_audits",
     "wp_bench",
     "wp_ci_act",
+    "wp_ci_preflight",
     "wp_e2e",
     "wp_fleet_status",
     "wp_format",
@@ -23,6 +24,8 @@ export const WP_TOOL_NAMES = [
     "wp_pr_wait",
     "wp_qa",
     "wp_release_readiness",
+    "wp_review_run",
+    "wp_run_wait",
     "wp_session_batch_execute",
     "wp_session_capture",
     "wp_session_context",
@@ -30,7 +33,9 @@ export const WP_TOOL_NAMES = [
     "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",

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

@@ -2,6 +2,7 @@ import audit from "./audit.js";
 import audits from "./audits.js";
 import bench from "./bench.js";
 import ciAct from "./ci-act.js";
+import ciPreflight from "./ci-preflight.js";
 import e2e from "./e2e.js";
 import format from "./format.js";
 import fleet from "./fleet.js";
@@ -12,6 +13,8 @@ import prUpsert from "./pr-upsert.js";
 import prWait from "./pr-wait.js";
 import qa from "./qa.js";
 import releaseReadiness from "./release-readiness.js";
+import reviewRun from "./review-run.js";
+import runWait from "./run-wait.js";
 import sessionBatchExecute from "./session-batch-execute.js";
 import sessionCapture from "./session-capture.js";
 import sessionContext from "./session-context.js";
@@ -19,7 +22,9 @@ import sessionDoctor from "./session-doctor.js";
 import sessionExecute from "./session-execute.js";
 import sessionExecuteFile from "./session-execute-file.js";
 import sessionFetchAndIndex from "./session-fetch-and-index.js";
+import sessionId from "./session-id.js";
 import sessionIndex from "./session-index.js";
+import sessionInfo from "./session-info.js";
 import sessionPurge from "./session-purge.js";
 import sessionRetrieve from "./session-retrieve.js";
 import sessionRestore from "./session-restore.js";
@@ -40,6 +45,7 @@ export const COMPILED_TOOL_REGISTRY = [
     audits,
     bench,
     ciAct,
+    ciPreflight,
     e2e,
     fleet,
     format,
@@ -50,6 +56,8 @@ export const COMPILED_TOOL_REGISTRY = [
     prWait,
     qa,
     releaseReadiness,
+    reviewRun,
+    runWait,
     sessionBatchExecute,
     sessionCapture,
     sessionContext,
@@ -57,7 +65,9 @@ export const COMPILED_TOOL_REGISTRY = [
     sessionExecute,
     sessionExecuteFile,
     sessionFetchAndIndex,
+    sessionId,
     sessionIndex,
+    sessionInfo,
     sessionPurge,
     sessionRetrieve,
     sessionRestore,

package/dist/esm/mcp/tools/_shared/audit-kinds.d.ts

@@ -1,3 +1,3 @@
-export declare const MCP_AUDIT_KINDS: readonly ["test-smells", "tph-e2e", "agents", "catalog-drift", "package-surface", "reference-parity-matrix", "docs-frontmatter", "blueprint-readme-drift", "blueprint-pr-coverage", "blueprint-lifecycle", "blueprint-trust", "architecture-drift", "cloudflare-deploy-contract", "absolute-path-policy", "no-first-party-mjs", "no-math-random", "roadmap-links", "bundle-budget", "commit-message", "tech-debt", "supported-agent-clis", "hook-surface", "harness-surfaces", "weakness-mining", "harness-overlay-evidence", "ai-contracts", "atomic-state-writes", "no-relative-package-scripts", "toolchain-isolation", "open-source-licenses", "secrets-policy", "no-dev-vars", "github-actions-secrets", "secret-provider-quarantine", "security-quality-regressions", "secrets-config", "consumer-agent-kit-dependency", "ci-test-perf", "test-scan-perf", "session-memory-hardcut", "worktree-main-ownership", "sast"];
+export declare const MCP_AUDIT_KINDS: readonly ["test-smells", "tph-e2e", "agents", "catalog-drift", "package-surface", "reference-parity-matrix", "docs-frontmatter", "blueprint-readme-drift", "blueprint-pr-coverage", "blueprint-lifecycle", "blueprint-trust", "architecture-drift", "cloudflare-deploy-contract", "absolute-path-policy", "no-first-party-mjs", "no-math-random", "roadmap-links", "bundle-budget", "commit-message", "tech-debt", "supported-agent-clis", "hook-surface", "harness-surfaces", "weakness-mining", "harness-overlay-evidence", "host-substitution-risk", "ai-contracts", "atomic-state-writes", "no-relative-package-scripts", "toolchain-isolation", "open-source-licenses", "secrets-policy", "no-dev-vars", "github-actions-secrets", "secret-provider-quarantine", "security-quality-regressions", "secrets-config", "consumer-agent-kit-dependency", "ci-test-perf", "test-scan-perf", "session-memory-hardcut", "worktree-main-ownership", "typescript-version", "ci-guardrails-wiring", "sast"];
 export type MCPAuditKind = (typeof MCP_AUDIT_KINDS)[number];
 export declare function isMCPAuditKind(value: string): value is MCPAuditKind;

package/dist/esm/mcp/tools/_shared/result.js

@@ -82,8 +82,51 @@ export function clipRawOutput(rawOutput, maxChars = DEFAULT_RAW_OUTPUT_LIMIT, op
         ...(recorded?.warning ? { warnings: [recorded.warning] } : {}),
     };
 }
+/**
+ * Maximum bytes of serialized `details` appended to an ERROR result's text
+ * content. Generous enough to carry a full validation-error array or a failed
+ * command record, small enough that a pathological payload cannot flood the
+ * caller's context.
+ */
+const ERROR_DETAIL_TEXT_LIMIT = 2_000;
+/**
+ * Render the actionable part of a failing payload for the text `content`.
+ *
+ * MCP hosts surface `content` (not `structuredContent`) when `isError` is set,
+ * so an error whose text is only the one-line `summary` forces the caller to
+ * go read the tool's source to learn WHAT failed — e.g. `wp_pr_upsert`
+ * returning bare "PR description validation failed; no GitHub mutation was
+ * attempted" while `details.validation.errors` held the exact missing fields.
+ * That round trip is pure wasted context. Fold the details into the text so
+ * one call is enough.
+ */
+function renderErrorDetail(payload) {
+    const details = payload.details;
+    if (details === undefined || details === null)
+        return undefined;
+    let serialized;
+    try {
+        // Compact (no pretty-print indentation): keeps the payload cheap in the
+        // caller's context, and avoids emitting whitespace runs that never came
+        // from the data — `session-index.test.ts` asserts a whitespace-only INPUT
+        // is not echoed back, which indented output would trip incidentally.
+        serialized = JSON.stringify(details);
+    }
+    catch {
+        return undefined; // circular/unserializable — summary alone still ships
+    }
+    if (!serialized || serialized === "{}" || serialized === "[]")
+        return undefined;
+    return serialized.length <= ERROR_DETAIL_TEXT_LIMIT
+        ? serialized
+        : `${serialized.slice(0, ERROR_DETAIL_TEXT_LIMIT - 1)}…`;
+}
 export function createSummaryResult(payload, options = {}) {
-    const text = clipSummaryText(options.text ?? payload.summary);
+    const summaryText = clipSummaryText(options.text ?? payload.summary);
+    // Only errors get the detail block: success results are already summary-first
+    // by design, and their details are available via `structuredContent`.
+    const detail = options.isError ? renderErrorDetail(payload) : undefined;
+    const text = detail ? `${summaryText}\n\n${detail}` : summaryText;
     return {
         content: [{ type: "text", text }],
         structuredContent: payload,

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

@@ -15,7 +15,7 @@
  */
 import { z } from "zod";
 import type { ToolDescriptor } from "#mcp/auto-discover";
-export declare const KINDS: readonly ["test-smells", "tph-e2e", "agents", "catalog-drift", "package-surface", "reference-parity-matrix", "docs-frontmatter", "blueprint-readme-drift", "blueprint-pr-coverage", "blueprint-lifecycle", "blueprint-trust", "architecture-drift", "cloudflare-deploy-contract", "absolute-path-policy", "no-first-party-mjs", "no-math-random", "roadmap-links", "bundle-budget", "commit-message", "tech-debt", "supported-agent-clis", "hook-surface", "harness-surfaces", "weakness-mining", "harness-overlay-evidence", "ai-contracts", "atomic-state-writes", "no-relative-package-scripts", "toolchain-isolation", "open-source-licenses", "secrets-policy", "no-dev-vars", "github-actions-secrets", "secret-provider-quarantine", "security-quality-regressions", "secrets-config", "consumer-agent-kit-dependency", "ci-test-perf", "test-scan-perf", "session-memory-hardcut", "worktree-main-ownership", "sast"];
+export declare const KINDS: readonly ["test-smells", "tph-e2e", "agents", "catalog-drift", "package-surface", "reference-parity-matrix", "docs-frontmatter", "blueprint-readme-drift", "blueprint-pr-coverage", "blueprint-lifecycle", "blueprint-trust", "architecture-drift", "cloudflare-deploy-contract", "absolute-path-policy", "no-first-party-mjs", "no-math-random", "roadmap-links", "bundle-budget", "commit-message", "tech-debt", "supported-agent-clis", "hook-surface", "harness-surfaces", "weakness-mining", "harness-overlay-evidence", "host-substitution-risk", "ai-contracts", "atomic-state-writes", "no-relative-package-scripts", "toolchain-isolation", "open-source-licenses", "secrets-policy", "no-dev-vars", "github-actions-secrets", "secret-provider-quarantine", "security-quality-regressions", "secrets-config", "consumer-agent-kit-dependency", "ci-test-perf", "test-scan-perf", "session-memory-hardcut", "worktree-main-ownership", "typescript-version", "ci-guardrails-wiring", "sast"];
 export declare const inputSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         "absolute-path-policy": "absolute-path-policy";
@@ -29,6 +29,7 @@ export declare const inputSchema: z.ZodObject<{
         "blueprint-trust": "blueprint-trust";
         "bundle-budget": "bundle-budget";
         "catalog-drift": "catalog-drift";
+        "ci-guardrails-wiring": "ci-guardrails-wiring";
         "ci-test-perf": "ci-test-perf";
         "cloudflare-deploy-contract": "cloudflare-deploy-contract";
         "commit-message": "commit-message";
@@ -38,6 +39,7 @@ export declare const inputSchema: z.ZodObject<{
         "harness-overlay-evidence": "harness-overlay-evidence";
         "harness-surfaces": "harness-surfaces";
         "hook-surface": "hook-surface";
+        "host-substitution-risk": "host-substitution-risk";
         "no-dev-vars": "no-dev-vars";
         "no-first-party-mjs": "no-first-party-mjs";
         "no-math-random": "no-math-random";
@@ -58,6 +60,7 @@ export declare const inputSchema: z.ZodObject<{
         "test-smells": "test-smells";
         "toolchain-isolation": "toolchain-isolation";
         "tph-e2e": "tph-e2e";
+        "typescript-version": "typescript-version";
         "weakness-mining": "weakness-mining";
         "worktree-main-ownership": "worktree-main-ownership";
     }>;

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

@@ -128,6 +128,16 @@ export async function dispatchAudit(input) {
                 details: auditResult,
             };
         }
+        case "host-substitution-risk": {
+            const { auditHostSubstitutionRisk } = await import("#audit/host-substitution-risk");
+            const auditResult = auditHostSubstitutionRisk(input.cwd ?? input.directory ?? process.cwd());
+            return {
+                passed: auditResult.ok,
+                summary: summarizeRepoAudit(kind, auditResult),
+                kind,
+                details: auditResult,
+            };
+        }
         case "agents": {
             const { auditAgents } = await import("#audit/agents");
             const auditResult = auditAgents(input.cwd ?? input.directory ?? process.cwd());
@@ -464,6 +474,16 @@ export async function dispatchAudit(input) {
                 details: auditResult,
             };
         }
+        case "ci-guardrails-wiring": {
+            const { auditCiGuardrailsWiring } = await import("#audit/ci-guardrails-wiring");
+            const auditResult = auditCiGuardrailsWiring(input.cwd ?? input.directory ?? process.cwd());
+            return {
+                passed: auditResult.ok,
+                summary: summarizeRepoAudit(kind, auditResult),
+                kind,
+                details: auditResult,
+            };
+        }
         case "test-scan-perf": {
             const { auditTestScanPerf } = await import("#audit/test-scan-perf");
             const auditResult = auditTestScanPerf(input.cwd ?? input.directory ?? process.cwd());
@@ -539,6 +559,16 @@ export async function dispatchAudit(input) {
                 },
             };
         }
+        case "typescript-version": {
+            const { auditTypescriptVersion } = await import("#audit/typescript-version");
+            const auditResult = auditTypescriptVersion(input.cwd ?? input.directory ?? process.cwd());
+            return {
+                passed: auditResult.ok,
+                summary: summarizeRepoAudit(kind, auditResult),
+                kind,
+                details: auditResult,
+            };
+        }
         default: {
             // Exhaustiveness check — z.enum should make this unreachable.
             const _exhaustive = kind;

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

@@ -25,6 +25,7 @@ declare const inputSchema: z.ZodObject<{
         "blueprint-trust": "blueprint-trust";
         "bundle-budget": "bundle-budget";
         "catalog-drift": "catalog-drift";
+        "ci-guardrails-wiring": "ci-guardrails-wiring";
         "ci-test-perf": "ci-test-perf";
         "cloudflare-deploy-contract": "cloudflare-deploy-contract";
         "commit-message": "commit-message";
@@ -34,6 +35,7 @@ declare const inputSchema: z.ZodObject<{
         "harness-overlay-evidence": "harness-overlay-evidence";
         "harness-surfaces": "harness-surfaces";
         "hook-surface": "hook-surface";
+        "host-substitution-risk": "host-substitution-risk";
         "no-dev-vars": "no-dev-vars";
         "no-first-party-mjs": "no-first-party-mjs";
         "no-math-random": "no-math-random";
@@ -54,6 +56,7 @@ declare const inputSchema: z.ZodObject<{
         "test-smells": "test-smells";
         "toolchain-isolation": "toolchain-isolation";
         "tph-e2e": "tph-e2e";
+        "typescript-version": "typescript-version";
         "weakness-mining": "weakness-mining";
         "worktree-main-ownership": "worktree-main-ownership";
     }>>>;

package/dist/esm/mcp/tools/ci-preflight.d.ts

@@ -0,0 +1,50 @@
+/**
+ * `wp_ci_preflight` MCP tool.
+ *
+ * Wraps `runCiPreflight` (the single owner of the pre-push gate — see
+ * `src/cli/commands/ci-preflight.ts`) so agents can run the exact fail-fast,
+ * branch-scoped sequence CI mirrors — `format → guardrails → typecheck →
+ * lint → test` — without shelling out to `wp ci-preflight` via Bash.
+ *
+ * `runCiPreflight`'s default `runCheck` re-invokes `wp <subcommand>` via
+ * `spawnSync(..., {stdio: "inherit"})`. That is correct for a real terminal
+ * but unsafe here: `wp mcp` speaks stdio-transport JSON-RPC over the process's
+ * real stdout, and an inherited child write would corrupt that stream. This
+ * tool substitutes a `runCheck` that spawns each stage asynchronously via the
+ * shared `runCommand` helper (captured stdout/stderr, a bounded per-stage
+ * timeout, and `extra.signal` cancellation) using the same `wp` launcher
+ * resolution (`resolveWpLauncher`) the CLI uses, so behavior stays identical
+ * — only the transport of the output changes. `runCiPreflight`'s own
+ * `stdout`/`stderr` deps are swallowed for the same reason (they default to
+ * `process.stdout`/`process.stderr`); the equivalent progress detail is
+ * reconstructed from the per-stage results this tool collects itself.
+ *
+ * `runCiPreflight` returns only an exit code — there is no structured
+ * per-stage payload to "pass through." The `{passed, summary, details:
+ * {stages, stoppedAt}}` shape below mirrors `wp_qa`'s aggregate-gate
+ * convention (structured pass/fail + per-stage breakdown) since ci-preflight
+ * is the same shape of thing: a staged composite gate, just sequential and
+ * fail-fast instead of `wp_qa`'s parallel `Promise.all`.
+ */
+import { z } from "zod";
+import type { ToolDescriptor } from "#mcp/auto-discover";
+declare const inputSchema: z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
+    full: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export type AkCiPreflightInput = z.infer<typeof inputSchema>;
+declare const stageResultSchema: z.ZodObject<{
+    label: z.ZodString;
+    args: z.ZodArray<z.ZodString>;
+    passed: z.ZodBoolean;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    timedOut: z.ZodOptional<z.ZodBoolean>;
+    aborted: z.ZodOptional<z.ZodBoolean>;
+    spawnError: z.ZodOptional<z.ZodString>;
+    rawOutput: z.ZodOptional<z.ZodString>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+    logPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CiPreflightStageResult = z.infer<typeof stageResultSchema>;
+declare const tool: ToolDescriptor;
+export default tool;

package/dist/esm/mcp/tools/ci-preflight.js

@@ -0,0 +1,183 @@
+/**
+ * `wp_ci_preflight` MCP tool.
+ *
+ * Wraps `runCiPreflight` (the single owner of the pre-push gate — see
+ * `src/cli/commands/ci-preflight.ts`) so agents can run the exact fail-fast,
+ * branch-scoped sequence CI mirrors — `format → guardrails → typecheck →
+ * lint → test` — without shelling out to `wp ci-preflight` via Bash.
+ *
+ * `runCiPreflight`'s default `runCheck` re-invokes `wp <subcommand>` via
+ * `spawnSync(..., {stdio: "inherit"})`. That is correct for a real terminal
+ * but unsafe here: `wp mcp` speaks stdio-transport JSON-RPC over the process's
+ * real stdout, and an inherited child write would corrupt that stream. This
+ * tool substitutes a `runCheck` that spawns each stage asynchronously via the
+ * shared `runCommand` helper (captured stdout/stderr, a bounded per-stage
+ * timeout, and `extra.signal` cancellation) using the same `wp` launcher
+ * resolution (`resolveWpLauncher`) the CLI uses, so behavior stays identical
+ * — only the transport of the output changes. `runCiPreflight`'s own
+ * `stdout`/`stderr` deps are swallowed for the same reason (they default to
+ * `process.stdout`/`process.stderr`); the equivalent progress detail is
+ * reconstructed from the per-stage results this tool collects itself.
+ *
+ * `runCiPreflight` returns only an exit code — there is no structured
+ * per-stage payload to "pass through." The `{passed, summary, details:
+ * {stages, stoppedAt}}` shape below mirrors `wp_qa`'s aggregate-gate
+ * convention (structured pass/fail + per-stage breakdown) since ci-preflight
+ * is the same shape of thing: a staged composite gate, just sequential and
+ * fail-fast instead of `wp_qa`'s parallel `Promise.all`.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { resolveWpLauncher, runCiPreflight, } from "#cli/commands/ci-preflight.js";
+import { formatMcpToolOutput } from "./_shared/full-output.js";
+import { resolveProjectRoot } from "./_shared/project-root.js";
+import { createSummaryOutputSchema, createSummaryResult } from "./_shared/result.js";
+import { isRunFailure, runCommand } from "./_shared/run-command.js";
+const inputSchema = z.object({
+    cwd: z.string().optional(),
+    full: z.boolean().optional().default(false),
+});
+// Generous but bounded: mirrors `wp_typecheck`'s cap (the heaviest single
+// sibling stage). In normal operation every stage here is branch-scoped
+// (`--affected --branch`) so real runs finish in seconds to low minutes; this
+// cap only exists to convert a hang into a diagnosable `timedOut: true`
+// instead of blocking the MCP transport indefinitely. Applied per-stage (not
+// as one combined budget) so an early hang doesn't eat the time later stages
+// would have needed.
+const CI_PREFLIGHT_STAGE_TIMEOUT_MS = 10 * 60 * 1_000;
+const stageResultSchema = z.object({
+    label: z.string(),
+    args: z.array(z.string()),
+    passed: z.boolean(),
+    exitCode: z.number().optional(),
+    timedOut: z.boolean().optional(),
+    aborted: z.boolean().optional(),
+    spawnError: z.string().optional(),
+    rawOutput: z.string().optional(),
+    truncated: z.boolean().optional(),
+    logPath: z.string().optional(),
+});
+const outputSchema = createSummaryOutputSchema({
+    details: z.object({
+        stages: z.array(stageResultSchema),
+        stoppedAt: z.string().optional(),
+        bootstrapError: z.string().optional(),
+    }),
+});
+const noopWritable = { write: () => true };
+/**
+ * Build the `runCheck` substitution: same stages, same launcher, same
+ * fail-fast contract as the CLI's `defaultRunCheck` — just async and
+ * output-capturing instead of `spawnSync(..., {stdio: "inherit"})`.
+ */
+function buildCapturingRunCheck(stages, options) {
+    return async (check, repoRoot) => {
+        const launcher = resolveWpLauncher(repoRoot);
+        const outcome = await runCommand(launcher.command, [...launcher.prefixArgs, ...check.args], {
+            timeoutMs: options.timeoutMs,
+            signal: options.signal,
+            cwd: repoRoot,
+        });
+        if (isRunFailure(outcome)) {
+            const spawnError = `${outcome.error.code ?? "unknown"} ${outcome.error.message}`;
+            stages.push({ label: check.label, args: [...check.args], passed: false, spawnError });
+            return 1;
+        }
+        const combined = [outcome.stdout, outcome.stderr].filter(Boolean).join("\n");
+        const compact = formatMcpToolOutput(combined, {
+            toolName: `wp_ci_preflight-${check.label}`,
+            full: options.full,
+            cwd: repoRoot,
+        });
+        stages.push({
+            label: check.label,
+            args: [...check.args],
+            passed: outcome.exitCode === 0,
+            exitCode: outcome.exitCode,
+            ...(outcome.timedOut ? { timedOut: true } : {}),
+            ...(outcome.aborted ? { aborted: true } : {}),
+            ...compact,
+        });
+        return outcome.exitCode;
+    };
+}
+function summarizeCiPreflight(stages, bootstrapError) {
+    if (bootstrapError)
+        return bootstrapError;
+    if (stages.length === 0)
+        return "ci-preflight did not run any checks";
+    const failed = stages.find((stage) => !stage.passed);
+    if (!failed)
+        return `ci-preflight passed (${stages.map((stage) => stage.label).join(", ")})`;
+    if (failed.spawnError)
+        return `ci-preflight could not start ${failed.label}: ${failed.spawnError}`;
+    if (failed.timedOut)
+        return `ci-preflight: ${failed.label} timed out`;
+    if (failed.aborted)
+        return `ci-preflight: ${failed.label} aborted`;
+    return `ci-preflight failed at ${failed.label} (exit ${failed.exitCode ?? "unknown"})`;
+}
+const tool = {
+    name: "wp_ci_preflight",
+    description: "Run the locally-runnable required CI checks, fail-fast, branch-scoped: `format → audit guardrails → typecheck → lint → test` (mirrors `.husky/pre-push`). Returns `{passed, summary, details: {stages, stoppedAt}}`. Use before push / PR open-update; prefer over `wp_qa` when you need pre-push parity (branch-scoped `--affected --branch`, sequential fail-fast) rather than `wp_qa`'s parallel whole-scope lint+typecheck+test; run `wp ci-preflight` directly only if this tool is unavailable.",
+    inputSchema,
+    outputSchema,
+    annotations: {
+        title: "CI preflight (pre-push gate)",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    handler: async (raw, extra) => {
+        const input = inputSchema.parse(raw ?? {});
+        const cwd = resolveProjectRoot(input.cwd ? { cwd: input.cwd } : {});
+        const stages = [];
+        let bootstrapError;
+        const runCheck = buildCapturingRunCheck(stages, {
+            timeoutMs: CI_PREFLIGHT_STAGE_TIMEOUT_MS,
+            signal: extra?.signal,
+            full: input.full,
+        });
+        const exitCode = await runCiPreflight({
+            cwd,
+            // Already resolved via the MCP-safe `resolveProjectRoot` walk above;
+            // re-resolving via git-topLevel here would risk landing on a different
+            // root than the one we're about to spawn stages in.
+            resolveRepoRoot: () => cwd,
+            hasNodeModules: (repoRoot) => {
+                const ok = existsSync(join(repoRoot, "node_modules"));
+                if (!ok) {
+                    bootstrapError = `wp_ci_preflight: ${repoRoot} is not bootstrapped — node_modules is missing. Run \`vp install\` in this worktree first, then retry.`;
+                }
+                return ok;
+            },
+            runCheck,
+            // Swallow progress writes — they default to process.stdout/stderr,
+            // which on a stdio-transport MCP server IS the JSON-RPC channel. The
+            // equivalent detail is already captured per-stage above.
+            stdout: noopWritable,
+            stderr: noopWritable,
+        });
+        const passed = exitCode === 0;
+        const stoppedAt = passed ? undefined : stages.at(-1)?.label;
+        const payload = {
+            passed,
+            summary: summarizeCiPreflight(stages, bootstrapError),
+            exitCode,
+            details: {
+                stages,
+                ...(stoppedAt ? { stoppedAt } : {}),
+                ...(bootstrapError ? { bootstrapError } : {}),
+            },
+        };
+        // `isError: true` is reserved for "we couldn't run the gate at all"
+        // (not bootstrapped, or a stage's spawn itself failed) — matching
+        // `wp_qa`'s convention that a check legitimately reporting `passed: false`
+        // is normal output the agent should act on, not a tool-execution error.
+        const executionFailed = bootstrapError !== undefined || stages.some((stage) => stage.spawnError !== undefined);
+        return createSummaryResult(payload, executionFailed ? { isError: true } : {});
+    },
+};
+export default tool;

package/dist/esm/mcp/tools/pr-upsert.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import { prDescriptionInputSchema, renderAndValidatePrDescription, } from "#pr-description/contract.js";
+import { readCurrentSessionId } from "#session-memory/current-session.js";
 import { createSummaryOutputSchema, createSummaryResult } from "./_shared/result.js";
 import { resolveProjectRoot } from "./_shared/project-root.js";
 import { redactText } from "./_shared/redact.js";
@@ -58,6 +59,42 @@ function resolveCwd(input) {
 function branchFor(input) {
     return input.branch ?? "HEAD";
 }
+/**
+ * Best-effort fill for an omitted `description.sessionId`, using the same
+ * lookup `wp_session_id` wraps. Never overrides an explicit value and never
+ * fights an explicit `Session-skip` (a caller who set a skip reason has
+ * already made a deliberate choice not to disclose a session id).
+ *
+ * This DOES change one previously-fail-closed case: an omitted `sessionId`
+ * with no `Session-skip` used to fail validation outright; it now silently
+ * passes when the current worktree has a resolvable id (which may be a prior,
+ * still-accurate-for-this-worktree id when no capture has happened yet in the
+ * live session) — this is the intended best-effort automation of the paste a
+ * caller would otherwise do by hand. When NO id resolves, the outcome is
+ * unchanged: the description is returned as-is and the pre-existing
+ * "missing sessionId" validation error still blocks the mutation. So the only
+ * new behavior is "fills a real gap"; it never manufactures a fake id and
+ * never converts a genuine miss into a silent success.
+ */
+function withAutoResolvedSessionId(input) {
+    const description = input.description;
+    if (description.sessionId?.trim())
+        return description;
+    if (description.sessionSkipReason?.trim())
+        return description;
+    try {
+        const sessionId = readCurrentSessionId(resolveCwd(input), process.env);
+        return sessionId ? { ...description, sessionId } : description;
+    }
+    catch (error) {
+        // Match this module's stderr-breadcrumb philosophy (see current-session.ts):
+        // a lookup throw degrades to "leave as-is" (fail-closed — validation then
+        // reports the missing sessionId), but is surfaced so a genuine store bug
+        // is not silently swallowed.
+        process.stderr.write(`[wp_pr_upsert] sessionId auto-resolve failed; leaving description unchanged: ${error instanceof Error ? error.message : String(error)}\n`);
+        return description;
+    }
+}
 function clipOutput(value, maxOutputBytes) {
     const redacted = redactText(value.trim());
     if (!redacted)
@@ -152,7 +189,8 @@ const tool = {
     },
     handler: async (raw, extra) => {
         const input = inputSchema.parse(raw ?? {});
-        const { body, validation } = renderAndValidatePrDescription(input.description);
+        const description = withAutoResolvedSessionId(input);
+        const { body, validation } = renderAndValidatePrDescription(description);
         const branch = branchFor(input);
         const bodySha256 = bodyHash(body);
         const commands = [];

package/dist/esm/mcp/tools/review-run.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `wp_review_run` MCP tool.
+ *
+ * Wraps `runReviewRunCommand` — the exact runtime `wp review run` and
+ * `wp review gate` use — so MCP callers get a first-class outside-voice
+ * review primitive instead of shelling into a provider CLI directly. Two
+ * ergonomic improvements over the raw `wp review run` CLI:
+ *
+ *   1. Accepts `prompt` directly instead of requiring a `--prompt-file` on
+ *      disk. The tool writes the prompt to a private temp file under the
+ *      resolved `artifactRoot` itself (cleaned up after each stage), since
+ *      `runReviewRunCommand` requires a real file to read over stdin.
+ *   2. By default runs a synthesized `probe` stage (cheap liveness check)
+ *      followed by the `review` stage in ONE call — removing the two-step
+ *      probe-then-review dance every consumer previously had to hand-roll in
+ *      bash (see the `codex` skill's pre-fix version). If the probe fails,
+ *      the review stage is never attempted. Pass `skipProbe: true` to go
+ *      straight to `review` once a provider is known-warm, or pass an
+ *      explicit `stage` for CLI-parity manual control.
+ *
+ * Provider fallback (e.g. Codex out of API credits) is a `provider`
+ * parameter change on this SAME tool call — never a raw shell-out to a
+ * different provider's CLI. `forbidden-commands.ts`'s
+ * `findReviewCliRedirect` enforces that on the Bash-tool side.
+ */
+import type { ToolDescriptor } from "#mcp/auto-discover";
+declare const tool: ToolDescriptor;
+export default tool;