@webpresso/agent-kit 3.1.30 → 3.3.0

package/dist/esm/mcp/tools/session-info.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { readCurrentSessionInfo } from "#session-memory/current-session.js";
+import { createSummaryOutputSchema, createSummaryResult } from "./_shared/result.js";
+const inputSchema = z
+    .object({
+    cwd: z.string().optional(),
+})
+    .strict();
+const outputSchema = createSummaryOutputSchema({
+    details: z.object({
+        sessionId: z.string(),
+        executionModels: z.array(z.string()),
+    }),
+}).extend({
+    sessionId: z.string(),
+    executionModels: z.array(z.string()),
+});
+function effectiveCwd(cwd) {
+    return cwd ?? process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+}
+const tool = {
+    name: "wp_session_info",
+    description: "Report the current agent session id and every distinct observed execution model for the PR AI/model disclosure contract. Structured equivalent of `wp session-info` (prefers a live host session id, then falls back to stored session-memory capture for this worktree and its sibling worktrees). Feed `sessionId` straight into `wp_pr_upsert`'s `description.sessionId` — that tool also auto-resolves it via the same underlying lookup when omitted, so calling this tool first is optional. An empty `sessionId` means no live or captured session was found; use `Session-skip: SKIP <reason>` in the disclosure instead. Prefer `wp_session_id` when you only need the id, not the model history — it skips the cross-worktree scan this tool does.",
+    inputSchema,
+    outputSchema,
+    annotations: {
+        title: "Session info",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    handler: async (raw) => {
+        const input = inputSchema.parse(raw ?? {});
+        const info = readCurrentSessionInfo(effectiveCwd(input.cwd), process.env);
+        const executionModels = [...info.models];
+        const payload = {
+            passed: true,
+            summary: info.sessionId
+                ? `session id ${info.sessionId} with ${executionModels.length} observed model${executionModels.length === 1 ? "" : "s"}`
+                : "no live or captured session id found; use Session-skip in the PR disclosure",
+            sessionId: info.sessionId,
+            executionModels,
+            details: { sessionId: info.sessionId, executionModels },
+        };
+        return createSummaryResult(payload);
+    },
+};
+export default tool;

package/dist/esm/output-transforms/audit.d.ts

@@ -0,0 +1,23 @@
+import type { TransformContext, TransformResult } from "./index.js";
+/**
+ * `wp audit <kind>` writes the full `formatRepoAuditReport` output (title +
+ * one bullet per violation) into its CLI log. Every audit kind normalizes to
+ * the shared `"audit"` tool name (see `normalizeToolName`), so without a
+ * dedicated transform that output fell through to `genericTransform`, whose
+ * error/fail keyword heuristic drops any violation bullet that doesn't
+ * literally contain "error"/"fail"/"✗"/"✘" — silently discarding most
+ * violation detail even when the full report is a handful of short lines.
+ *
+ * This transform recognizes the bullet-list shape directly so violation text
+ * survives regardless of wording, then defers to the same size-based
+ * clip/elision policy every other transform uses (`createTransformResult` /
+ * `clipRawOutput`'s existing byte threshold) to decide whether the (now
+ * correctly extracted) violation list is short enough to print inline or
+ * long enough to still defer to `wp logs audit`.
+ *
+ * Audit output that isn't shaped like a violation-bullet report (for example
+ * raw subprocess output from `mutation`/`bundle-budget`) has no matching
+ * bullet lines, so this falls back to the previous generic keyword-based
+ * behavior unchanged.
+ */
+export declare function auditTransform(rawOutput: string | undefined, context: TransformContext): TransformResult;

package/dist/esm/output-transforms/audit.js

@@ -0,0 +1,47 @@
+import { createTransformResult } from "./metadata.js";
+import { genericTransform } from "./generic.js";
+// `formatRepoAuditReport` (src/audit/repo-guardrails.ts) always renders one
+// violation per line as `- <location><metadata><message><fixability>`. That
+// bullet marker is the one structural signal every repo-audit report shares,
+// regardless of which audit kind produced it or whether the violation text
+// happens to contain the words "error"/"fail" that the generic fallback
+// keys off of.
+const VIOLATION_LINE_RE = /^-\s+(.+)$/u;
+/**
+ * `wp audit <kind>` writes the full `formatRepoAuditReport` output (title +
+ * one bullet per violation) into its CLI log. Every audit kind normalizes to
+ * the shared `"audit"` tool name (see `normalizeToolName`), so without a
+ * dedicated transform that output fell through to `genericTransform`, whose
+ * error/fail keyword heuristic drops any violation bullet that doesn't
+ * literally contain "error"/"fail"/"✗"/"✘" — silently discarding most
+ * violation detail even when the full report is a handful of short lines.
+ *
+ * This transform recognizes the bullet-list shape directly so violation text
+ * survives regardless of wording, then defers to the same size-based
+ * clip/elision policy every other transform uses (`createTransformResult` /
+ * `clipRawOutput`'s existing byte threshold) to decide whether the (now
+ * correctly extracted) violation list is short enough to print inline or
+ * long enough to still defer to `wp logs audit`.
+ *
+ * Audit output that isn't shaped like a violation-bullet report (for example
+ * raw subprocess output from `mutation`/`bundle-budget`) has no matching
+ * bullet lines, so this falls back to the previous generic keyword-based
+ * behavior unchanged.
+ */
+export function auditTransform(rawOutput, context) {
+    if (!rawOutput)
+        return {};
+    const failures = extractViolationBullets(rawOutput);
+    if (failures.length === 0)
+        return genericTransform(rawOutput, context);
+    return createTransformResult(rawOutput, failures.map((failure) => failure.message).join("\n"), context, { tier: 1, failures });
+}
+function extractViolationBullets(rawOutput) {
+    const failures = [];
+    for (const line of rawOutput.split(/\r?\n/u)) {
+        const message = VIOLATION_LINE_RE.exec(line)?.[1]?.trim();
+        if (message)
+            failures.push({ message });
+    }
+    return failures;
+}

package/dist/esm/output-transforms/index.js

@@ -1,3 +1,4 @@
+import { auditTransform } from "./audit.js";
 import { genericTransform } from "./generic.js";
 import { oxlintTransform } from "./oxlint.js";
 import { tscTransform } from "./tsc.js";
@@ -8,6 +9,7 @@ const builtInTransforms = new Map([
     ["lint-oxlint", oxlintTransform],
     ["typecheck", tscTransform],
     ["test", vitestTransform],
+    ["audit", auditTransform],
 ]);
 const transforms = new Map(builtInTransforms);
 export function registerTransform(toolName, transform) {

package/dist/esm/package.json

@@ -89,6 +89,8 @@
     "#compiler/*": "./compiler/*.js",
     "#review/*.js": "./review/*.js",
     "#review/*": "./review/*.js",
+    "#rust/*.js": "./rust/*.js",
+    "#rust/*": "./rust/*.js",
     "#telemetry/*.js": "./telemetry/*.js",
     "#telemetry/*": "./telemetry/*.js",
     "#codex/app-server/client": "./codex/app-server/client.js",

package/dist/esm/platform/client.d.ts

@@ -44,8 +44,14 @@ export interface PlatformResponse<T = unknown> {
     readonly status: number;
     readonly data: T;
 }
+/**
+ * Injectable fetch call-signature used by platform transport and tests.
+ * Narrower than `typeof fetch` (which requires Bun/DOM statics like
+ * `preconnect`) so vitest mocks remain assignable without casts.
+ */
+export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 export interface PlatformClientOptions {
-    readonly fetchFn?: typeof globalThis.fetch;
+    readonly fetchFn?: FetchLike;
     readonly maxAttempts?: number;
     readonly baseRetryDelayMs?: number;
     readonly maxRetryDelayMs?: number;

package/dist/esm/platform/github-contract-source.d.ts

@@ -1,9 +1,10 @@
 import { type AuthenticatedPlatformContractSnapshot, type PlatformContractAuthority, type PlatformContractAuthorityProbeResult, type PlatformContractSourceAdapter } from "./contract-provenance.js";
+import { type FetchLike } from "./client.js";
 export interface GitHubContractSourceAdapterOptions {
     readonly token: string;
     readonly authority?: string;
     readonly apiUrl?: string;
-    readonly fetchFn?: typeof globalThis.fetch;
+    readonly fetchFn?: FetchLike;
     readonly sleep?: (delayMs: number) => Promise<void>;
 }
 export declare class GitHubContractSourceAdapter implements PlatformContractSourceAdapter {

package/dist/esm/pr-description/contract.js

@@ -31,13 +31,33 @@ const SESSION_SKIP_PREFIX = /^Session-skip:/im;
 function trim(value) {
     return value?.trim() ?? "";
 }
+/**
+ * Finds the value of a "<label>: <value>" list item at the head of a line,
+ * tolerating a leading "- " bullet and markdown emphasis wrapping the label
+ * (`**bold**`, `__bold__`, `*italic*`, `_italic_`) on either side of the
+ * colon — e.g. both "- Execution model(s): x" and
+ * "- **Execution model(s):** x" match. Still anchored to the start of the
+ * line (after stripping the bullet/emphasis decoration): a mention of the
+ * label mid-sentence never matches. Mirrors the CI `require_field` awk
+ * matcher in `.github/workflows/ci.agent-kit.yml` — keep the two in lockstep.
+ */
 function fieldValue(body, label) {
     const expected = label.toLowerCase();
     for (const line of body.split(/\r?\n/u)) {
-        const normalized = line.toLowerCase();
-        if (normalized.startsWith(`- ${expected}:`) || normalized.startsWith(`${expected}:`)) {
-            return line.slice(line.indexOf(":") + 1).trim();
-        }
+        const colonIndex = line.indexOf(":");
+        if (colonIndex === -1)
+            continue;
+        const before = line
+            .slice(0, colonIndex)
+            .replace(/^\s+/u, "")
+            .replace(/^-\s+/u, "")
+            .replace(/[*_]+/gu, "");
+        if (before.toLowerCase() !== expected)
+            continue;
+        return line
+            .slice(colonIndex + 1)
+            .replace(/^[*_]+/u, "")
+            .trim();
     }
     return undefined;
 }

package/dist/esm/review/authority.js

@@ -9,7 +9,7 @@ import { createHash } from "node:crypto";
 import { existsSync, lstatSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { evaluateReviewEvents, parseReviewEventLog } from "./events.js";
-import { createDeliverySubjectAtRef, createLegacyPlanSubjectAtRef, createPlanSubjectAtRef, resolveReviewCommit, } from "./subject.js";
+import { createDeliverySubjectAtRef, createLegacyPlanSubjectAtRef, createPlanSubjectAtRef, createPreTagsStripPlanSubjectAtRef, resolveReviewCommit, } from "./subject.js";
 const GIT_TIMEOUT_MS = 5_000;
 const GIT_MAX_BUFFER_BYTES = 128 * 1024 * 1024;
 const REGULAR_MODE_PATTERN = /^100(?:644|755)$/u;
@@ -60,7 +60,7 @@ function assertStableSlug(slug) {
 }
 function locateBlueprint(entries, stableSlug) {
     assertStableSlug(stableSlug);
-    const suffixPattern = new RegExp(`(?:^|/)${LIFECYCLE_SEGMENTS}/${stableSlug.replaceAll("/", "\\/")}/_overview\\.md$`, "u");
+    const suffixPattern = new RegExp(`(?:^|/)${LIFECYCLE_SEGMENTS}/${stableSlug.replaceAll("/", "\\/")}(?:/_overview\\.md|\\.md)$`, "u");
     const matches = entries.filter((entry) => suffixPattern.test(entry.path) &&
         REGULAR_MODE_PATTERN.test(entry.mode) &&
         entry.type === "blob");
@@ -69,6 +69,9 @@ function locateBlueprint(entries, stableSlug) {
     }
     return matches[0];
 }
+function ledgerDirectoryForBlueprintPath(blueprintPath) {
+    return blueprintPath.endsWith("/_overview.md") ? path.posix.dirname(blueprintPath) : null;
+}
 function readBlob(cwd, entry) {
     if (!REGULAR_MODE_PATTERN.test(entry.mode) || entry.type !== "blob") {
         throw new Error(`Review authority path is not a regular blob: ${entry.path}`);
@@ -115,14 +118,16 @@ export function readReviewAuthorityAtRef(cwd, ref, stableSlug, purpose) {
     const commit = resolveReviewCommit(cwd, ref);
     const entries = parseRefTree(cwd, commit);
     const overview = locateBlueprint(entries, stableSlug);
-    const blueprintDirectory = path.posix.dirname(overview.path);
-    const ledgerPath = path.posix.join(blueprintDirectory, "review-events.jsonl");
-    const ledger = entries.find((entry) => entry.path === ledgerPath);
+    const blueprintDirectory = ledgerDirectoryForBlueprintPath(overview.path);
+    const ledgerPath = blueprintDirectory === null ? null : path.posix.join(blueprintDirectory, "review-events.jsonl");
+    const ledger = ledgerPath === null ? undefined : entries.find((entry) => entry.path === ledgerPath);
     const events = ledger ? parseReviewEventLog(readBlob(cwd, ledger).toString("utf8")) : [];
     if (events.some((event) => event.blueprintSlug !== stableSlug)) {
         throw new Error(`Review event ledger contains an event for a different blueprint: ${ledgerPath}`);
     }
-    const { compromisedIds, issues } = markCompromisedArtifactEvents(cwd, entries, blueprintDirectory, events);
+    const { compromisedIds, issues } = blueprintDirectory === null
+        ? { compromisedIds: new Set(), issues: [] }
+        : markCompromisedArtifactEvents(cwd, entries, blueprintDirectory, events);
     const subject = purpose === "plan"
         ? createPlanSubjectAtRef(cwd, commit, stableSlug, overview.path)
         : createDeliverySubjectAtRef(cwd, commit, stableSlug, overview.path);
@@ -133,18 +138,23 @@ export function readReviewAuthorityAtRef(cwd, ref, stableSlug, purpose) {
         subjectDigest: subject.digest,
     }, compromisedIds);
     if (purpose === "plan" && evaluation.approvals.length === 0) {
-        // Digest-compatibility fallback: events recorded before the lifecycle
-        // stripped-key extension bound their subjectDigest to the legacy
-        // normalization. Accept those for the same tracked content; new events
-        // always record the current digest (see legacyNormalizePlanSubjectContent).
-        const legacySubject = createLegacyPlanSubjectAtRef(cwd, commit, stableSlug, overview.path);
-        if (legacySubject.digest !== subject.digest) {
+        // Digest-compatibility fallbacks (newest-first after current):
+        // 1) pre-tags-strip: lifecycle strip without advisory `tags` (approvals recorded
+        //    after the stripped-key extension but before the tags strip)
+        // 2) legacy: status + completed_at only (pre-extension)
+        // New events always record the current digest (with tags strip).
+        for (const make of [createPreTagsStripPlanSubjectAtRef, createLegacyPlanSubjectAtRef]) {
+            const alt = make(cwd, commit, stableSlug, overview.path);
+            if (alt.digest === subject.digest)
+                continue;
             evaluation = evaluateReviewEvents(events, {
                 purpose,
                 blueprintSlug: stableSlug,
-                subjectScheme: legacySubject.scheme,
-                subjectDigest: legacySubject.digest,
+                subjectScheme: alt.scheme,
+                subjectDigest: alt.digest,
             }, compromisedIds);
+            if (evaluation.approvals.length > 0)
+                break;
         }
     }
     return {
@@ -160,6 +170,9 @@ export function readReviewAuthorityAtRef(cwd, ref, stableSlug, purpose) {
     };
 }
 export function readWorkingReviewEvents(blueprintPath, stableSlug) {
+    if (path.basename(blueprintPath) !== "_overview.md") {
+        return { events: [], compromisedIds: new Set(), issues: [] };
+    }
     const ledgerPath = path.join(path.dirname(blueprintPath), "review-events.jsonl");
     if (!existsSync(ledgerPath))
         return { events: [], compromisedIds: new Set(), issues: [] };

package/dist/esm/review/availability.d.ts

@@ -45,7 +45,40 @@ export declare function recordReviewAvailability(projectRoot: string, event: Rev
 export declare function recordReviewAvailabilityWithLock(projectRoot: string, event: ReviewAvailabilityEvent): Promise<ReviewAvailabilityState>;
 export declare function isProviderSuppressed(state: ReviewAvailabilityState, provider: ReviewProvider): boolean;
 export declare function suppressedReviewers(state: ReviewAvailabilityState): Set<string>;
+/**
+ * Backstop age for suppressions recorded without a parseable retry window.
+ *
+ * Without this, a provider/account failure that never set `retryAfterMs`
+ * (unparsable limit text, incomplete event payload) stays suppressed forever
+ * and permanently removes that surface from rotation. 24h is long enough that
+ * a real multi-hour/day window still wins when present, and short enough that
+ * a sticky unknown-limit entry self-heals on the next calendar day instead of
+ * requiring a manual availability reset.
+ */
+export declare const MAX_SUPPRESSION_AGE_MS: number;
 export declare function pruneExpiredAvailabilitySuppressions(state: ReviewAvailabilityState, nowMs?: number): {
     state: ReviewAvailabilityState;
     pruned: string[];
 };
+export declare const OPENCODE_ACCOUNT_AVAILABILITY_SCHEMA_VERSION = 1;
+export interface OpencodeAccountAvailabilityState {
+    readonly schemaVersion: 1;
+    readonly updatedAt: string;
+    readonly accounts: Record<string, ReviewAvailabilityRecord>;
+}
+export interface OpencodeAccountAvailabilityEvent {
+    readonly limitWindow?: ReviewLimitWindow;
+    readonly retryAfterMs?: number;
+    readonly failureCode?: string;
+    readonly terminalClassification?: string;
+    readonly at?: string;
+}
+export declare function opencodeAccountAvailabilityPath(): string;
+export declare function loadOpencodeAccountAvailability(): OpencodeAccountAvailabilityState;
+export declare function isOpencodeAccountSuppressed(state: OpencodeAccountAvailabilityState, canonicalId: string): boolean;
+export declare function recordOpencodeAccountAvailability(canonicalId: string, event: OpencodeAccountAvailabilityEvent): OpencodeAccountAvailabilityState;
+export declare function recordOpencodeAccountAvailabilityWithLock(canonicalId: string, event: OpencodeAccountAvailabilityEvent): Promise<OpencodeAccountAvailabilityState>;
+export declare function pruneExpiredOpencodeAccountSuppressions(state: OpencodeAccountAvailabilityState, nowMs?: number): {
+    state: OpencodeAccountAvailabilityState;
+    pruned: string[];
+};

package/dist/esm/review/availability.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import path from "node:path";
-import { NotInGitRepoError, withLock } from "#paths/state-root.js";
+import { getStateRoot, NotInGitRepoError, withLock } from "#paths/state-root.js";
 import { writeJsonFileAtomic } from "#shared-utils/write-json-file.js";
 export const REVIEW_AVAILABILITY_SCHEMA_VERSION = 1;
 const FAILURE_CLASSIFICATIONS = new Set(["provider-limit-reached", "provider-unavailable"]);
@@ -121,10 +121,7 @@ function isAvailabilitySuccess(event) {
     return SUCCESS_CLASSIFICATIONS.has(event.terminalClassification);
 }
 function isProviderWideOpenCodeFailure(event) {
-    return (event.provider === "opencode" &&
-        (event.failureCode === "opencode-go-usage-limit" ||
-            event.reviewer === undefined ||
-            event.reviewer === "opencode"));
+    return (event.provider === "opencode" && (event.reviewer === undefined || event.reviewer === "opencode"));
 }
 function nextRecord(previous, event, input) {
     const at = event.at ?? new Date().toISOString();
@@ -250,26 +247,50 @@ export function suppressedReviewers(state) {
         .filter((record) => record.suppressed)
         .map((record) => record.canonicalId));
 }
-export function pruneExpiredAvailabilitySuppressions(state, nowMs = Date.now()) {
-    const pruned = [];
-    const pruneMap = (records) => Object.fromEntries(Object.entries(records).map(([key, record]) => {
-        if (record.suppressed && !suppressedRecordStillApplies(record)) {
+/**
+ * Backstop age for suppressions recorded without a parseable retry window.
+ *
+ * Without this, a provider/account failure that never set `retryAfterMs`
+ * (unparsable limit text, incomplete event payload) stays suppressed forever
+ * and permanently removes that surface from rotation. 24h is long enough that
+ * a real multi-hour/day window still wins when present, and short enough that
+ * a sticky unknown-limit entry self-heals on the next calendar day instead of
+ * requiring a manual availability reset.
+ */
+export const MAX_SUPPRESSION_AGE_MS = 24 * 60 * 60 * 1000;
+/**
+ * Shared expiry predicate for a suppressed availability record: applies to
+ * both the reviewer/provider store and the opencode-go account store below.
+ * A record clears when its terminal classification is no longer a failure
+ * classification, or when its retry window (or the max-age backstop) has
+ * elapsed.
+ */
+function suppressionExpired(record, nowMs) {
+    if (!record.suppressed)
+        return false;
+    if (!suppressedRecordStillApplies(record))
+        return true;
+    if (record.lastFailureAt === undefined)
+        return false;
+    const failureAt = Date.parse(record.lastFailureAt);
+    if (!Number.isFinite(failureAt))
+        return false;
+    const windowMs = record.retryAfterMs === undefined ? MAX_SUPPRESSION_AGE_MS : record.retryAfterMs;
+    return failureAt + windowMs <= nowMs;
+}
+function pruneRecordMap(records, nowMs, pruned) {
+    return Object.fromEntries(Object.entries(records).map(([key, record]) => {
+        if (suppressionExpired(record, nowMs)) {
             pruned.push(key);
             return [key, { ...record, suppressed: false }];
         }
-        if (record.suppressed &&
-            record.retryAfterMs !== undefined &&
-            record.lastFailureAt !== undefined) {
-            const failureAt = Date.parse(record.lastFailureAt);
-            if (Number.isFinite(failureAt) && failureAt + record.retryAfterMs <= nowMs) {
-                pruned.push(key);
-                return [key, { ...record, suppressed: false }];
-            }
-        }
         return [key, record];
     }));
-    const providers = pruneMap(state.providers);
-    const reviewers = pruneMap(state.reviewers);
+}
+export function pruneExpiredAvailabilitySuppressions(state, nowMs = Date.now()) {
+    const pruned = [];
+    const providers = pruneRecordMap(state.providers, nowMs, pruned);
+    const reviewers = pruneRecordMap(state.reviewers, nowMs, pruned);
     if (pruned.length === 0)
         return { state, pruned };
     return {
@@ -282,3 +303,84 @@ export function pruneExpiredAvailabilitySuppressions(state, nowMs = Date.now())
         pruned,
     };
 }
+// --- opencode-go multi-account cooldown store (user-scoped, cross-repo) ---
+export const OPENCODE_ACCOUNT_AVAILABILITY_SCHEMA_VERSION = 1;
+export function opencodeAccountAvailabilityPath() {
+    return path.join(getStateRoot(), "opencode-account-availability.json");
+}
+function emptyOpencodeAccountAvailability(now = new Date().toISOString()) {
+    return {
+        schemaVersion: OPENCODE_ACCOUNT_AVAILABILITY_SCHEMA_VERSION,
+        updatedAt: now,
+        accounts: {},
+    };
+}
+export function loadOpencodeAccountAvailability() {
+    const file = opencodeAccountAvailabilityPath();
+    if (!existsSync(file))
+        return emptyOpencodeAccountAvailability();
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        if (!isRecord(parsed) ||
+            parsed.schemaVersion !== OPENCODE_ACCOUNT_AVAILABILITY_SCHEMA_VERSION) {
+            return emptyOpencodeAccountAvailability();
+        }
+        return {
+            schemaVersion: OPENCODE_ACCOUNT_AVAILABILITY_SCHEMA_VERSION,
+            updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : new Date().toISOString(),
+            accounts: normalizeRecordMap(parsed.accounts),
+        };
+    }
+    catch {
+        return emptyOpencodeAccountAvailability();
+    }
+}
+function saveOpencodeAccountAvailability(state) {
+    const file = opencodeAccountAvailabilityPath();
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeJsonFileAtomic(file, state);
+}
+export function isOpencodeAccountSuppressed(state, canonicalId) {
+    return state.accounts[canonicalId]?.suppressed === true;
+}
+export function recordOpencodeAccountAvailability(canonicalId, event) {
+    const at = event.at ?? new Date().toISOString();
+    const current = loadOpencodeAccountAvailability();
+    const accounts = { ...current.accounts };
+    accounts[canonicalId] = {
+        canonicalId,
+        provider: "opencode",
+        terminalClassification: event.terminalClassification ?? "provider-limit-reached",
+        ...(event.failureCode ? { failureCode: event.failureCode } : {}),
+        ...(event.limitWindow ? { limitWindow: event.limitWindow } : {}),
+        ...(event.retryAfterMs === undefined ? {} : { retryAfterMs: event.retryAfterMs }),
+        lastFailureAt: at,
+        suppressed: true,
+        suppressionScope: "provider",
+        suppressedAt: at,
+    };
+    const next = {
+        schemaVersion: OPENCODE_ACCOUNT_AVAILABILITY_SCHEMA_VERSION,
+        updatedAt: at,
+        accounts,
+    };
+    saveOpencodeAccountAvailability(next);
+    return next;
+}
+export function recordOpencodeAccountAvailabilityWithLock(canonicalId, event) {
+    return withLock("user", () => recordOpencodeAccountAvailability(canonicalId, event));
+}
+export function pruneExpiredOpencodeAccountSuppressions(state, nowMs = Date.now()) {
+    const pruned = [];
+    const accounts = pruneRecordMap(state.accounts, nowMs, pruned);
+    if (pruned.length === 0)
+        return { state, pruned };
+    return {
+        state: {
+            ...state,
+            updatedAt: new Date(nowMs).toISOString(),
+            accounts,
+        },
+        pruned,
+    };
+}

package/dist/esm/review/delivery-verifier.d.ts

@@ -0,0 +1,27 @@
+import { executeAllowedWpCommand } from "#trust/command-runner.js";
+import type { ReviewTargetCheckout } from "#review/execution/review-checkout.js";
+export interface ReviewGateVerificationCommand {
+    readonly command: string;
+    readonly outcome: "passed" | "failed" | "timed-out" | "deferred";
+    readonly durationMs: number;
+    readonly exitCode: number | null;
+    readonly signal?: string;
+}
+export interface ReviewGateVerification {
+    readonly status: "passed" | "failed";
+    readonly commands: readonly ReviewGateVerificationCommand[];
+    readonly failureCode?: string;
+    readonly logPath?: string;
+}
+export interface VerifyDeliveryGatesInput {
+    readonly purpose: "plan" | "delivery";
+    readonly blueprintContent: string;
+    readonly projectRoot: string;
+    readonly gateId: string;
+    readonly checkout: ReviewTargetCheckout;
+    readonly signal?: AbortSignal;
+    readonly executeCommand?: typeof executeAllowedWpCommand;
+}
+export declare function verifyDeliveryPromotionGates(input: VerifyDeliveryGatesInput): ReviewGateVerification | undefined;
+export declare function verificationPromptSummary(verification: ReviewGateVerification | undefined): string | undefined;
+export declare function verificationArtifactSection(verification: ReviewGateVerification | undefined): string;

package/dist/esm/review/delivery-verifier.js

@@ -0,0 +1,115 @@
+import path from "node:path";
+import { executeAllowedWpCommand, relativeCommandLogPath, } from "#trust/command-runner.js";
+import { parseTrustDossier } from "#trust/dossier.js";
+import { parseAllowedWpCommand } from "#trust/gates.js";
+export function verifyDeliveryPromotionGates(input) {
+    if (input.purpose !== "delivery")
+        return undefined;
+    const parsed = parseTrustDossier(input.blueprintContent);
+    if (parsed.violations.length > 0) {
+        if (parsed.violations.length === 1 &&
+            parsed.violations[0]?.section === "Trust Dossier" &&
+            parsed.violations[0]?.message === "missing Trust Dossier section") {
+            return undefined;
+        }
+        return {
+            status: "failed",
+            commands: [],
+            failureCode: "malformed-trust-dossier",
+        };
+    }
+    const gates = parsed.dossier?.gates ?? [];
+    if (gates.length === 0)
+        return undefined;
+    const commands = [];
+    const executeCommand = input.executeCommand ?? executeAllowedWpCommand;
+    const logRoot = path.join(input.projectRoot, ".webpresso", "logs", "delivery-verification", input.gateId);
+    for (const gate of gates) {
+        if (input.signal?.aborted) {
+            return {
+                status: "failed",
+                commands,
+                failureCode: "verification-cancelled",
+            };
+        }
+        if (isApprovalDependentLifecycleGate(gate.command)) {
+            commands.push({
+                command: gate.command,
+                outcome: "deferred",
+                durationMs: 0,
+                exitCode: null,
+            });
+            continue;
+        }
+        const result = executeCommand({
+            command: gate.command,
+            executionRoot: input.checkout.cwd,
+            logRoot,
+            env: { CI: "1", NO_COLOR: "1", WP_FORCE_SOURCE: "1" },
+        });
+        commands.push(publicCommandResult(result));
+        if (result.outcome !== "passed") {
+            return {
+                status: "failed",
+                commands,
+                failureCode: result.failureCode ?? "verification-command-failed",
+                logPath: relativeCommandLogPath(input.projectRoot, result.logPath),
+            };
+        }
+        const changes = input.checkout.changes();
+        if (changes.length > 0) {
+            return {
+                status: "failed",
+                commands,
+                failureCode: "verification-worktree-contaminated",
+                logPath: relativeCommandLogPath(input.projectRoot, result.logPath),
+            };
+        }
+    }
+    return {
+        status: "passed",
+        commands,
+    };
+}
+export function verificationPromptSummary(verification) {
+    if (!verification)
+        return undefined;
+    if (verification.status !== "passed")
+        return undefined;
+    return [
+        "Host verification before outside review: passed.",
+        ...verification.commands.map((command, index) => `${index + 1}. ${command.command}: ${command.outcome === "deferred" ? "deferred until review publication" : "passed"}`),
+    ].join("\n");
+}
+function isApprovalDependentLifecycleGate(command) {
+    try {
+        const [, subcommand, kind] = parseAllowedWpCommand(command);
+        return subcommand === "audit" && kind === "blueprint-lifecycle";
+    }
+    catch {
+        return false;
+    }
+}
+export function verificationArtifactSection(verification) {
+    if (!verification)
+        return "";
+    const lines = [
+        "## Host Verification",
+        "",
+        `Status: ${verification.status}`,
+        ...verification.commands.map((command, index) => `${index + 1}. ${command.command} -> ${command.outcome} (${command.durationMs}ms, exit ${command.exitCode ?? "null"})`),
+        ...(verification.failureCode ? [`Failure code: ${verification.failureCode}`] : []),
+        ...(verification.logPath ? [`Log: ${verification.logPath}`] : []),
+        "",
+    ];
+    return `${lines.join("\n")}\n`;
+}
+function publicCommandResult(result) {
+    return {
+        command: result.command,
+        outcome: result.outcome,
+        durationMs: result.durationMs,
+        exitCode: result.exitCode,
+        ...(result.signal ? { signal: result.signal } : {}),
+    };
+}