@webpresso/agent-kit 3.1.28 → 3.2.0

package/dist/esm/cli/commands/quality-log-store.js

@@ -1,7 +1,7 @@
-import { randomUUID } from "node:crypto";
-import { closeSync, createWriteStream, mkdirSync, openSync, readdirSync, readFileSync, statSync, renameSync, utimesSync, rmSync, writeFileSync, } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { createWriteStream, mkdirSync, openSync, readdirSync, readFileSync, statSync, renameSync, utimesSync, rmSync, writeFileSync, } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { getSurfacePath } from "#paths/state-root.js";
 import { readTrustedJsonFile } from "#shared-utils/read-json-file.js";
 import { shortId } from "#shared-utils/short-id.js";
@@ -16,6 +16,7 @@ export const CLI_LOG_COMMANDS = [
     "format",
 ];
 const ORPHAN_LOG_GRACE_MS = 60_000;
+const INDEX_LOCK_STALE_MS = 5_000;
 export function isCliLogCommandName(value) {
     return CLI_LOG_COMMANDS.includes(value);
 }
@@ -63,39 +64,39 @@ function openCliLogSink(commandDir, command, cwd) {
             stream.write(chunk);
         },
         async finalize(metadata) {
-            await new Promise((resolve, reject) => {
-                if (streamError) {
-                    reject(streamError);
-                    return;
-                }
-                rejectPendingFinalize = reject;
-                stream.end(() => {
-                    rejectPendingFinalize = undefined;
+            try {
+                await new Promise((resolve, reject) => {
                     if (streamError) {
                         reject(streamError);
                         return;
                     }
-                    resolve();
+                    rejectPendingFinalize = reject;
+                    stream.end(() => {
+                        rejectPendingFinalize = undefined;
+                        if (streamError) {
+                            reject(streamError);
+                            return;
+                        }
+                        resolve();
+                    });
                 });
-            });
-            const entry = {
-                id,
-                command,
-                timestamp: metadata.timestamp ?? new Date().toISOString(),
-                exitCode: metadata.exitCode,
-                logPath: absoluteLogPath,
-                ...(metadata.options ? { options: metadata.options } : {}),
-                ...(metadata.summary ? { summary: metadata.summary } : {}),
-            };
-            try {
+                const entry = {
+                    id,
+                    command,
+                    timestamp: metadata.timestamp ?? new Date().toISOString(),
+                    exitCode: metadata.exitCode,
+                    logPath: absoluteLogPath,
+                    ...(metadata.options ? { options: metadata.options } : {}),
+                    ...(metadata.summary ? { summary: metadata.summary } : {}),
+                };
                 markLogRecentlyFinalized(absoluteLogPath);
                 // Index/lock live next to the log file so fallback dirs stay consistent.
                 writeLogEntryInDir(entry, commandDir);
+                return entry;
             }
             finally {
                 rmSync(activeMarkerPath, { force: true });
             }
-            return entry;
         },
     };
 }
@@ -113,7 +114,7 @@ export function createCliLogSink(command, cwd = process.cwd()) {
     catch (error) {
         if (!isUnwritableFsError(error))
             throw error;
-        const fallbackDir = join(tmpdir(), "webpresso", "cli-logs", command);
+        const fallbackDir = getFallbackCommandLogDir(command, cwd);
         const code = typeof error === "object" && error !== null && "code" in error
             ? String(error.code)
             : "unknown";
@@ -122,13 +123,37 @@ export function createCliLogSink(command, cwd = process.cwd()) {
     }
 }
 export function readCliLogEntries(command, cwd = process.cwd()) {
-    const indexPath = getCommandIndexPath(command, cwd);
+    const entries = [
+        ...readCliLogEntriesFromCommandDir(command, getCommandLogDir(command, cwd)),
+        ...readCliLogEntriesFromCommandDir(command, getFallbackCommandLogDir(command, cwd)),
+    ];
+    const byLogPath = new Map();
+    for (const entry of entries) {
+        byLogPath.set(entry.logPath, entry);
+    }
+    return [...byLogPath.values()]
+        .sort((a, b) => {
+        if (a.active === true && b.active !== true)
+            return -1;
+        if (b.active === true && a.active !== true)
+            return 1;
+        return b.timestamp.localeCompare(a.timestamp);
+    })
+        .slice(0, 10);
+}
+function readCliLogEntriesFromCommandDir(command, commandDir) {
+    const activeEntries = readActiveCliLogEntriesFromDir(command, commandDir);
+    const indexPath = join(commandDir, "index.json");
     try {
         const parsed = readTrustedJsonFile(indexPath);
-        return Array.isArray(parsed.entries) ? parsed.entries : [];
+        const finalizedEntries = Array.isArray(parsed.entries) ? parsed.entries : [];
+        return [
+            ...activeEntries,
+            ...finalizedEntries.filter((entry) => !activeEntries.some((active) => active.id === entry.id)),
+        ].slice(0, 10);
     }
     catch {
-        return [];
+        return activeEntries;
     }
 }
 export function readCliLogEntry(command, ordinal = 1, cwd = process.cwd()) {
@@ -146,6 +171,45 @@ function readCliLogEntriesFromDir(commandDir) {
         return [];
     }
 }
+function readActiveCliLogEntriesFromDir(command, commandDir) {
+    let files;
+    try {
+        files = readdirSync(commandDir);
+    }
+    catch {
+        return [];
+    }
+    return files
+        .filter((file) => file.endsWith(".log.active"))
+        .map((file) => readActiveCliLogEntryFromMarker(command, join(commandDir, file)))
+        .filter((entry) => entry !== null)
+        .sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+}
+function readActiveCliLogEntryFromMarker(command, markerPath) {
+    try {
+        const markerStat = statSync(markerPath);
+        const marker = readFileSync(markerPath, "utf8");
+        const id = basename(markerPath).slice(0, -".log.active".length);
+        if (!id)
+            return null;
+        const markerLines = marker.split("\n");
+        const live = isActiveMarkerSnapshotLive(marker, markerStat.mtimeMs);
+        return {
+            id,
+            command,
+            timestamp: markerLines[1]?.trim() || new Date(markerStat.mtimeMs).toISOString(),
+            exitCode: -1,
+            logPath: markerPath.slice(0, -".active".length),
+            ...(live ? { active: true } : {}),
+            summary: live ? "active log" : "orphaned log from exited process",
+        };
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return null;
+        throw error;
+    }
+}
 function writeLogEntryInDir(entry, commandDir) {
     withCommandIndexLockInDir(commandDir, () => {
         const indexPath = join(commandDir, "index.json");
@@ -169,28 +233,86 @@ function writeLogEntryInDir(entry, commandDir) {
 }
 function withCommandIndexLockInDir(commandDir, fn) {
     mkdirSync(commandDir, { recursive: true });
-    const lockPath = join(commandDir, "index.lock");
+    const lockDir = join(commandDir, "index.lock.d");
+    mkdirSync(lockDir, { recursive: true });
+    const ownerPath = join(lockDir, `${Date.now()}-${process.pid}-${randomUUID()}.owner`);
+    writeFileSync(ownerPath, `${process.pid}\n${new Date().toISOString()}\n`, {
+        encoding: "utf8",
+        flag: "wx",
+    });
     const started = Date.now();
-    let fd;
-    while (fd === undefined) {
-        try {
-            fd = openSync(lockPath, "wx");
-        }
-        catch (error) {
-            if (!isFileExistsError(error))
-                throw error;
-            if (Date.now() - started > 5_000) {
-                throw new Error(`Timed out waiting for CLI log index lock: ${lockPath}`);
+    try {
+        while (!isCurrentIndexLockOwner(lockDir, ownerPath)) {
+            if (Date.now() - started > INDEX_LOCK_STALE_MS) {
+                throw new Error(`Timed out waiting for CLI log index lock: ${lockDir}`);
             }
             sleepSync(10);
         }
-    }
-    try {
         return fn();
     }
     finally {
-        closeSync(fd);
-        rmSync(lockPath, { force: true });
+        rmSync(ownerPath, { force: true });
+    }
+}
+function isCurrentIndexLockOwner(lockDir, ownerPath) {
+    const liveOwners = readLiveIndexLockOwners(lockDir);
+    const firstOwner = liveOwners[0];
+    if (firstOwner === undefined)
+        return false;
+    return firstOwner.path === ownerPath;
+}
+function readLiveIndexLockOwners(lockDir) {
+    let files;
+    try {
+        files = readdirSync(lockDir);
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return [];
+        throw error;
+    }
+    return files
+        .filter((file) => file.endsWith(".owner"))
+        .map((file) => readIndexLockOwner(join(lockDir, file)))
+        .filter((owner) => owner !== null)
+        .sort((a, b) => a.timestampMs - b.timestampMs || a.path.localeCompare(b.path));
+}
+function readIndexLockOwner(ownerPath) {
+    let marker = "";
+    let markerMtimeMs = 0;
+    try {
+        const markerStat = statSync(ownerPath);
+        markerMtimeMs = markerStat.mtimeMs;
+        marker = readFileSync(ownerPath, "utf8");
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return null;
+        throw error;
+    }
+    const markerLines = marker.split("\n");
+    const pid = Number(markerLines[0]);
+    const hasOwner = Number.isInteger(pid) && pid > 0;
+    const timestamp = Date.parse(markerLines[1] ?? "");
+    const timestampMs = Number.isFinite(timestamp) ? timestamp : markerMtimeMs;
+    const stale = (hasOwner && !isProcessLive(pid)) ||
+        (!hasOwner && Date.now() - markerMtimeMs > INDEX_LOCK_STALE_MS);
+    if (stale) {
+        rmSync(ownerPath, { force: true });
+        return null;
+    }
+    return { path: ownerPath, timestampMs };
+}
+function isProcessLive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error) {
+            return error.code === "EPERM";
+        }
+        return false;
     }
 }
 function writeIndexAtomically(indexPath, index) {
@@ -233,31 +355,45 @@ function canPruneLogPath(logPath) {
     }
 }
 function isActiveLogPath(logPath) {
+    const activeMarkerPath = getActiveMarkerPath(logPath);
     try {
-        readFileSync(getActiveMarkerPath(logPath), "utf8");
-        return true;
+        const markerStat = statSync(activeMarkerPath);
+        const marker = readFileSync(activeMarkerPath, "utf8");
+        const live = isActiveMarkerSnapshotLive(marker, markerStat.mtimeMs);
+        if (!live)
+            rmSync(activeMarkerPath, { force: true });
+        return live;
     }
-    catch {
+    catch (error) {
+        if (!isMissingFileError(error))
+            throw error;
         return false;
     }
 }
+function isActiveMarkerSnapshotLive(marker, markerMtimeMs) {
+    const pid = Number(marker.split("\n")[0]);
+    if (Number.isInteger(pid) && pid > 0) {
+        return isProcessLive(pid);
+    }
+    return Date.now() - markerMtimeMs <= ORPHAN_LOG_GRACE_MS;
+}
 function getActiveMarkerPath(logPath) {
     return `${logPath}.active`;
 }
 function sleepSync(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
-function isFileExistsError(error) {
-    return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
-}
 function isMissingFileError(error) {
     return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function getCommandLogDir(command, cwd) {
     return getSurfacePath(join("cli-logs", command), "repo", cwd);
 }
-function getCommandIndexPath(command, cwd) {
-    return join(getCommandLogDir(command, cwd), "index.json");
+function getFallbackCommandLogDir(command, cwd) {
+    return join(tmpdir(), "webpresso", "cli-logs", fallbackScopeId(cwd), command);
+}
+function fallbackScopeId(cwd) {
+    return createHash("sha256").update(resolve(cwd)).digest("hex").slice(0, 12);
 }
 function createLogId(now = new Date()) {
     const iso = now.toISOString().replaceAll(":", "-").replaceAll(".", "-");

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

@@ -2,8 +2,11 @@ import type { CAC } from "cac";
 import { runReviewExecution, type ReviewEffort, type ReviewLimitWindow, type ReviewProvider, type ReviewRunSummary, type ReviewStage } from "#review/execution/index.js";
 import { createReviewTargetCheckout, type ReviewTargetCheckout } from "#review/execution/review-checkout.js";
 import { type ReviewProcessRecord } from "#review/execution/process-registry.js";
+import { type OpencodeAccount } from "#review/opencode-account.js";
+import { resolveOpencodeAccountsGracefully } from "#runtime/opencode-account-materializer.js";
 import { evaluateApprovalGate } from "#lifecycle/audit";
 import { type ReviewEvent } from "#review/events.js";
+import { type ReviewGateVerification } from "#review/delivery-verifier.js";
 import { runCommand } from "#mcp/tools/_shared/run-command.js";
 export type ReviewVerdict = "approve" | "approve-with-nits" | "reject" | "no-verdict";
 export type ReviewStatus = "complete" | "timed-out" | "incomplete" | "unavailable" | "failed";
@@ -77,6 +80,8 @@ export interface ReviewCommandOptions {
     artifactRoot?: string;
     idleSeconds?: string;
     maxProgressEvents?: string;
+    reason?: string;
+    confirm?: boolean;
 }
 interface ReviewGateAttempt {
     readonly provider: ReviewProvider;
@@ -90,6 +95,7 @@ interface ReviewGateAttempt {
     readonly verdict: ReviewVerdict;
     readonly terminalClassification: string;
     readonly failureCode?: string;
+    readonly providerErrorDetail?: string;
     readonly limitWindow?: ReviewLimitWindow;
     readonly retryAfterMs?: number;
     readonly artifact?: string;
@@ -105,7 +111,7 @@ interface ReviewGateResult {
     readonly targetSha: string;
     readonly baseSha: string;
     readonly promptHash: string;
-    readonly status: "approved" | "needs-review" | "rejected" | "recorded-untracked";
+    readonly status: "approved" | "needs-review" | "rejected" | "scope-exhausted" | "recorded-untracked" | "verification-failed";
     readonly approvalGate: ReturnType<typeof evaluateApprovalGate>;
     readonly statePath: string;
     readonly attempts: readonly ReviewGateAttempt[];
@@ -123,6 +129,7 @@ interface ReviewGateResult {
         readonly rev?: string;
     }[];
     readonly issues?: readonly string[];
+    readonly verification?: ReviewGateVerification;
     readonly message: string;
 }
 interface ReviewLedger {
@@ -164,6 +171,22 @@ export declare function runReviewRunCommand(projectRoot: string, options: Review
 export declare function readReviewLedger(projectRoot: string, slug: string): Promise<ReviewLedger>;
 export declare function logReviewEntry(projectRoot: string, slug: string, input: ReviewCommandOptions): Promise<ReviewEntry>;
 export declare function logReviewEvent(projectRoot: string, slug: string, input: ReviewCommandOptions): Promise<ReviewEvent>;
+/**
+ * `wp review override` — the gated, auditable human escape hatch for the
+ * promotion approval gate. It records a `maintainer-override` approval that
+ * satisfies the gate distinctly (never as a strong/OpenCode-Go approval).
+ *
+ * Trust properties:
+ * - REFUSES unless a formal strong-reviewer gate has already REJECTED the exact
+ *   current subject (precondition + target binding are the same lookup).
+ * - Requires an explicit `--reason` and `--confirm` — no accidental invocation.
+ * - Reviewer id `maintainer-override` is not in the `wp review log` reviewer
+ *   enum, so neither `wp review log` nor `wp_blueprint_review_log` can mint it;
+ *   this command is the only writer. The read-time policy in
+ *   `#review/events` treats it as human-like, so its manual-stage record is a
+ *   legitimate governance approval rather than a disguised machine approval.
+ */
+export declare function runReviewOverride(projectRoot: string, slug: string, input: ReviewCommandOptions): Promise<ReviewEvent>;
 export declare function classifyProviderOutput(output: string): Pick<ReviewGateAttempt, "status" | "verdict" | "terminalClassification">;
 export declare function reviewerFamily(model: string): ReviewReviewerId;
 type GateProviderResultStage = ReviewStage | "approval-gate";
@@ -176,18 +199,26 @@ export declare function invokeProvider(input: {
     readonly provider: ReviewProvider;
     readonly targetSha: string;
     readonly signal?: AbortSignal;
-}, executeReview?: typeof runReviewExecution, runCatalogCommand?: typeof runCommand, createTargetCheckout?: typeof createReviewTargetCheckout, existingCheckout?: ReviewTargetCheckout): Promise<{
+    readonly authDataDir?: string;
+}, executeReview?: typeof runReviewExecution, runCatalogCommand?: typeof runCommand, createTargetCheckout?: typeof createReviewTargetCheckout, getSharedCheckout?: () => ReviewTargetCheckout | undefined): Promise<{
     output: string;
     model: string;
     reviewer: string;
     stage?: GateProviderResultStage;
-} & Pick<ReviewGateAttempt, "status" | "verdict" | "terminalClassification" | "failureCode" | "limitWindow" | "retryAfterMs">>;
+} & Pick<ReviewGateAttempt, "status" | "verdict" | "terminalClassification" | "failureCode" | "providerErrorDetail" | "limitWindow" | "retryAfterMs">>;
 export interface ReviewGateDependencies {
     readonly createTargetCheckout?: typeof createReviewTargetCheckout;
     readonly invokeProvider?: typeof invokeProvider;
     readonly runCatalogCommand?: typeof runCommand;
     readonly runReviewExecution?: typeof runReviewExecution;
     readonly signal?: AbortSignal;
+    /** Test seam: resolve opencode-go accounts from the secret provider. */
+    readonly resolveOpencodeAccounts?: typeof resolveOpencodeAccountsGracefully;
+    /**
+     * Test seam: materialize an account's isolated auth store and return the
+     * `XDG_DATA_HOME` directory to inject for that account's spawns.
+     */
+    readonly prepareOpencodeCredential?: (account: OpencodeAccount) => string;
 }
 /**
  * Sanctioned fallback when `wp review gate` does not reach "approved" — points
@@ -198,6 +229,7 @@ export interface ReviewGateDependencies {
 export declare function reviewGateNonConvergenceHint(slug: string, context?: {
     readonly gateId?: string;
     readonly failureCode?: string;
+    readonly status?: ReviewGateResult["status"];
 }): string;
 export declare function runReviewGate(projectRoot: string, slug: string, input: ReviewCommandOptions, dependencies?: ReviewGateDependencies): Promise<ReviewGateResult>;
 export declare function buildReviewScoreboard(entries: readonly ReviewEntry[]): readonly ReviewScoreboardRow[];