@webpresso/agent-kit 3.3.1 → 3.3.2

package/dist/esm/ci/release-progress.js

@@ -0,0 +1,139 @@
+/**
+ * Classify a GitHub Actions Release run into operator-facing progress phases.
+ *
+ * After Version Packages merge, agents must not sit on silent `npm view` polls:
+ * merge, native matrix, and npm publish are separate states. This pure helper
+ * maps job list snapshots (from `gh run view --json jobs`) into those states.
+ */
+const NATIVE_JOB_PREFIX = "Session memory native";
+function isNativeJob(name) {
+    return name.startsWith(NATIVE_JOB_PREFIX);
+}
+function isFailure(conclusion) {
+    return conclusion === "failure" || conclusion === "cancelled" || conclusion === "timed_out";
+}
+function isSuccess(conclusion) {
+    return conclusion === "success" || conclusion === "skipped";
+}
+/**
+ * Classify release workflow jobs into a single progress phase for agent/ops reporting.
+ */
+export function classifyReleaseRunProgress(jobs) {
+    const nativeJobs = jobs.filter((job) => isNativeJob(job.name));
+    const detect = jobs.find((job) => job.name === "Detect publishable versions");
+    const release = jobs.find((job) => job.name === "Release");
+    const nativeDone = nativeJobs.filter((job) => job.status === "completed" && isSuccess(job.conclusion)).length;
+    const nativeFailed = nativeJobs.filter((job) => job.status === "completed" && isFailure(job.conclusion)).length;
+    const nativeInProgress = nativeJobs.filter((job) => job.status === "in_progress").length;
+    const native = {
+        done: nativeDone,
+        total: nativeJobs.length,
+        failed: nativeFailed,
+        inProgress: nativeInProgress,
+    };
+    const publishRunning = release?.status === "in_progress";
+    const publishDone = release?.status === "completed" && isSuccess(release.conclusion);
+    const publishFailed = release?.status === "completed" && isFailure(release.conclusion);
+    if (nativeFailed > 0 || publishFailed) {
+        return {
+            phase: "failed",
+            detail: nativeFailed > 0
+                ? `Native matrix failed (${nativeFailed} cell(s))`
+                : `Release/publish job failed (${release?.conclusion ?? "unknown"})`,
+            native,
+            publishRunning,
+            publishDone,
+            publishFailed,
+        };
+    }
+    if (publishDone) {
+        return {
+            phase: "done",
+            detail: "Release job completed successfully (check npm for version)",
+            native,
+            publishRunning,
+            publishDone,
+            publishFailed,
+        };
+    }
+    if (publishRunning || (native.total > 0 && nativeDone === native.total && release)) {
+        return {
+            phase: "publish",
+            detail: publishRunning
+                ? "Native matrix complete; Release/publish job in progress"
+                : "Native matrix complete; waiting for Release job",
+            native,
+            publishRunning,
+            publishDone,
+            publishFailed,
+        };
+    }
+    if (native.total > 0 && (nativeInProgress > 0 || nativeDone < native.total)) {
+        return {
+            phase: "native-matrix",
+            detail: `Building session-memory natives ${nativeDone}/${native.total} complete` +
+                (nativeInProgress > 0 ? ` (${nativeInProgress} in progress)` : ""),
+            native,
+            publishRunning,
+            publishDone,
+            publishFailed,
+        };
+    }
+    if (detect && detect.status !== "completed") {
+        return {
+            phase: "detect",
+            detail: "Detecting whether this run will publish",
+            native,
+            publishRunning,
+            publishDone,
+            publishFailed,
+        };
+    }
+    return {
+        phase: "detect",
+        detail: "Release run starting",
+        native,
+        publishRunning,
+        publishDone,
+        publishFailed,
+    };
+}
+/** Format one line for agent/ops logs (merge vs matrix vs publish). */
+export function formatReleaseProgressLine(progress) {
+    return `release-progress phase=${progress.phase} native=${progress.native.done}/${progress.native.total} ${progress.detail}`;
+}
+/**
+ * Parse `gh run view <id> --json jobs` (or full run object with `jobs`) into snapshots.
+ * Production CLI and tests share this path so classification is never reimplemented.
+ */
+export function jobsFromGhRunViewJson(payload) {
+    if (payload == null || typeof payload !== "object") {
+        throw new Error("gh run view JSON must be an object with a jobs array");
+    }
+    const record = payload;
+    const jobsRaw = Array.isArray(payload)
+        ? payload
+        : Array.isArray(record.jobs)
+            ? record.jobs
+            : null;
+    if (!jobsRaw) {
+        throw new Error("gh run view JSON must include a jobs array");
+    }
+    return jobsRaw.map((entry, index) => {
+        if (entry == null || typeof entry !== "object") {
+            throw new Error(`jobs[${index}] must be an object`);
+        }
+        const job = entry;
+        const name = typeof job.name === "string" ? job.name : "";
+        const status = typeof job.status === "string" ? job.status : "";
+        if (!name || !status) {
+            throw new Error(`jobs[${index}] requires string name and status`);
+        }
+        const conclusion = job.conclusion === null || job.conclusion === undefined
+            ? null
+            : typeof job.conclusion === "string"
+                ? job.conclusion
+                : null;
+        return { name, status, conclusion };
+    });
+}

package/dist/esm/cli/cli.d.ts

@@ -5,7 +5,7 @@
  * Lazy-loads subcommand modules based on the first argv to keep startup
  * cheap. Modeled on apps/cli-wp/src/cli.ts.
  */
-declare const SUPPORTED_COMMANDS: readonly ["blueprint", "browser", "dash", "dash-helper-start", "dash-helper-complete", "claude", "codex", "grok", "opencode", "yolo", "config", "secrets", "roadmap", "status", "review", "sync", "audit", "qa", "ultragoal", "compile", "rule", "skill", "skills", "docs", "setup", "init", "dev", "deploy", "preview", "cleanup", "migrate", "doctor", "err", "test", "e2e", "ci", "ci-preflight", "public:readiness", "typecheck", "lint", "format", "rust-check", "logs", "session-id", "session-info", "session", "tech-debt", "pr", "fleet", "worktree", "mcp", "hook", "hooks", "self-install-guard", "optional-tool-refresh", "gain", "bench", "install", "add", "remove", "update", "exec", "run"];
+declare const SUPPORTED_COMMANDS: readonly ["blueprint", "browser", "dash", "dash-helper-start", "dash-helper-complete", "claude", "codex", "grok", "opencode", "yolo", "config", "secrets", "roadmap", "status", "review", "sync", "audit", "qa", "ultragoal", "compile", "rule", "skill", "skills", "docs", "setup", "init", "dev", "deploy", "preview", "cleanup", "migrate", "doctor", "err", "test", "e2e", "ci", "ci-preflight", "release-progress", "public:readiness", "typecheck", "lint", "format", "rust-check", "logs", "session-id", "session-info", "session", "tech-debt", "pr", "fleet", "worktree", "mcp", "hook", "hooks", "self-install-guard", "optional-tool-refresh", "gain", "bench", "install", "add", "remove", "update", "exec", "run"];
 export type SupportedCommand = (typeof SUPPORTED_COMMANDS)[number];
 type RootHelpEntry = {
     readonly command: string;

package/dist/esm/cli/cli.js

@@ -55,6 +55,7 @@ const SUPPORTED_COMMANDS = [
     "e2e",
     "ci",
     "ci-preflight",
+    "release-progress",
     "public:readiness",
     "typecheck",
     "lint",
@@ -118,6 +119,10 @@ const ROOT_HELP_CORE_ENTRIES = [
         command: "ci-preflight",
         description: "Run the locally-runnable required CI checks fail-fast (the pre-push gate)",
     },
+    {
+        command: "release-progress",
+        description: "Report Release workflow phase (detect / native-matrix / publish) instead of silent npm view waits",
+    },
     {
         command: "public:readiness",
         description: "Run the public package readiness gate through the portable wp surface",
@@ -375,6 +380,10 @@ const COMMAND_REGISTRARS = {
         const { registerCiPreflightCommand } = await import("./commands/ci-preflight.js");
         registerCiPreflightCommand(cli);
     },
+    "release-progress": async (cli) => {
+        const { registerReleaseProgressCommand } = await import("./commands/release-progress.js");
+        registerReleaseProgressCommand(cli);
+    },
     "public:readiness": async (cli) => {
         const { registerPublicReadinessCommand } = await import("./commands/public-readiness.js");
         registerPublicReadinessCommand(cli);

package/dist/esm/cli/commands/blueprint/mutations.js

@@ -17,7 +17,7 @@ import { randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { parseBlueprint } from "#core/parser";
-import { escapeRegex } from "#utils/string";
+import { buildTaskHeaderRegexForId } from "#markdown/task-heading";
 import { openDb } from "#db/connection.js";
 import { resolveBlueprintProjectionDbPath, withMarkdownWriteLock } from "#db/paths.js";
 import { getBlueprintDocumentPaths } from "#utils/document-paths.js";
@@ -209,8 +209,7 @@ function upsertCompletedAt(content, isoDate) {
  * Returns { lineIndex, currentStatus } or null if not found.
  */
 function findTaskStatusLine(lines, taskId) {
-    const escapedId = escapeRegex(taskId);
-    const taskPattern = new RegExp(`^####\\s+(?:\\[[^\\]]+\\]\\s+)?Task\\s+${escapedId}[:\\s]`);
+    const taskPattern = buildTaskHeaderRegexForId(taskId);
     let inBlock = false;
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i] ?? "";

package/dist/esm/cli/commands/release-progress.d.ts

@@ -0,0 +1,53 @@
+/**
+ * `wp release-progress` — report Release workflow phase (detect / native-matrix / publish).
+ *
+ * Agents must not poll only `npm view` after Version Packages merge. This command
+ * loads the live GitHub Actions job list and classifies progress via
+ * {@link classifyReleaseRunProgress}.
+ */
+import type { CAC } from "cac";
+import { type ReleaseJobSnapshot, type ReleaseProgress } from "#ci/release-progress.js";
+export declare const RELEASE_PROGRESS_COMMAND_HELP: string;
+export interface GhRunJobsFetcher {
+    (options: {
+        readonly runId: string;
+        readonly repo: string;
+    }): ReleaseJobSnapshot[];
+}
+export interface LatestReleaseRunResolver {
+    (options: {
+        readonly repo: string;
+    }): string;
+}
+/** Production fetcher: `gh run view --json jobs`. */
+export declare function fetchReleaseJobsViaGh(options: {
+    readonly runId: string;
+    readonly repo: string;
+}): ReleaseJobSnapshot[];
+/** Production resolver: latest Release workflow run for the repo. */
+export declare function resolveLatestReleaseRunIdViaGh(options: {
+    readonly repo: string;
+}): string;
+export interface RunReleaseProgressOptions {
+    readonly runId?: string | number;
+    readonly repo?: string;
+    readonly json?: boolean;
+    readonly fetchJobs?: GhRunJobsFetcher;
+    readonly resolveLatestRunId?: LatestReleaseRunResolver;
+    readonly stdout?: {
+        write(chunk: string): void;
+    };
+    readonly stderr?: {
+        write(chunk: string): void;
+    };
+}
+/**
+ * Core command body — injectable for tests; production uses gh CLI defaults.
+ */
+export declare function runReleaseProgress(options?: RunReleaseProgressOptions): {
+    readonly exitCode: number;
+    readonly progress: ReleaseProgress;
+    readonly runId: string;
+    readonly line: string;
+};
+export declare function registerReleaseProgressCommand(cli: CAC): void;

package/dist/esm/cli/commands/release-progress.js

@@ -0,0 +1,155 @@
+/**
+ * `wp release-progress` — report Release workflow phase (detect / native-matrix / publish).
+ *
+ * Agents must not poll only `npm view` after Version Packages merge. This command
+ * loads the live GitHub Actions job list and classifies progress via
+ * {@link classifyReleaseRunProgress}.
+ */
+import { spawnSync } from "node:child_process";
+import { classifyReleaseRunProgress, formatReleaseProgressLine, jobsFromGhRunViewJson, } from "#ci/release-progress.js";
+export const RELEASE_PROGRESS_COMMAND_HELP = [
+    "Report agent-kit Release workflow progress by phase.",
+    "",
+    "Phases: detect | native-matrix | publish | done | failed.",
+    "Use after merging Version Packages so long session-memory native builds are",
+    "not mistaken for a hung merge or silent npm wait.",
+    "",
+    "Examples:",
+    "  wp release-progress",
+    "  wp release-progress --run-id 30152651072",
+    "  wp release-progress --repo webpresso/agent-kit --json",
+].join("\n");
+const DEFAULT_REPO = "webpresso/agent-kit";
+const RELEASE_WORKFLOW = "release.yml";
+function runGhJson(args) {
+    const result = spawnSync("gh", [...args], {
+        encoding: "utf8",
+        timeout: 60_000,
+        maxBuffer: 8 * 1024 * 1024,
+    });
+    if (result.error)
+        throw result.error;
+    if ((result.status ?? 1) !== 0) {
+        const stderr = (result.stderr ?? "").trim();
+        throw new Error(stderr || `gh ${args.join(" ")} failed (exit ${result.status ?? 1})`);
+    }
+    const stdout = (result.stdout ?? "").trim();
+    if (!stdout)
+        throw new Error(`gh ${args.join(" ")} returned empty stdout`);
+    return JSON.parse(stdout);
+}
+/** Production fetcher: `gh run view --json jobs`. */
+export function fetchReleaseJobsViaGh(options) {
+    const payload = runGhJson([
+        "run",
+        "view",
+        options.runId,
+        "--repo",
+        options.repo,
+        "--json",
+        "jobs,status,conclusion,url,displayTitle",
+    ]);
+    return jobsFromGhRunViewJson(payload);
+}
+/** Production resolver: latest Release workflow run for the repo. */
+export function resolveLatestReleaseRunIdViaGh(options) {
+    const payload = runGhJson([
+        "run",
+        "list",
+        "--repo",
+        options.repo,
+        "--workflow",
+        RELEASE_WORKFLOW,
+        "--limit",
+        "1",
+        "--json",
+        "databaseId,status,displayTitle",
+    ]);
+    if (!Array.isArray(payload) || payload.length === 0) {
+        throw new Error(`No Release workflow runs found for ${options.repo}`);
+    }
+    const first = payload[0];
+    const id = first.databaseId;
+    if (typeof id === "number" && Number.isFinite(id))
+        return String(id);
+    if (typeof id === "string" && id.trim())
+        return id.trim();
+    throw new Error("Latest Release run is missing databaseId");
+}
+function coerceNonEmptyString(value) {
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : undefined;
+    }
+    if (typeof value === "number" && Number.isFinite(value))
+        return String(value);
+    return undefined;
+}
+/**
+ * Core command body — injectable for tests; production uses gh CLI defaults.
+ */
+export function runReleaseProgress(options = {}) {
+    const repo = coerceNonEmptyString(options.repo) || DEFAULT_REPO;
+    const resolveLatest = options.resolveLatestRunId ?? resolveLatestReleaseRunIdViaGh;
+    const fetchJobs = options.fetchJobs ?? fetchReleaseJobsViaGh;
+    const stdout = options.stdout ?? process.stdout;
+    const stderr = options.stderr ?? process.stderr;
+    // cac may parse purely numeric --run-id values as numbers; coerce before trim.
+    const runId = coerceNonEmptyString(options.runId) || resolveLatest({ repo });
+    const jobs = fetchJobs({ runId, repo });
+    const progress = classifyReleaseRunProgress(jobs);
+    const line = formatReleaseProgressLine(progress);
+    if (options.json) {
+        stdout.write(`${JSON.stringify({
+            runId,
+            repo,
+            phase: progress.phase,
+            detail: progress.detail,
+            native: progress.native,
+            publishRunning: progress.publishRunning,
+            publishDone: progress.publishDone,
+            publishFailed: progress.publishFailed,
+            line,
+        }, null, 2)}\n`);
+    }
+    else {
+        stdout.write(`${line}\n`);
+        stdout.write(`  run-id: ${runId}\n`);
+        stdout.write(`  repo: ${repo}\n`);
+        if (progress.phase === "done") {
+            stdout.write("  next: npm view @webpresso/agent-kit version  # only after phase=done\n");
+        }
+        else if (progress.phase === "native-matrix" || progress.phase === "publish") {
+            stdout.write("  note: do not treat npm view alone as progress; matrix/publish still running\n");
+        }
+    }
+    if (progress.phase === "failed") {
+        stderr.write(`wp release-progress: ${progress.detail}\n`);
+        return { exitCode: 1, progress, runId, line };
+    }
+    return { exitCode: 0, progress, runId, line };
+}
+export function registerReleaseProgressCommand(cli) {
+    cli
+        .command("release-progress", RELEASE_PROGRESS_COMMAND_HELP)
+        .option("--run-id <id>", "GitHub Actions run id (default: latest Release workflow run)")
+        .option("--repo <owner/name>", `GitHub repo (default: ${DEFAULT_REPO})`)
+        .option("--json", "Emit structured JSON")
+        .action((flags) => {
+        try {
+            const result = runReleaseProgress({
+                runId: flags.runId,
+                repo: flags.repo,
+                json: Boolean(flags.json),
+            });
+            process.exitCode = result.exitCode;
+            return result.exitCode;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`wp release-progress: ${message}\n`);
+            process.exitCode = 1;
+            return 1;
+        }
+    });
+}

package/dist/esm/cli/commands/review.js

@@ -167,6 +167,11 @@ function resolveReviewModel(provider, model) {
     const fableVersion = /^fable[-\s]?(\d+)$/iu.exec(model)?.[1];
     return fableVersion ? `claude-fable-${fableVersion}` : model;
 }
+// How many DISTINCT rejected semantic subjects are allowed before the anti-runaway
+// budget cap trips. Identical resubmissions never reach here (they reuse the prior
+// rejection for free), so this only bounds genuinely different converging attempts.
+// A human may extend past it in place with WP_REVIEW_SCOPE_CONTINUE=1 (recorded).
+const REVIEW_SUBJECT_REJECTION_LIMIT = 4;
 function classificationForFailureCode(code) {
     if (!code)
         return undefined;
@@ -182,6 +187,7 @@ function isLocalReviewFailureCode(code) {
         code === "expected-marker-missing" ||
         code === "missing-terminal-result" ||
         code === "semantic-progress-budget-exceeded" ||
+        code === "sandbox-unavailable" ||
         code.startsWith("provider-stdin-"));
 }
 function reviewRunTerminalClassification(summary) {
@@ -1157,16 +1163,24 @@ const reviewGateAttemptSchema = z.object({
 });
 const reviewGateVerificationCommandSchema = z.object({
     command: z.string(),
-    outcome: z.enum(["passed", "failed", "timed-out"]),
+    // "deferred" is produced for approval-dependent lifecycle gates
+    // (delivery-verifier.ts) and persisted into gate state, so it MUST round-trip
+    // through the reload schema or resumption/reuse of a lifecycle-gated review
+    // throws "Review gate state is malformed".
+    outcome: z.enum(["passed", "failed", "timed-out", "deferred"]),
     durationMs: z.number(),
     exitCode: z.number().nullable(),
     signal: z.string().optional(),
 });
+const _assertVerificationCommandReloadable = true;
+void _assertVerificationCommandReloadable;
 const reviewGateVerificationSchema = z.object({
     status: z.enum(["passed", "failed"]),
     commands: z.array(reviewGateVerificationCommandSchema),
     failureCode: z.string().optional(),
     logPath: z.string().optional(),
+    sandbox: z.enum(["srt", "disabled-by-operator", "unavailable"]).optional(),
+    sandboxReason: z.string().optional(),
 });
 const reviewGateStateSchema = z
     .object({
@@ -1259,15 +1273,42 @@ function buildGatePrompt(input) {
         ...(input.priorRejections && input.priorRejections.length > 0
             ? [
                 "",
-                "Prior formal rejection evidence (this is the final semantic remediation review):",
+                "Prior formal rejection evidence for this converging change:",
                 ...input.priorRejections.map((entry) => `- ${entry.subjectDigest}: ${entry.artifactPath}`),
-                "Inspect every prior finding and its disposition. Return all remaining blockers together; do not defer discoverable blockers to another review round.",
+                "For each prior finding, state its disposition (fixed / still-open / not-a-blocker) with evidence.",
                 "",
             ]
             : []),
-        "Inspect the target SHA and blueprint directly. Focus on correctness, security, concurrency, recovery, tests, and scope compliance.",
+        "Inspect the target SHA and blueprint directly.",
+        "",
+        "This is a CONVERGENCE gate. Your goal is to surface EVERY blocker in ONE pass so the author can fix them all at once; a blocker you leave for a later round costs a full review cycle. Be exhaustive, not incremental.",
+        "",
+        'Walk ALL of these dimensions in order. For EACH, either report specific findings or write "no blocker". Do not skip a dimension and do not stop early:',
+        "1. Correctness & logic — wrong results, edge cases, off-by-one, error handling.",
+        "2. Security & trust boundaries — trace EVERY place external or target-controlled input, config, or code influences execution, file writes, network, or process spawning, and confirm each is confined. Untrusted code or config that runs with insufficient isolation is a blocker.",
+        "3. Concurrency & races — shared state, ordering, cleanup-vs-use races.",
+        "4. Resource, recovery & process lifecycle — timeouts, orphaned/daemonized processes, unbounded growth, cleanup ordering, and every failure/cancellation path.",
+        "5. Test coverage adequacy — is every material claim backed by a test that would FAIL if the claim were false? Name the specific missing test; a claim asserted but not exercised by a test is a blocker.",
+        "6. Scope & spec compliance — does the delivered code match the blueprint's stated decisions and claims?",
+        "7. Documentation & lifecycle accuracy — do the blueprint's stated status, evidence, and verified-head match reality?",
+        "",
+        "For EVERY finding, include all three of:",
+        "- Trigger: a concrete scenario or input that produces the failure. If you cannot name one, do not flag it as a blocker.",
+        "- Severity: BLOCKER (must fix to ship) or NIT (non-blocking), plus a one-line confidence note.",
+        "- Fix: the concrete change to make; when there is a real tradeoff, give 2 options with their costs so the author can choose and fix in one pass.",
+        "",
+        "Only flag as BLOCKER what a concrete failing scenario justifies. When impact is high (data loss, security, corruption) but your confidence is limited, still report it as a BLOCKER and state explicitly what remains uncertain — do not omit it.",
+        "",
+        "Before the verdict, do a COMPLETENESS pass: list what you did NOT inspect or could not verify that might still hide a blocker. If that list contains a plausible high-impact gap, convert it into a finding rather than leaving it for a later round.",
+        ...(input.purpose === "delivery"
+            ? [
+                "",
+                "Blueprint lifecycle scope: this delivery review judges the CODE at the target SHA. Blueprint lifecycle advancement — moving tasks to `done`, checking acceptance criteria, and transitioning the blueprint out of `draft` into `completed/` — happens AFTER this approval, at landing. A blueprint that is still `status: draft` with `todo` tasks and unchecked acceptance is EXPECTED here and is NOT a blocker: the lifecycle audit requires a draft to have zero checked acceptance, and a blueprint cannot leave `draft` without the very approval this review would grant. Do verify that the blueprint's stated verified-head matches the target and that its documented decisions match the delivered code; do NOT block on draft/todo lifecycle state.",
+            ]
+            : []),
+        "",
         "End with exactly one standalone verdict line: APPROVED, APPROVE-WITH-NITS, or BLOCKED.",
-        "APPROVE-WITH-NITS satisfies the gate only when every finding is non-blocking.",
+        "APPROVE-WITH-NITS satisfies the gate only when every finding is a NIT and carries a proposed fix.",
         "If any unresolved correctness, security, recovery, test, or scope blocker remains, end with BLOCKED.",
     ].join("\n");
 }
@@ -1886,7 +1927,7 @@ function rejectedReviewSubjects(input) {
  */
 export function reviewGateNonConvergenceHint(slug, context = {}) {
     if (context.status === "scope-exhausted") {
-        return `hint: formal review budget is exhausted for ${slug}. Stop automated review retries and obtain an explicit human scope decision before creating a successor blueprint.`;
+        return `hint: formal review budget is exhausted for ${slug} after ${REVIEW_SUBJECT_REJECTION_LIMIT} rejected semantic subjects. Stop automated review retries. If you have addressed the prior findings and this is a good-faith converging attempt, a human may record an explicit scope decision and continue reviewing this blueprint in place by setting WP_REVIEW_SCOPE_CONTINUE=1 — no successor blueprint is needed.`;
     }
     if (context.failureCode === "provider-event-too-large" && context.gateId) {
         return `hint: provider transport emitted a single provider JSON event above the bounded capture limit for ${slug}; no review verdict was produced. Retry the unchanged gate with "wp review gate ${slug} --resume ${context.gateId} --provider <provider>" and select a different provider when possible. Retrying the same provider/model is allowed for recovery but is likely to recur for deterministic oversized output. An independent "wp review run" can be recorded only as a human-adjudicated verdict through wp_blueprint_review_log; that tool cannot create a Claude/Codex/Grok/OpenCode-Go approval. The event-size and timeout bounds were not increased. See catalog/agent/rules/pre-implementation.md.`;
@@ -2114,7 +2155,7 @@ export async function runReviewGate(projectRoot, slug, input, dependencies = { i
             // (verifyDeliveryPromotionGates is a no-op for every other purpose).
             const deliveryCheckout = purpose === "delivery" ? ensureSharedCheckout() : undefined;
             if (deliveryCheckout) {
-                verification = verifyDeliveryPromotionGates({
+                verification = await verifyDeliveryPromotionGates({
                     purpose,
                     blueprintContent,
                     projectRoot,
@@ -2122,6 +2163,9 @@ export async function runReviewGate(projectRoot, slug, input, dependencies = { i
                     checkout: deliveryCheckout,
                     ...(dependencies.signal ? { signal: dependencies.signal } : {}),
                 });
+                if (verification?.sandbox === "disabled-by-operator") {
+                    process.stderr.write("WARNING: WP_REVIEW_UNSANDBOXED_GATES=1 — delivery gates ran WITHOUT OS isolation (recorded as disabled-by-operator; approval reuse is disabled so this run publishes committed evidence).\n");
+                }
                 const summary = verificationPromptSummary(verification);
                 if (summary) {
                     prompt = renderPrompt(summary);
@@ -2135,7 +2179,11 @@ export async function runReviewGate(projectRoot, slug, input, dependencies = { i
                 }
             }
             let approvalGate = currentApprovalGate();
-            if (approvalGate.satisfied) {
+            // Under an unsandboxed operator override, never take the approval-reuse
+            // fast path: force a fresh provider review so the run publishes a
+            // committed artifact carrying `Sandbox: disabled-by-operator`. (The
+            // override is also recorded in the persisted gate state on every path.)
+            if (approvalGate.satisfied && verification?.sandbox !== "disabled-by-operator") {
                 const result = makeResult(approvalGate, reusedApprovals.length > 0 ? "approved" : "recorded-untracked");
                 assertReviewRefUnchanged(projectRoot, input.target ?? "HEAD", targetSha);
                 persistGateState(projectRoot, result);
@@ -2157,15 +2205,30 @@ export async function runReviewGate(projectRoot, slug, input, dependencies = { i
                 cleanupSharedCheckout();
                 return result;
             }
-            if (rejectedSubjects.length >= 2) {
-                const result = makeResult(approvalGate, "scope-exhausted", "Formal review budget exhausted after two rejected semantic subjects. No review provider was invoked; stop and obtain an explicit human scope decision before creating a successor blueprint.");
+            // Anti-runaway budget cap. Identical resubmissions are already
+            // short-circuited for free by the currentSubjectRejection check above, so
+            // this only ever fires on GENUINELY DIFFERENT (converging) subjects —
+            // i.e. changes that addressed the prior findings. That is legitimate
+            // iteration, not thrash, so a human MAY record an explicit in-place scope
+            // decision to continue reviewing THIS blueprint instead of being forced to
+            // fork a successor (which would only launder the counter). Automated runs
+            // do not set the flag and still hard-stop.
+            if (rejectedSubjects.length >= REVIEW_SUBJECT_REJECTION_LIMIT &&
+                process.env["WP_REVIEW_SCOPE_CONTINUE"] !== "1") {
+                const result = makeResult(approvalGate, "scope-exhausted", `Formal review budget exhausted after ${REVIEW_SUBJECT_REJECTION_LIMIT} rejected semantic subjects; no reviewer was invoked. If you have addressed the prior findings and this is a good-faith converging attempt, set WP_REVIEW_SCOPE_CONTINUE=1 to record an explicit human scope decision and continue reviewing this blueprint — no successor blueprint is needed. Automated runs must stop and escalate.`);
                 assertReviewRefUnchanged(projectRoot, input.target ?? "HEAD", targetSha);
                 persistGateState(projectRoot, result);
                 cleanupSharedCheckout();
                 return result;
             }
+            if (rejectedSubjects.length >= REVIEW_SUBJECT_REJECTION_LIMIT) {
+                // Recorded for audit: the operator explicitly extended the budget past
+                // the cap for this converging attempt. The reviewer's verdict is still
+                // required — the approval gate itself is unchanged.
+                gateIssues.push(`human scope-continue: WP_REVIEW_SCOPE_CONTINUE=1 extended the review budget past ${rejectedSubjects.length} rejected subjects`);
+            }
             if (rejectedSubjects.length > 0) {
-                prompt = renderPrompt(verification ? verificationPromptSummary(verification) : undefined, rejectedSubjects.slice(0, 2));
+                prompt = renderPrompt(verification ? verificationPromptSummary(verification) : undefined, rejectedSubjects.slice(0, REVIEW_SUBJECT_REJECTION_LIMIT));
             }
             const artifactDirectory = path.join(path.dirname(location.path), "review-artifacts");
             if (existsSync(artifactDirectory) && lstatSync(artifactDirectory).isSymbolicLink()) {

package/dist/esm/cli/utils.d.ts

@@ -15,7 +15,14 @@ interface GetProjectRootOptions {
 }
 /**
  * Walks upward from startDir looking for any marker in
- * `PROJECT_ROOT_MARKERS` (priority order). Throws if nothing is found.
+ * `PROJECT_ROOT_MARKERS` (priority order). The walk is clamped at the
+ * enclosing git repository boundary: a directory containing `.git` (dir for
+ * a normal checkout, file for a linked worktree or submodule) is itself a
+ * project root when no marker matched at or below it. Without the clamp, a
+ * markerless git repo silently resolves to whatever ancestor happens to
+ * carry a `package.json` (e.g. editor-tooling junk in `$HOME`) and commands
+ * like `wp blueprint new` write outside the repo. Throws if neither a
+ * marker nor a git boundary is found.
  */
 export declare function findProjectRoot(startDir: string): string;
 export declare function getProjectRoot(options?: GetProjectRootOptions): string;

package/dist/esm/cli/utils.js

@@ -35,7 +35,14 @@ function findMarker(rootDir) {
 }
 /**
  * Walks upward from startDir looking for any marker in
- * `PROJECT_ROOT_MARKERS` (priority order). Throws if nothing is found.
+ * `PROJECT_ROOT_MARKERS` (priority order). The walk is clamped at the
+ * enclosing git repository boundary: a directory containing `.git` (dir for
+ * a normal checkout, file for a linked worktree or submodule) is itself a
+ * project root when no marker matched at or below it. Without the clamp, a
+ * markerless git repo silently resolves to whatever ancestor happens to
+ * carry a `package.json` (e.g. editor-tooling junk in `$HOME`) and commands
+ * like `wp blueprint new` write outside the repo. Throws if neither a
+ * marker nor a git boundary is found.
  */
 export function findProjectRoot(startDir) {
     let current = path.resolve(startDir);
@@ -43,9 +50,12 @@ export function findProjectRoot(startDir) {
         if (findMarker(current)) {
             return current;
         }
+        if (existsSync(path.join(current, ".git"))) {
+            return current;
+        }
         const parent = path.dirname(current);
         if (parent === current) {
-            throw new Error(`Could not find project root (looked for ${PROJECT_ROOT_MARKERS.join(", ")}). Started from: ${startDir}`);
+            throw new Error(`Could not find project root (looked for ${PROJECT_ROOT_MARKERS.join(", ")} or a .git boundary). Started from: ${startDir}`);
         }
         current = parent;
     }

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);