@webpresso/agent-kit 3.1.28 → 3.2.0

package/dist/esm/review/execution/adapters.js

@@ -3,7 +3,7 @@ import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { CLAUDE_DEFAULT_REVIEW_MODEL, CODEX_DEFAULT_REVIEW_MODEL, GROK_DEFAULT_REVIEW_MODEL, } from "./types.js";
-import { canonicalizeProviderFailureCode } from "./output-policy.js";
+import { canonicalizeProviderFailureCode, sanitizeProviderErrorDetail } from "./output-policy.js";
 function objectValue(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -61,6 +61,18 @@ function providerErrorMessage(value) {
     ];
     return candidates.find((candidate) => typeof candidate === "string") ?? null;
 }
+// Builds a "failure" event, attaching the provider's raw diagnostic text
+// (sanitized and length-bounded) alongside the canonical short `code` when
+// one is available. `code` stays the only field the retry/classification
+// control flow reads; `message` exists purely to be surfaced to a caller who
+// is stuck debugging a generic failure code.
+function providerFailureEvent(value, code, message = providerErrorMessage(value)) {
+    return {
+        kind: "failure",
+        code,
+        ...(message ? { message: sanitizeProviderErrorDetail(message) } : {}),
+    };
+}
 function parseResetDurationMs(message) {
     const reset = message.match(/\bresets?\s+in\s+([^.'"]+)/iu)?.[1];
     if (!reset)
@@ -94,6 +106,7 @@ function opencodeUsageLimit(message) {
     return {
         kind: "failure",
         code: "opencode-go-usage-limit",
+        message: sanitizeProviderErrorDetail(message),
         limitWindow,
         ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
     };
@@ -104,7 +117,7 @@ function claudeEvent(value) {
         return { kind: "unsupported" };
     if (record.type === "result") {
         if (record.is_error === true || record.subtype === "error") {
-            return { kind: "failure", code: failureCode(record) };
+            return providerFailureEvent(record, failureCode(record));
         }
         return {
             kind: "terminal",
@@ -112,7 +125,7 @@ function claudeEvent(value) {
         };
     }
     if (record.type === "error")
-        return { kind: "failure", code: failureCode(record) };
+        return providerFailureEvent(record, failureCode(record));
     if (record.type === "rate_limit_event") {
         const rateLimit = objectValue(record.rate_limit_info);
         return rateLimit?.status === "rejected"
@@ -127,7 +140,7 @@ function claudeEvent(value) {
     }
     if (record.type === "assistant") {
         return typeof record.error === "string"
-            ? { kind: "failure", code: failureCode(record) }
+            ? providerFailureEvent(record, failureCode(record), record.error)
             : { kind: "progress", frontier: claudeEnvelopeFrontier(record) };
     }
     if (record.type !== "stream_event")
@@ -151,7 +164,7 @@ function claudeEvent(value) {
         return { kind: "progress", frontier: stableFrontier(event) };
     }
     if (event.type === "error")
-        return { kind: "failure", code: failureCode(event) };
+        return providerFailureEvent(event, failureCode(event));
     return { kind: "unsupported" };
 }
 function opencodeText(record) {
@@ -216,7 +229,7 @@ function opencodeEvent(value) {
     if (record.type === "error") {
         const message = providerErrorMessage(record);
         const usageLimit = message === null ? null : opencodeUsageLimit(message);
-        return usageLimit ?? { kind: "failure", code: failureCode(record) };
+        return usageLimit ?? providerFailureEvent(record, failureCode(record), message);
     }
     // OpenCode's non-interactive JSON protocol closes a completed run with
     // session.idle or step_finish(reason: "stop"); recorded Kimi and DeepSeek
@@ -293,10 +306,10 @@ function codexEvent(value) {
                     : message && /rate.?limit|quota/iu.test(message)
                         ? "rate-limit-rejected"
                         : "provider-error");
-        return { kind: "failure", code };
+        return providerFailureEvent(record, code, message);
     }
     if (type.includes("rate_limit") && /reject|limit|quota/iu.test(message ?? "")) {
-        return { kind: "failure", code: "rate-limit-rejected" };
+        return providerFailureEvent(record, "rate-limit-rejected", message);
     }
     if (type === "result" ||
         type === "final" ||
@@ -399,6 +412,10 @@ export const opencodeReviewAdapter = {
                 OPENCODE_CONFIG_CONTENT: OPENCODE_REVIEW_CONFIG,
                 OPENCODE_DISABLE_AUTOUPDATE: "true",
                 OPENCODE_DISABLE_PRUNE: "true",
+                // Isolate the credential store per account: the spawn reads
+                // `<authDataDir>/opencode/auth.json` instead of the user's global file,
+                // so mid-flight account failover never races a live interactive TUI.
+                ...(input.authDataDir ? { XDG_DATA_HOME: input.authDataDir } : {}),
             },
             cleanup: attachment.cleanup,
         };
@@ -506,7 +523,7 @@ export const grokReviewAdapter = {
             return {
                 kind: "failure",
                 code: "provider-failed",
-                message,
+                message: sanitizeProviderErrorDetail(message),
             };
         }
         return { kind: "progress", frontier: type || "event" };

package/dist/esm/review/execution/output-policy.d.ts

@@ -11,4 +11,6 @@ export type ReviewOutputPolicyResult = {
 };
 export declare function sanitizeReviewOutput(value: string): string;
 export declare function applyReviewOutputPolicy(value: string, consumedBytes?: number): ReviewOutputPolicyResult;
+export declare const REVIEW_ERROR_DETAIL_MAX_CHARS = 400;
+export declare function sanitizeProviderErrorDetail(value: string): string;
 export declare function canonicalizeProviderFailureCode(value: unknown): string;

package/dist/esm/review/execution/output-policy.js

@@ -23,6 +23,18 @@ export function applyReviewOutputPolicy(value, consumedBytes = 0) {
     }
     return { ok: true, value: sanitized, bytes, totalBytes: consumedBytes + bytes };
 }
+export const REVIEW_ERROR_DETAIL_MAX_CHARS = 400;
+// Bounds and redacts a provider's raw diagnostic text (a JSON envelope's
+// error.message field, or a raw stderr line) before it is retained anywhere.
+// This feeds only the ephemeral gate state file and CLI stdout -- never the
+// durable, git-committed review ledger -- but the same secret redaction that
+// already applies to terminal/progress "result" text applies here too.
+export function sanitizeProviderErrorDetail(value) {
+    const sanitized = sanitizeReviewOutput(value).replace(/\s+/gu, " ").trim();
+    return sanitized.length > REVIEW_ERROR_DETAIL_MAX_CHARS
+        ? `${sanitized.slice(0, REVIEW_ERROR_DETAIL_MAX_CHARS)}…`
+        : sanitized;
+}
 export function canonicalizeProviderFailureCode(value) {
     if (typeof value !== "string")
         return "provider-error";

package/dist/esm/review/execution/review-checkout.js

@@ -1,8 +1,8 @@
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { lstatSync, mkdtempSync, readFileSync, readdirSync, readlinkSync, rmSync, unlinkSync, writeFileSync, } from "node:fs";
+import { lstatSync, mkdtempSync, readFileSync, readdirSync, readlinkSync, rmSync, symlinkSync, unlinkSync, writeFileSync, } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 function git(cwd, args, input) {
     return execFileSync("git", [...args], {
         cwd,
@@ -60,12 +60,69 @@ function worktreeFingerprint(cwd) {
     }
     return hash.digest("hex");
 }
-function status(cwd) {
+// Path segments that mark gitignored content as NON-source: derived build
+// outputs a Promotion Gate command (`./bin/wp typecheck`/`test`/etc.)
+// regenerates while self-hosting this repo (`dist/`, `.tshy/`) and the
+// reconstructed dependency tree (`node_modules`, already separately allowlisted
+// via `ignoredPaths` when symlinked — kept here too for depth-safety, e.g. a
+// nested per-workspace-package `node_modules`). A gitignored (`!!`) path whose
+// ANY segment is one of these — at any workspace depth (e.g. `packages/x/dist`,
+// `.tshy/build.log`) — is exempt from the contamination check. Confirmed
+// empirically that the gate commands emit gitignored output exclusively under
+// these roots.
+//
+// SCOPE (deliberate, documented): this verifier enforces the review TARGET's
+// *source* integrity, not its build artifacts. It does not flag writes under a
+// derived/dependency root, because such output can reach neither the caller
+// nor the reviewed source (the checkout is a disposable tmpdir). Everything
+// else stays strict: a tracked mutation (` M `/` D `), a new untracked source
+// file (`?? `), and any NON-derived gitignored write (e.g. a stray `.env`) all
+// still surface.
+const NON_SOURCE_IGNORED_SEGMENTS = new Set(["dist", ".tshy", "node_modules"]);
+function isNonSourceIgnoredPath(relativePath) {
+    return relativePath.split("/").some((segment) => NON_SOURCE_IGNORED_SEGMENTS.has(segment));
+}
+// This repo self-hosts: a Promotion Gate command's first `./bin/wp` invocation
+// triggers wp's own bootstrap build, which runs tshy and then
+// `./bin/wp format --file package.json` — an IDEMPOTENT normalization (e.g.
+// adding a missing trailing newline). Re-running it a second time produces
+// byte-identical output modulo trailing whitespace, so it is not a source
+// mutation. Exempt ONLY that exact shape: a plain, unstaged content
+// modification (` M `) of a file literally named `package.json` whose
+// tracked-vs-working-tree bytes differ solely in trailing whitespace. Any
+// other package.json change (dependency/script/field edits, staged changes,
+// adds, deletes) still fails closed — this check never inspects JSON
+// semantics, only trailing-whitespace-normalized byte equality.
+function isNormalizedPackageJsonModification(cwd, line) {
+    if (!line.startsWith(" M "))
+        return false;
+    const relativePath = line.slice(3);
+    if (basename(relativePath) !== "package.json")
+        return false;
+    try {
+        const working = readFileSync(join(cwd, relativePath), "utf8");
+        const tracked = git(cwd, ["show", `HEAD:${relativePath}`]);
+        return working.replace(/\s+$/u, "") === tracked.replace(/\s+$/u, "");
+    }
+    catch {
+        return false;
+    }
+}
+function status(cwd, ignoredPaths = new Set()) {
     const output = git(cwd, ["status", "--porcelain=v1", "--untracked-files=all", "--ignored"]);
     return output
         .split(/\r?\n/u)
-        .map((line) => line.trimEnd())
-        .filter((line) => line.length > 0);
+        .filter((line) => line.length > 0)
+        .filter((line) => {
+        const relativePath = line.slice(3).replace(/\/$/u, "");
+        if (ignoredPaths.has(relativePath))
+            return false;
+        if (line.startsWith("!!") && isNonSourceIgnoredPath(relativePath))
+            return false;
+        if (isNormalizedPackageJsonModification(cwd, line))
+            return false;
+        return true;
+    });
 }
 function neutralizeSymlinks(directory) {
     for (const entry of readdirSync(directory, { withFileTypes: true })) {
@@ -111,6 +168,7 @@ export function createReviewTargetCheckout(repositoryRoot, targetSha) {
         git(cwd, ["update-ref", "HEAD", baselineHead]);
         if (status(cwd).length > 0)
             throw new Error("review target checkout was not clean at start");
+        const injectedPaths = projectCallerDependencies(repositoryRoot, cwd);
         let cleaned = false;
         return {
             cwd,
@@ -119,7 +177,7 @@ export function createReviewTargetCheckout(repositoryRoot, targetSha) {
             },
             changes: () => {
                 try {
-                    const changes = [...status(cwd)];
+                    const changes = [...status(cwd, injectedPaths)];
                     if (git(cwd, ["rev-parse", "HEAD"]).trim() !== baselineHead) {
                         changes.push("review checkout HEAD changed");
                     }
@@ -145,3 +203,26 @@ export function createReviewTargetCheckout(repositoryRoot, targetSha) {
         throw error;
     }
 }
+function projectCallerDependencies(repositoryRoot, checkoutRoot) {
+    const projected = new Set();
+    const dependencyPath = "node_modules";
+    const callerPath = join(repositoryRoot, dependencyPath);
+    const targetPath = join(checkoutRoot, dependencyPath);
+    try {
+        lstatSync(callerPath);
+    }
+    catch {
+        return projected;
+    }
+    try {
+        lstatSync(targetPath);
+        return projected;
+    }
+    catch {
+        // Missing in the target archive means the caller dependency cache may be
+        // projected for local tooling without overwriting target-owned files.
+    }
+    symlinkSync(callerPath, targetPath, "dir");
+    projected.add(dependencyPath);
+    return projected;
+}

package/dist/esm/review/execution/supervisor.js

@@ -107,6 +107,7 @@ export async function superviseReviewExecution(input, adapter, deps = {}) {
     });
     let status = null;
     let failureCode;
+    let providerErrorDetail;
     let limitWindow;
     let retryAfterMs;
     let result;
@@ -191,6 +192,7 @@ export async function superviseReviewExecution(input, adapter, deps = {}) {
         failureCode = code;
         limitWindow = metadata.limitWindow;
         retryAfterMs = metadata.retryAfterMs;
+        providerErrorDetail = metadata.providerErrorDetail;
         requestTermination();
         finalize();
     };
@@ -249,6 +251,7 @@ export async function superviseReviewExecution(input, adapter, deps = {}) {
             fail("provider-failure", canonicalizeProviderFailureCode(event.code), {
                 ...(event.limitWindow === undefined ? {} : { limitWindow: event.limitWindow }),
                 ...(event.retryAfterMs === undefined ? {} : { retryAfterMs: event.retryAfterMs }),
+                ...(event.message === undefined ? {} : { providerErrorDetail: event.message }),
             });
             return;
         }
@@ -324,6 +327,7 @@ export async function superviseReviewExecution(input, adapter, deps = {}) {
             fail("provider-failure", canonicalizeProviderFailureCode(event.code), {
                 ...(event.limitWindow === undefined ? {} : { limitWindow: event.limitWindow }),
                 ...(event.retryAfterMs === undefined ? {} : { retryAfterMs: event.retryAfterMs }),
+                ...(event.message === undefined ? {} : { providerErrorDetail: event.message }),
             });
         }
     };
@@ -425,6 +429,7 @@ export async function superviseReviewExecution(input, adapter, deps = {}) {
             markerMatched,
             ...(result === undefined ? {} : { result }),
             ...(terminalFailureCode === undefined ? {} : { failureCode: terminalFailureCode }),
+            ...(providerErrorDetail === undefined ? {} : { providerErrorDetail }),
             ...(limitWindow === undefined ? {} : { limitWindow }),
             ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
             summaryPath: artifacts.summaryPath,

package/dist/esm/review/execution/types.d.ts

@@ -19,6 +19,12 @@ export interface ReviewRunInput {
     readonly cwd?: string;
     readonly registryRoot?: string;
     readonly signal?: AbortSignal;
+    /**
+     * Isolated opencode auth store directory for this spawn. When set, the
+     * opencode adapter injects it as `XDG_DATA_HOME` so the child reads a
+     * per-account `auth.json` instead of the user's global credential store.
+     */
+    readonly authDataDir?: string;
 }
 export interface ReviewInvocation {
     readonly command: string;
@@ -41,6 +47,7 @@ export type ReviewAdapterEvent = {
 } | {
     readonly kind: "failure";
     readonly code: string;
+    readonly message?: string;
     readonly limitWindow?: ReviewLimitWindow;
     readonly retryAfterMs?: number;
 } | {
@@ -70,6 +77,7 @@ export interface ReviewRunSummary {
     readonly markerMatched: boolean | null;
     readonly result?: string;
     readonly failureCode?: string;
+    readonly providerErrorDetail?: string;
     readonly limitWindow?: ReviewLimitWindow;
     readonly retryAfterMs?: number;
     readonly summaryPath: string;

package/dist/esm/review/opencode-account.d.ts

@@ -0,0 +1,24 @@
+import { type OpencodeAccountAvailabilityState } from "./availability.js";
+export interface OpencodeAccount {
+    readonly id: string;
+    readonly secretName: string;
+    readonly key: string;
+}
+export interface OpencodeAccountSelection {
+    readonly account: OpencodeAccount;
+    readonly cooled: boolean;
+    readonly waitMs?: number;
+}
+/**
+ * Discover opencode-go accounts from Doppler-sourced secrets shaped
+ * `OPENCODE_GO_KEY_<ID>`. Sorted by id ascending, de-duplicated by id.
+ */
+export declare function resolveOpencodeAccounts(secrets: Readonly<Record<string, string>>): readonly OpencodeAccount[];
+export declare function opencodeAccountCanonicalId(id: string): string;
+export declare function opencodeAccountDataDir(id: string, stateRoot?: string): string;
+/**
+ * Select the account to use for the next opencode-go invocation. Callers must
+ * prune expired suppressions in `state` before calling this (via
+ * `pruneExpiredOpencodeAccountSuppressions`).
+ */
+export declare function selectActiveOpencodeAccount(accounts: readonly OpencodeAccount[], state: OpencodeAccountAvailabilityState, nowMs?: number): OpencodeAccountSelection | undefined;

package/dist/esm/review/opencode-account.js

@@ -0,0 +1,68 @@
+import path from "node:path";
+import { getStateRoot } from "#paths/state-root.js";
+import { isOpencodeAccountSuppressed, } from "./availability.js";
+const OPENCODE_GO_KEY_PATTERN = /^OPENCODE_GO_KEY_([A-Za-z0-9]+)$/;
+/**
+ * Discover opencode-go accounts from Doppler-sourced secrets shaped
+ * `OPENCODE_GO_KEY_<ID>`. Sorted by id ascending, de-duplicated by id.
+ */
+export function resolveOpencodeAccounts(secrets) {
+    const byId = new Map();
+    for (const [secretName, key] of Object.entries(secrets)) {
+        if (!key || key.trim().length === 0)
+            continue;
+        const match = OPENCODE_GO_KEY_PATTERN.exec(secretName);
+        if (!match?.[1])
+            continue;
+        const id = match[1].toLowerCase();
+        if (!byId.has(id))
+            byId.set(id, { id, secretName, key });
+    }
+    return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+export function opencodeAccountCanonicalId(id) {
+    return `opencode-go:${id}`;
+}
+export function opencodeAccountDataDir(id, stateRoot) {
+    return path.join(stateRoot ?? getStateRoot(), "opencode-accounts", id);
+}
+function suppressionExpiryMs(state, canonicalId) {
+    const record = state.accounts[canonicalId];
+    if (record === undefined || record.lastFailureAt === undefined)
+        return undefined;
+    const failureAt = Date.parse(record.lastFailureAt);
+    if (!Number.isFinite(failureAt))
+        return undefined;
+    return failureAt + (record.retryAfterMs ?? 0);
+}
+function pickSoonestExpiring(accounts, state, nowMs) {
+    const withExpiry = accounts.map((account) => ({
+        account,
+        expiresAt: suppressionExpiryMs(state, opencodeAccountCanonicalId(account.id)) ??
+            Number.POSITIVE_INFINITY,
+    }));
+    // `accounts` is non-empty whenever this is called, so a no-initial-value
+    // reduce is safe and keeps the accumulator type undefined-free.
+    const soonest = withExpiry.reduce((min, candidate) => candidate.expiresAt < min.expiresAt ? candidate : min);
+    const waitMs = Number.isFinite(soonest.expiresAt)
+        ? Math.max(0, soonest.expiresAt - nowMs)
+        : undefined;
+    return {
+        account: soonest.account,
+        cooled: true,
+        ...(waitMs === undefined ? {} : { waitMs }),
+    };
+}
+/**
+ * Select the account to use for the next opencode-go invocation. Callers must
+ * prune expired suppressions in `state` before calling this (via
+ * `pruneExpiredOpencodeAccountSuppressions`).
+ */
+export function selectActiveOpencodeAccount(accounts, state, nowMs = Date.now()) {
+    if (accounts.length === 0)
+        return undefined;
+    const available = accounts.find((account) => !isOpencodeAccountSuppressed(state, opencodeAccountCanonicalId(account.id)));
+    if (available)
+        return { account: available, cooled: false };
+    return pickSoonestExpiring(accounts, state, nowMs);
+}

package/dist/esm/review/opencode-auth.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Resolve opencode's `auth.json` path from an XDG-style data-home env var.
+ *
+ * Mirrors the resolver in `src/cli/commands/dash/opencode-db.ts`
+ * (`opencodeDatabasePath`), but targets `opencode/auth.json` instead of
+ * `opencode/opencode.db`.
+ */
+export declare function opencodeAuthPath(env?: Readonly<Record<string, string | undefined>>, home?: string): string;
+export interface MaterializeOpencodeGoAuthOptions {
+    readonly dataDir?: string;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly home?: string;
+}
+export interface MaterializeOpencodeGoAuthResult {
+    readonly path: string;
+    readonly wrote: boolean;
+}
+/**
+ * Read the `opencode-go` API key currently on disk, or `undefined` when the
+ * store is missing, corrupt, or holds no `opencode-go` entry.
+ *
+ * Callers use this to identify which account is currently materialized by
+ * matching the value against their own resolved account list — that keeps the
+ * "which account is active" question answerable without persisting extra state.
+ * Never throws.
+ */
+export declare function readOpencodeGoKey(options?: MaterializeOpencodeGoAuthOptions): string | undefined;
+/**
+ * Merge an `opencode-go` API-key entry into opencode's `auth.json`, preserving
+ * every other provider entry already on disk. Never throws on a missing,
+ * unreadable, or corrupt existing file — that state is treated as `{}`.
+ */
+export declare function materializeOpencodeGoAuth(key: string, options?: MaterializeOpencodeGoAuthOptions): MaterializeOpencodeGoAuthResult;

package/dist/esm/review/opencode-auth.js

@@ -0,0 +1,79 @@
+import { mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { writeJsonFileAtomic } from "#shared-utils/write-json-file.js";
+/**
+ * Resolve opencode's `auth.json` path from an XDG-style data-home env var.
+ *
+ * Mirrors the resolver in `src/cli/commands/dash/opencode-db.ts`
+ * (`opencodeDatabasePath`), but targets `opencode/auth.json` instead of
+ * `opencode/opencode.db`.
+ */
+export function opencodeAuthPath(env = process.env, home = homedir()) {
+    const dataHome = env["XDG_DATA_HOME"]?.trim() || join(home, ".local", "share");
+    return join(dataHome, "opencode", "auth.json");
+}
+function resolveAuthPath(options) {
+    if (options.dataDir !== undefined) {
+        return join(options.dataDir, "opencode", "auth.json");
+    }
+    return opencodeAuthPath(options.env, options.home);
+}
+function readExistingAuth(path) {
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+function isSameOpencodeGoEntry(entry, key) {
+    if (entry === null || typeof entry !== "object")
+        return false;
+    const candidate = entry;
+    return candidate["type"] === "api" && candidate["key"] === key;
+}
+/**
+ * Read the `opencode-go` API key currently on disk, or `undefined` when the
+ * store is missing, corrupt, or holds no `opencode-go` entry.
+ *
+ * Callers use this to identify which account is currently materialized by
+ * matching the value against their own resolved account list — that keeps the
+ * "which account is active" question answerable without persisting extra state.
+ * Never throws.
+ */
+export function readOpencodeGoKey(options = {}) {
+    const entry = readExistingAuth(resolveAuthPath(options))["opencode-go"];
+    if (entry === null || typeof entry !== "object")
+        return undefined;
+    const candidate = entry;
+    return typeof candidate["key"] === "string" ? candidate["key"] : undefined;
+}
+/**
+ * Merge an `opencode-go` API-key entry into opencode's `auth.json`, preserving
+ * every other provider entry already on disk. Never throws on a missing,
+ * unreadable, or corrupt existing file — that state is treated as `{}`.
+ */
+export function materializeOpencodeGoAuth(key, options = {}) {
+    const path = resolveAuthPath(options);
+    const existing = readExistingAuth(path);
+    if (isSameOpencodeGoEntry(existing["opencode-go"], key)) {
+        return { path, wrote: false };
+    }
+    const entry = { type: "api", key };
+    const next = { ...existing, "opencode-go": entry };
+    mkdirSync(dirname(path), { recursive: true });
+    writeJsonFileAtomic(path, next, { writeFileOptions: { mode: 0o600 } });
+    return { path, wrote: true };
+}

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

@@ -12,13 +12,40 @@ interface TreeEntry {
     readonly path: Buffer;
 }
 export declare function resolveReviewCommit(cwd: string, ref: string): string;
+/**
+ * Repo-relative paths with uncommitted changes (staged, unstaged, or
+ * untracked) that are NOT review evidence (reviews.md / review-events.jsonl /
+ * review-artifacts/*.md — see isReviewEvidenceRelativePath). A `wp-git-tree-v1`
+ * subject digest is computed purely from the committed tree at a ref, so any
+ * non-evidence path here means the working tree diverges from what that
+ * digest — and any approval bound to it — actually covers. Review evidence is
+ * excluded because the gate's own artifact/ledger writes routinely leave the
+ * tree dirty between reruns without representing unreviewed content.
+ */
+export declare function findUnreviewedWorkingTreeChanges(cwd: string): readonly string[];
 declare function isExcludedReviewEnvelope(entry: TreeEntry, blueprintRoot: Buffer): boolean;
+export declare function isReviewEvidenceRelativePath(value: string): boolean;
 declare function isReviewEvidencePath(entry: TreeEntry): boolean;
 declare function updateField(hash: Hash, value: Buffer | string): void;
 export declare function createDeliverySubjectAtRef(cwd: string, ref: string, blueprintSlug: string, blueprintPath?: string): ReviewSubject;
 export declare function createSourceSubjectAtRef(cwd: string, ref: string): ReviewSubject;
 export declare function normalizePlanSubjectContent(content: Buffer | string): Buffer;
+/**
+ * Plan-subject digest for in-memory (working-tree) blueprint content. Used to
+ * accept working-ledger review events that digest-bind the exact bytes being
+ * committed (pre-commit runs before those events reach any git ref).
+ */
+export declare function createPlanSubjectDigestForContent(blueprintSlug: string, content: Buffer | string): string;
+/**
+ * Digest-compatibility variant for review events recorded before the
+ * stripped-key extension of `neutralizeLifecycleFrontmatter`. Verification
+ * accepts a match against either normalization; new digests always use
+ * `normalizePlanSubjectContent`.
+ */
+export declare function legacyNormalizePlanSubjectContent(content: Buffer | string): Buffer;
 export declare function createPlanSubjectAtRef(cwd: string, ref: string, blueprintSlug: string, blueprintPath?: string): ReviewSubject;
+/** Plan subject digested with the pre-extension normalization (see above). */
+export declare function createLegacyPlanSubjectAtRef(cwd: string, ref: string, blueprintSlug: string, blueprintPath?: string): ReviewSubject;
 export declare const reviewSubjectInternals: {
     isExcludedReviewEnvelope: typeof isExcludedReviewEnvelope;
     isReviewEvidencePath: typeof isReviewEvidencePath;