@webpresso/agent-kit 3.1.30 → 3.3.0

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,7 +12,19 @@ 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;
@@ -31,9 +43,22 @@ export declare function createPlanSubjectDigestForContent(blueprintSlug: string,
  * `normalizePlanSubjectContent`.
  */
 export declare function legacyNormalizePlanSubjectContent(content: Buffer | string): Buffer;
+/**
+ * Digest-compatibility variant for review events recorded after the lifecycle
+ * stripped-key extension but before the advisory `tags` strip. Verification
+ * accepts a match against this tier so existing plan approvals on tagged
+ * blueprints are not stranded by the tags-strip rollout.
+ */
+export declare function preTagsStripNormalizePlanSubjectContent(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;
+/** Plan subject digested without the advisory `tags` strip (pre-tags-strip tier). */
+export declare function createPreTagsStripPlanSubjectAtRef(cwd: string, ref: string, blueprintSlug: string, blueprintPath?: string): ReviewSubject;
+/** Working-ledger digest for the pre-tags-strip compatibility tier. */
+export declare function createPreTagsStripPlanSubjectDigestForContent(blueprintSlug: string, content: Buffer | string): string;
+/** Working-ledger digest for the pre-extension legacy compatibility tier. */
+export declare function createLegacyPlanSubjectDigestForContent(blueprintSlug: string, content: Buffer | string): string;
 export declare const reviewSubjectInternals: {
     isExcludedReviewEnvelope: typeof isExcludedReviewEnvelope;
     isReviewEvidencePath: typeof isReviewEvidencePath;

package/dist/esm/review/subject.js

@@ -39,6 +39,43 @@ export function resolveReviewCommit(cwd, ref) {
     }
     return commit;
 }
+/**
+ * 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 function findUnreviewedWorkingTreeChanges(cwd) {
+    const output = gitBuffer(cwd, [
+        "status",
+        "--porcelain=v1",
+        "--untracked-files=all",
+        "--ignored=no",
+        "-z",
+    ]).toString("utf8");
+    const records = output.split("\0").filter((record) => record.length > 0);
+    const paths = new Set();
+    for (let index = 0; index < records.length; index += 1) {
+        const record = records[index];
+        const statusCode = record.slice(0, 2);
+        paths.add(record.slice(3));
+        if (/[RC]/u.test(statusCode)) {
+            // Rename/copy porcelain records are followed by the original path.
+            const originalPath = records[index + 1];
+            if (originalPath !== undefined) {
+                paths.add(originalPath);
+                index += 1;
+            }
+        }
+    }
+    return [...paths]
+        .filter((relativePath) => !isReviewEvidenceRelativePath(relativePath))
+        .toSorted();
+}
 function parseTree(cwd, commit) {
     const output = gitBuffer(cwd, ["ls-tree", "-r", "-z", "--full-tree", commit]);
     const entries = [];
@@ -74,31 +111,40 @@ function parseTree(cwd, commit) {
         throw new Error("Truncated git ls-tree output.");
     return entries.sort((left, right) => Buffer.compare(left.path, right.path));
 }
-function findBlueprintRoot(entries, blueprintSlug, blueprintPath) {
+function isRegularBlob(entry) {
+    return entry.type === "blob" && /^100(?:644|755)$/u.test(entry.mode.toString("ascii"));
+}
+function findBlueprintDocument(entries, blueprintSlug, blueprintPath) {
     if (blueprintPath) {
         const normalized = blueprintPath.replaceAll("\\", "/");
         const target = Buffer.from(normalized, "utf8");
-        const matches = entries.filter((entry) => entry.path.equals(target));
-        if (matches.length === 1 && normalized.endsWith("/_overview.md")) {
-            return target.subarray(0, target.length - Buffer.byteLength("_overview.md"));
+        const matches = entries.filter((entry) => entry.path.equals(target) && isRegularBlob(entry));
+        if (matches.length === 1 && normalized.endsWith(".md")) {
+            return matches[0];
         }
     }
-    const suffix = Buffer.from(`/${blueprintSlug}/_overview.md`, "utf8");
+    const folderSuffix = `/${blueprintSlug}/_overview.md`;
+    const flatSuffix = `/${blueprintSlug}.md`;
     const matches = entries.filter((entry) => {
         const normalized = entry.path.toString("utf8");
-        const segments = normalized.split("/");
-        return (segments[0] === "blueprints" &&
-            BLUEPRINT_STATUSES.has(segments[1] ?? "") &&
-            entry.path.subarray(-suffix.length).equals(suffix));
+        const suffix = normalized.endsWith(folderSuffix)
+            ? folderSuffix
+            : normalized.endsWith(flatSuffix)
+                ? flatSuffix
+                : undefined;
+        const lifecycle = suffix ? normalized.slice(0, -suffix.length).split("/").at(-1) : undefined;
+        return isRegularBlob(entry) && BLUEPRINT_STATUSES.has(lifecycle ?? "");
     });
     if (matches.length !== 1) {
         throw new Error(`Expected one tracked blueprint ${blueprintSlug} at target commit, found ${matches.length}.`);
     }
-    const overview = matches[0].path;
-    return overview.subarray(0, overview.length - Buffer.byteLength("_overview.md"));
+    return matches[0];
 }
-function isRegularBlob(entry) {
-    return entry.type === "blob" && /^100(?:644|755)$/u.test(entry.mode.toString("ascii"));
+function blueprintEvidenceRoot(documentPath) {
+    const value = documentPath.toString("utf8");
+    if (!value.endsWith("/_overview.md"))
+        return null;
+    return documentPath.subarray(0, documentPath.length - Buffer.byteLength("_overview.md"));
 }
 function isExcludedReviewEnvelope(entry, blueprintRoot) {
     if (!isRegularBlob(entry) ||
@@ -114,10 +160,10 @@ function isExcludedReviewEnvelope(entry, blueprintRoot) {
     const artifactName = relative.slice(prefix.length);
     return artifactName.length > 3 && !artifactName.includes("/") && artifactName.endsWith(".md");
 }
-function isReviewEvidencePath(entry) {
-    if (!isRegularBlob(entry))
-        return false;
-    const value = entry.path.toString("utf8");
+// String-based counterpart of isReviewEvidencePath, shared with callers that
+// only have a repo-relative path (no TreeEntry) — currently the working-tree
+// divergence check in findUnreviewedWorkingTreeChanges below.
+export function isReviewEvidenceRelativePath(value) {
     if (!/^blueprints\/(?:[^/]+\/)*[^/]+\//u.test(value))
         return false;
     if (/(?:^|\/)reviews\.md$/u.test(value) || /(?:^|\/)review-events\.jsonl$/u.test(value)) {
@@ -125,6 +171,11 @@ function isReviewEvidencePath(entry) {
     }
     return /(?:^|\/)review-artifacts\/[^/]+\.md$/u.test(value);
 }
+function isReviewEvidencePath(entry) {
+    if (!isRegularBlob(entry))
+        return false;
+    return isReviewEvidenceRelativePath(entry.path.toString("utf8"));
+}
 function loadBlobContents(cwd, entries) {
     const blobs = entries.filter((entry) => entry.type === "blob");
     if (blobs.length === 0)
@@ -195,11 +246,13 @@ function readTreeAtRef(cwd, ref) {
 }
 export function createDeliverySubjectAtRef(cwd, ref, blueprintSlug, blueprintPath) {
     const { commit, objectFormat, entries: allEntries } = readTreeAtRef(cwd, ref);
-    const blueprintRoot = findBlueprintRoot(allEntries, blueprintSlug, blueprintPath);
+    const document = findBlueprintDocument(allEntries, blueprintSlug, blueprintPath);
+    const blueprintRoot = blueprintEvidenceRoot(document.path);
     // Exclude review evidence for the owning blueprint AND for every other blueprint
     // (the same global exclusion source snapshots use): recording evidence under an
     // unrelated blueprint must not invalidate an otherwise-identical delivery review.
-    const entries = allEntries.filter((entry) => !isExcludedReviewEnvelope(entry, blueprintRoot) && !isReviewEvidencePath(entry));
+    const entries = allEntries.filter((entry) => (blueprintRoot === null || !isExcludedReviewEnvelope(entry, blueprintRoot)) &&
+        !isReviewEvidencePath(entry));
     return {
         scheme: "wp-git-tree-v1",
         digest: hashTreeEntries(cwd, entries, objectFormat, DELIVERY_DOMAIN),
@@ -259,26 +312,32 @@ function neutralizePromotionGateResults(text) {
 // continuation lines). Each mirrors exactly one lifecycle writer:
 // `completed_at` (upsertCompletedAt) and the `wp blueprint start` /
 // progress-stamp fields (setBlueprintFrontmatterFields lifecycle intents).
-const PLAN_LIFECYCLE_STRIPPED_KEYS = [
+// Lifecycle writers only — the pre-tags-strip normalization (compat tier).
+const PLAN_LIFECYCLE_STRIPPED_KEYS_CORE = [
     "completed_at",
     "last_updated",
     "progress",
     "worktree_owner_id",
     "worktree_owner_branch",
 ];
+// Current plan-subject strip set: core lifecycle keys plus advisory `tags`.
+// Tags are not plan substance; MCP put and CLI serialize disagree on array-item
+// quoting (`- "x"` vs `- x`). Approvals recorded before the tags strip must
+// still verify via `preTagsStripNormalizePlanSubjectContent`.
+const PLAN_LIFECYCLE_STRIPPED_KEYS = [...PLAN_LIFECYCLE_STRIPPED_KEYS_CORE, "tags"];
 // Neutralize the lifecycle-owned frontmatter fields (`status:` value plus the
-// stripped keys above) INSIDE the leading frontmatter block only. A body line
+// stripped keys above, including advisory `tags`) INSIDE the leading frontmatter block only. A body line
 // that merely looks like one of these (e.g. task text reading
 // "completed_at: must remain unset until release") is plan substance and must
 // keep affecting the digest. Stripping removes the key line and any indented
 // continuation lines so folded (`>-`) values normalize away too.
-function neutralizeLifecycleFrontmatter(text) {
+function neutralizeLifecycleFrontmatter(text, strippedKeys = PLAN_LIFECYCLE_STRIPPED_KEYS) {
     const match = /^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/u.exec(text);
     if (!match)
         return text;
     let frontmatter = match[0];
     frontmatter = frontmatter.replace(/^(status:\s*)(['"]?)[^'"\r\n]+?(['"]?)(\s*)$/m, `$1${PLAN_STATUS_PLACEHOLDER}$4`);
-    for (const key of PLAN_LIFECYCLE_STRIPPED_KEYS) {
+    for (const key of strippedKeys) {
         frontmatter = frontmatter.replace(new RegExp(String.raw `^${key}:[^\n]*\n?(?:[ \t]+[^\n]*\n?)*`, "gmu"), "");
     }
     return `${frontmatter}${text.slice(match[0].length)}`;
@@ -410,12 +469,25 @@ export function legacyNormalizePlanSubjectContent(content) {
     text = neutralizePromotionGateResults(text);
     return Buffer.from(text, "utf8");
 }
+/**
+ * Digest-compatibility variant for review events recorded after the lifecycle
+ * stripped-key extension but before the advisory `tags` strip. Verification
+ * accepts a match against this tier so existing plan approvals on tagged
+ * blueprints are not stranded by the tags-strip rollout.
+ */
+export function preTagsStripNormalizePlanSubjectContent(content) {
+    let text = typeof content === "string" ? content : content.toString("utf8");
+    text = neutralizeLifecycleFrontmatter(text, PLAN_LIFECYCLE_STRIPPED_KEYS_CORE);
+    text = neutralizeReadinessStamps(text);
+    text = neutralizePromotionGateResults(text);
+    text = neutralizeTaskExecutionState(text);
+    return Buffer.from(text, "utf8");
+}
 function planSubjectAtRef(cwd, ref, blueprintSlug, normalize, blueprintPath) {
     const commit = resolveReviewCommit(cwd, ref);
     const entries = parseTree(cwd, commit);
-    const blueprintRoot = findBlueprintRoot(entries, blueprintSlug, blueprintPath);
-    const overviewPath = Buffer.concat([blueprintRoot, Buffer.from("_overview.md", "ascii")]);
-    const overview = entries.find((entry) => entry.path.equals(overviewPath));
+    const overview = findBlueprintDocument(entries, blueprintSlug, blueprintPath);
+    const overviewPath = overview.path;
     if (!overview || overview.type !== "blob") {
         throw new Error("Tracked blueprint overview is not a blob.");
     }
@@ -439,6 +511,24 @@ export function createPlanSubjectAtRef(cwd, ref, blueprintSlug, blueprintPath) {
 export function createLegacyPlanSubjectAtRef(cwd, ref, blueprintSlug, blueprintPath) {
     return planSubjectAtRef(cwd, ref, blueprintSlug, legacyNormalizePlanSubjectContent, blueprintPath);
 }
+/** Plan subject digested without the advisory `tags` strip (pre-tags-strip tier). */
+export function createPreTagsStripPlanSubjectAtRef(cwd, ref, blueprintSlug, blueprintPath) {
+    return planSubjectAtRef(cwd, ref, blueprintSlug, preTagsStripNormalizePlanSubjectContent, blueprintPath);
+}
+/** Working-ledger digest for the pre-tags-strip compatibility tier. */
+export function createPreTagsStripPlanSubjectDigestForContent(blueprintSlug, content) {
+    const hash = createHash("sha256").update(PLAN_DOMAIN);
+    updateField(hash, blueprintSlug);
+    updateField(hash, preTagsStripNormalizePlanSubjectContent(content));
+    return hash.digest("hex");
+}
+/** Working-ledger digest for the pre-extension legacy compatibility tier. */
+export function createLegacyPlanSubjectDigestForContent(blueprintSlug, content) {
+    const hash = createHash("sha256").update(PLAN_DOMAIN);
+    updateField(hash, blueprintSlug);
+    updateField(hash, legacyNormalizePlanSubjectContent(content));
+    return hash.digest("hex");
+}
 export const reviewSubjectInternals = {
     isExcludedReviewEnvelope,
     isReviewEvidencePath,

package/dist/esm/runtime/opencode-account-materializer.d.ts

@@ -0,0 +1,34 @@
+import { type OpencodeAccount } from "#review/opencode-account.js";
+import { resolveRuntimeEnvironment } from "./executor.js";
+export type OpencodeAccountsResolution = {
+    readonly ok: true;
+    readonly accounts: readonly OpencodeAccount[];
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+export interface ResolveOpencodeAccountsGracefullyInput {
+    readonly cwd: string;
+    /**
+     * Secret profile to resolve through — REQUIRED, never optional.
+     *
+     * Without it `resolveRuntimeEnvironment` passes no environment selector and
+     * the secret manager falls back to its own ambient, path-keyed config
+     * (Doppler's per-directory scopes, Infisical's discovered `.infisical.json`).
+     * That resolves only in a checkout that happens to sit under the scoped path,
+     * so discovery silently yields zero accounts in every managed worktree, CI
+     * clone, and fresh checkout — a failure mode that is invisible because callers
+     * degrade gracefully. Keeping this required makes that class of bug a compile
+     * error instead of a silent runtime degradation. Callers pass
+     * `resolveAgentSecretProfile(env)`.
+     */
+    readonly secretProfile: string;
+    readonly resolveRuntimeEnvironment?: typeof resolveRuntimeEnvironment;
+}
+/**
+ * Resolve `OPENCODE_GO_KEY_*` secrets into accounts without ever throwing.
+ * On any resolution failure (missing profile, secret-manager error, empty
+ * result), returns a failure reason derived only from the error's own
+ * message/type — never from a secret value.
+ */
+export declare function resolveOpencodeAccountsGracefully(input: ResolveOpencodeAccountsGracefullyInput): OpencodeAccountsResolution;

package/dist/esm/runtime/opencode-account-materializer.js

@@ -0,0 +1,33 @@
+import { resolveOpencodeAccounts } from "#review/opencode-account.js";
+import { resolveRuntimeEnvironment } from "./executor.js";
+function describeError(error) {
+    if (error instanceof Error)
+        return `${error.name}: ${error.message}`;
+    return typeof error === "string" ? error : "unknown error";
+}
+/**
+ * Resolve `OPENCODE_GO_KEY_*` secrets into accounts without ever throwing.
+ * On any resolution failure (missing profile, secret-manager error, empty
+ * result), returns a failure reason derived only from the error's own
+ * message/type — never from a secret value.
+ */
+export function resolveOpencodeAccountsGracefully(input) {
+    const resolveEnv = input.resolveRuntimeEnvironment ?? resolveRuntimeEnvironment;
+    let secrets;
+    try {
+        secrets = resolveEnv({
+            cwd: input.cwd,
+            profile: "secrets-only",
+            secretProfile: input.secretProfile,
+            environment: input.secretProfile,
+        });
+    }
+    catch (error) {
+        return { ok: false, reason: describeError(error) };
+    }
+    const accounts = resolveOpencodeAccounts(secrets);
+    if (accounts.length === 0) {
+        return { ok: false, reason: "no OPENCODE_GO_KEY_* secrets found" };
+    }
+    return { ok: true, accounts };
+}

package/dist/esm/rust/affected-manifests.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Maps changed repo paths to the tracked Rust crate(s) they belong to.
+ *
+ * Pure and dependency-free so it is unit-testable without shelling out to
+ * `cargo` or `git` — see `#cli/commands/rust-check.js` for the CLI command
+ * that spawns `cargo check`/`cargo test` for whatever this resolves.
+ */
+export interface TrackedRustCrate {
+    /** Crate directory relative to the repo root, e.g. "native/dash-tui". */
+    readonly root: string;
+    /** Manifest path relative to the repo root. */
+    readonly manifest: string;
+    /** `cargo` args (after `cargo`) that prove this crate's tests still pass. */
+    readonly testArgs: readonly string[];
+}
+/**
+ * The Rust crates `wp ci-preflight` proves compile + pass on an affected
+ * change. Mirrors exactly what `.github/workflows/ci.agent-kit.yml` (native
+ * session-memory + dash-tui jobs) and `.github/workflows/desktop-perf.yml`
+ * (desktop `src-tauri`) already build and test in CI — no new cargo
+ * invocation shape is invented here.
+ *
+ * Deliberately EXCLUDES the `spikes/**` crates (`spikes/pty-spawn-transport/
+ * rust`, `spikes/desktop-pty-loadtest/rust`,
+ * `spikes/desktop-pty-loadtest/src-tauri`): no CI workflow builds or tests
+ * them today — they are scratch/prototype crates with no compile guarantee.
+ * Gating pre-push on them would fail closed on code nobody has ever promised
+ * compiles. Revisit this list if a spike graduates to a tracked crate.
+ */
+export declare const TRACKED_RUST_CRATES: readonly TrackedRustCrate[];
+/**
+ * Returns the sorted, deduped list of tracked-crate manifest paths touched by
+ * `files`. Rust files under an untracked crate (e.g. `spikes/**`) or outside
+ * any crate are ignored, not escalated to "affects everything" — each
+ * manifest maps back to `TRACKED_RUST_CRATES` for its `testArgs`.
+ */
+export declare function resolveAffectedRustManifests(files: readonly string[]): readonly string[];
+export declare function trackedCrateForManifest(manifest: string): TrackedRustCrate | undefined;

package/dist/esm/rust/affected-manifests.js

@@ -0,0 +1,69 @@
+/**
+ * Maps changed repo paths to the tracked Rust crate(s) they belong to.
+ *
+ * Pure and dependency-free so it is unit-testable without shelling out to
+ * `cargo` or `git` — see `#cli/commands/rust-check.js` for the CLI command
+ * that spawns `cargo check`/`cargo test` for whatever this resolves.
+ */
+/**
+ * The Rust crates `wp ci-preflight` proves compile + pass on an affected
+ * change. Mirrors exactly what `.github/workflows/ci.agent-kit.yml` (native
+ * session-memory + dash-tui jobs) and `.github/workflows/desktop-perf.yml`
+ * (desktop `src-tauri`) already build and test in CI — no new cargo
+ * invocation shape is invented here.
+ *
+ * Deliberately EXCLUDES the `spikes/**` crates (`spikes/pty-spawn-transport/
+ * rust`, `spikes/desktop-pty-loadtest/rust`,
+ * `spikes/desktop-pty-loadtest/src-tauri`): no CI workflow builds or tests
+ * them today — they are scratch/prototype crates with no compile guarantee.
+ * Gating pre-push on them would fail closed on code nobody has ever promised
+ * compiles. Revisit this list if a spike graduates to a tracked crate.
+ */
+export const TRACKED_RUST_CRATES = [
+    {
+        root: "native/session-memory-engine",
+        manifest: "native/session-memory-engine/Cargo.toml",
+        testArgs: ["test", "--manifest-path", "native/session-memory-engine/Cargo.toml", "--all"],
+    },
+    {
+        root: "native/dash-tui",
+        manifest: "native/dash-tui/Cargo.toml",
+        testArgs: ["test", "--manifest-path", "native/dash-tui/Cargo.toml"],
+    },
+    {
+        root: "apps/desktop/src-tauri",
+        manifest: "apps/desktop/src-tauri/Cargo.toml",
+        testArgs: ["test", "--manifest-path", "apps/desktop/src-tauri/Cargo.toml", "--lib"],
+    },
+];
+function isRustSignalFile(file) {
+    return (file.endsWith(".rs") ||
+        file === "Cargo.toml" ||
+        file.endsWith("/Cargo.toml") ||
+        file === "Cargo.lock" ||
+        file.endsWith("/Cargo.lock"));
+}
+function owningTrackedCrate(file) {
+    return TRACKED_RUST_CRATES.find((candidate) => file === candidate.root || file.startsWith(`${candidate.root}/`));
+}
+/**
+ * Returns the sorted, deduped list of tracked-crate manifest paths touched by
+ * `files`. Rust files under an untracked crate (e.g. `spikes/**`) or outside
+ * any crate are ignored, not escalated to "affects everything" — each
+ * manifest maps back to `TRACKED_RUST_CRATES` for its `testArgs`.
+ */
+export function resolveAffectedRustManifests(files) {
+    const manifests = new Set();
+    for (const rawFile of files) {
+        const file = rawFile.replaceAll("\\", "/");
+        if (!isRustSignalFile(file))
+            continue;
+        const crate = owningTrackedCrate(file);
+        if (crate)
+            manifests.add(crate.manifest);
+    }
+    return [...manifests].sort();
+}
+export function trackedCrateForManifest(manifest) {
+    return TRACKED_RUST_CRATES.find((candidate) => candidate.manifest === manifest);
+}

package/dist/esm/session-memory/fetch-index.d.ts

@@ -20,7 +20,7 @@ export interface FetchAndIndexOptions {
     signal?: AbortSignal;
 }
 export declare function fetchAndIndex(options: FetchAndIndexOptions, deps?: {
-    readonly fetchImpl?: typeof fetch;
+    readonly fetchImpl?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
     /** Internal/test-only escape hatch for loopback fixtures; never exposed in CLI/MCP input. */
     readonly allowedHosts?: readonly string[];
 }): Promise<SessionMemoryChunk[]>;