@loucompanion/forge-bridge 0.1.3-dev.fbe15023cdfe → 0.1.4-dev.1ff37038366e

package/dist/session/provider-cli/provider-cli.artifacts.js

@@ -4,6 +4,8 @@ import { artifactRootFor, artifactRootForOwner, debugCompletionPhaseOrder, draft
 import { ensureNoSymbolicLinkPathSegments, isPathUnderRoot, sha256File } from "../qa-sidecar-validation.js";
 import { hasLaunchTarget } from "./provider-cli.qa-sidecars.js";
 import { clip, isNodeError, messageFromError, normalizedString, parseJsonLine, stringField } from "./provider-output-state.js";
+const maxTransportedQaSidecarBytes = 8 * 1024 * 1024;
+const maxTransportedQaSidecarsTotalBytes = 16 * 1024 * 1024;
 const developCyclePhaseOrder = ["implementation", "self_review", "validation"];
 const nonPublishableWorktreePaths = [".forge", ".local"];
 export async function emitDraftGateArtifacts(emit, worktreePath, workItemId) {
@@ -146,23 +148,23 @@ export async function cleanupCompletionTools(completionTools, emit) {
         }).catch(() => undefined);
     }
 }
-export async function commitWorktreeChanges(git, worktreePath, workItemId) {
+export async function commitWorktreeChanges(git, worktreePath, workItemId, alreadyStagedChangedFiles) {
+    const changedFiles = alreadyStagedChangedFiles ?? await stagePublishableWorktreeChanges(git, worktreePath);
+    if (changedFiles.length > 0) {
+        await git.run(worktreePath, ["commit", "-m", `provider cli changeset for ${workItemId.slice(0, 8)}`]);
+    }
+    const commitSha = (await git.run(worktreePath, ["rev-parse", "HEAD"])).trim();
+    return { commitSha, changedFiles };
+}
+export async function stagePublishableWorktreeChanges(git, worktreePath) {
     await git.run(worktreePath, ["add", "-A"]);
     for (const reservedPath of nonPublishableWorktreePaths) {
         await git.run(worktreePath, ["reset", "--", reservedPath]).catch(() => "");
     }
-    const changedFiles = (await git.run(worktreePath, ["diff", "--cached", "--name-only"]))
+    return (await git.run(worktreePath, ["diff", "--cached", "--name-only"]))
         .split(/\r?\n/)
         .map((line) => line.trim())
         .filter(Boolean);
-    if (changedFiles.length > 0) {
-        await git.run(worktreePath, ["commit", "-m", `provider cli changeset for ${workItemId.slice(0, 8)}`]);
-    }
-    else {
-        await git.run(worktreePath, ["commit", "--allow-empty", "-m", `provider cli completed for ${workItemId.slice(0, 8)}`]);
-    }
-    const commitSha = (await git.run(worktreePath, ["rev-parse", "HEAD"])).trim();
-    return { commitSha, changedFiles };
 }
 export function phaseCompleteEventType(phase) {
     return phase === "implementation" ? "implementation_complete" : `${phase}_complete`;
@@ -212,12 +214,13 @@ export async function readQaCompletionArtifactBundle(worktreePath, workItemId, o
     const planJson = await fs.readFile(path.join(artifactRoot, qaArtifactFileNames.plan), "utf8");
     const evidenceJson = await fs.readFile(path.join(artifactRoot, qaArtifactFileNames.evidence), "utf8");
     const findingsJson = await fs.readFile(path.join(artifactRoot, qaArtifactFileNames.findings), "utf8");
-    await validateQaBundleSidecarReferences(worktreePath, workItemId, ownerType, ownerId);
+    const sidecars = await readQaBundleSidecars(worktreePath, workItemId, ownerType, ownerId);
     return {
         ...artifact,
         planJson,
         evidenceJson,
-        findingsJson
+        findingsJson,
+        sidecars
     };
 }
 export async function hasCompleteQaArtifactBundle(worktreePath, workItemId, ownerType, ownerId) {
@@ -274,15 +277,21 @@ function hasPassingRepositoryPlaywrightEvidence(evidence) {
     });
 }
 export async function validateQaBundleSidecarReferences(worktreePath, workItemId, ownerType, ownerId) {
+    await readQaBundleSidecars(worktreePath, workItemId, ownerType, ownerId);
+}
+export async function readQaBundleSidecars(worktreePath, workItemId, ownerType, ownerId) {
     const artifactRoot = ownerType && ownerId
         ? artifactRootForOwner(worktreePath, ownerType, ownerId)
         : artifactRootFor(worktreePath, workItemId);
     const evidence = await readJsonObjectFile(path.join(artifactRoot, qaArtifactFileNames.evidence));
     const sidecars = arrayField(evidence, "sidecars");
     if (sidecars.length === 0) {
-        return;
+        return [];
     }
     const qaSidecarRoot = path.resolve(artifactRoot, "qa");
+    const transported = [];
+    const transportedByPath = new Map();
+    let totalBytes = 0;
     for (const [index, sidecar] of sidecars.entries()) {
         const sidecarPath = stringField(sidecar, "path");
         const expectedHash = stringField(sidecar, "content_hash");
@@ -312,11 +321,36 @@ export async function validateQaBundleSidecarReferences(worktreePath, workItemId
         if (stat.size !== expectedBytes) {
             throw new Error(`QA sidecar ${index} bytes do not match the referenced file.`);
         }
+        if (stat.size > maxTransportedQaSidecarBytes) {
+            throw new Error(`QA sidecar ${index} exceeds the ${maxTransportedQaSidecarBytes}-byte transport limit.`);
+        }
         const actualHash = await sha256File(fullPath);
         if (actualHash !== expectedHash.trim().toLowerCase()) {
             throw new Error(`QA sidecar ${index} content_hash does not match the referenced file.`);
         }
+        const canonicalPath = path.relative(worktreePath, fullPath).split(path.sep).join("/");
+        const duplicateKey = canonicalPath.toLowerCase();
+        const existing = transportedByPath.get(duplicateKey);
+        if (existing) {
+            if (existing.contentHash !== actualHash || existing.bytes !== stat.size) {
+                throw new Error(`QA sidecar ${index} conflicts with another payload for ${canonicalPath}.`);
+            }
+            continue;
+        }
+        totalBytes += stat.size;
+        if (totalBytes > maxTransportedQaSidecarsTotalBytes) {
+            throw new Error(`QA sidecars exceed the ${maxTransportedQaSidecarsTotalBytes}-byte total transport limit.`);
+        }
+        const content = await fs.readFile(fullPath);
+        transportedByPath.set(duplicateKey, { contentHash: actualHash, bytes: stat.size });
+        transported.push({
+            path: canonicalPath,
+            contentBase64: content.toString("base64"),
+            contentHash: actualHash,
+            bytes: stat.size
+        });
     }
+    return transported;
 }
 export async function emitQaStructuredEvents(emit, artifact) {
     const artifactRoot = path.dirname(artifact.path);

package/dist/session/provider-cli/provider-cli.deterministic.js

@@ -3,12 +3,13 @@ import path from "node:path";
 import { GitClient } from "../../shared/git/git.js";
 import { buildSpecBody, selectLaneCommand } from "../../worktree/artifact-injector.js";
 import { completionPhaseFromDispatch, debugCompletionPhaseOrder, expectedCompletionToolName, expectedDebugCompletionToolName, expectedQaCompletionToolName, qaCompletionGateOrder, readCompletionArtifact, usesDebugCycleCompletion, usesDevelopCycleCompletion, writeCompletionArtifact } from "../phase-completion.js";
-import { emitArchitectStructuredEvents, emitCompletionArtifactRecorded, emitQaArtifactRecorded, emitQaGateAccepted, emitQaStructuredEvents, isDebugCompletionPhaseForProvider, nextQaGate, phaseCompleteEventType, qaArtifactRootForDispatch, readQaCompletionArtifactBundle, readQaGateArtifact } from "./provider-cli.artifacts.js";
+import { commitWorktreeChanges, emitArchitectStructuredEvents, emitCompletionArtifactRecorded, emitQaArtifactRecorded, emitQaGateAccepted, emitQaStructuredEvents, isDebugCompletionPhaseForProvider, nextQaGate, phaseCompleteEventType, qaArtifactRootForDispatch, readQaCompletionArtifactBundle, readQaGateArtifact } from "./provider-cli.artifacts.js";
 import { deterministicBrowserCheck, deterministicBrowserSidecar, hasLaunchTarget, writeQaSidecarFiles } from "./provider-cli.qa-sidecars.js";
 import { buildProviderCliCommand, formatProviderCliCommand, isPullRequestCheckRepairDispatch, isPullRequestCommentsDispatch, singleLine } from "./provider-cli.prompts.js";
 import { estimatedDeterministicUsage, exactRedactionSecrets } from "./provider-cli.runtime.js";
 import { buildProviderUsageEvent } from "./provider-usage.js";
 import { writeCiRepairReadinessManifest } from "./ci-repair-readiness.js";
+import { assertRepairHeadEpoch } from "./provider-cli.repair-epoch.js";
 import { deterministicArchitectPayload, deterministicCompletionPayload, deterministicQaGatePayload } from "./provider-cli.deterministic-payloads.js";
 export class DeterministicProviderCliService {
     git;
@@ -211,6 +212,7 @@ export class DeterministicProviderCliService {
     }
     async runPullRequestRepair(context, route) {
         const { dispatch, worktree } = context;
+        await assertRepairHeadEpoch(context, this.git);
         const repairChecks = route === "ci_repair" || isPullRequestCheckRepairDispatch(dispatch);
         const addressComments = isPullRequestCommentsDispatch(dispatch);
         let repairArtifact = null;
@@ -238,7 +240,37 @@ export class DeterministicProviderCliService {
                 throw new Error(`Deterministic CI repair did not produce ${reference.path}.`);
             await emitCompletionArtifactRecorded(context.emit, worktree.worktreePath, repairArtifact);
         }
-        await this.git.run(worktree.worktreePath, ["commit", "--allow-empty", "-m", `forge bridge ${repairChecks ? "ci repair" : addressComments ? "pr comments" : "conflict resolve"} for ${dispatch.workItem.id.slice(0, 8)}`]);
+        if (addressComments) {
+            const actionable = dispatch.pullRequest?.reviewFindings.filter(finding => finding.actionable) ?? [];
+            if (actionable.length === 0 || !dispatch.pullRequest?.reviewIssueKey || !dispatch.pullRequest.headSha) {
+                throw new Error("Deterministic comment repair requires a durable actionable finding snapshot.");
+            }
+            await writeCompletionArtifact({
+                worktreePath: worktree.worktreePath,
+                workItemId: dispatch.workItem.id,
+                phase: "comment_repair",
+                producedBy: "forge-deterministic-provider",
+            }, expectedCompletionToolName("comment_repair"), {
+                status: "pass",
+                summary: "Recorded deterministic decision-required outcomes without changing source.",
+                repair_head_sha: dispatch.pullRequest.headSha,
+                repair_issue_key: dispatch.pullRequest.reviewIssueKey,
+                dispositions: actionable.map(finding => ({
+                    claim_id: finding.claimId,
+                    kind: finding.kind,
+                    body_sha256: finding.bodySha256,
+                    disposition: "needs_decision",
+                    evidence: "The deterministic provider cannot evaluate semantic review feedback."
+                })),
+                changed_files: [],
+                validation: []
+            });
+            repairArtifact = await readCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, "comment_repair");
+            if (!repairArtifact)
+                throw new Error("Deterministic comment repair did not produce its completion artifact.");
+            await emitCompletionArtifactRecorded(context.emit, worktree.worktreePath, repairArtifact);
+        }
+        await commitWorktreeChanges(this.git, worktree.worktreePath, dispatch.workItem.id);
         await context.emit(buildProviderUsageEvent(dispatch, estimatedDeterministicUsage()));
         await context.emit({
             role: "assistant",

package/dist/session/provider-cli/provider-cli.process.d.ts

@@ -1,4 +1,5 @@
 import { type LaunchCommand } from "../../shared/process/windows-launch.js";
+export declare const PROVIDER_OUTPUT_CAPTURE_LIMIT_CHARS: number;
 export type ProviderCliCommand = LaunchCommand;
 export interface ProviderProcessRunRequest {
     readonly command: string;
@@ -7,11 +8,21 @@ export interface ProviderProcessRunRequest {
     readonly env?: Readonly<Record<string, string>>;
     readonly stdin?: string;
     readonly captureOutput?: boolean;
+    /**
+     * Exact process-local values that must be removed from rejected errors and
+     * supervisor persistence. This metadata is consumed by the attempt
+     * supervisor and is never forwarded to the child process.
+     */
+    readonly failureRedactionValues?: readonly string[];
 }
 export interface ProviderProcessRunResult {
     readonly exitCode: number;
     readonly stdout: string;
     readonly stderr: string;
+    readonly peakMemoryBytes?: number;
+    readonly memorySampleCount?: number;
+    readonly memorySource?: string;
+    readonly memoryObservedAt?: string;
 }
 export interface ProviderProcessRunner {
     run(request: ProviderProcessRunRequest, handlers?: ProviderProcessHandlers, signal?: AbortSignal): Promise<ProviderProcessRunResult>;
@@ -21,6 +32,36 @@ export interface ProviderProcessHandlers {
     onStdoutLine?(line: string): Promise<void> | void;
     onStderrLine?(line: string): Promise<void> | void;
 }
+/** Recovery must wrap the attempt coordinator, never its raw OS runner. Each
+ * relaunch needs a new fenced child generation and exclusive launch files. */
+export declare function recoveringProviderProcessRunner(inner: ProviderProcessRunner): ProviderProcessRunner;
+/**
+ * Codex Desktop and an independently installed Codex CLI can briefly disagree
+ * about the shared models-cache schema during a rolling upgrade. Recover only
+ * that exact failure by quarantining the bounded cache file and retrying once;
+ * auth, config, sessions, and every other CODEX_HOME entry remain untouched.
+ */
+export declare class CodexModelsCacheRecoveringProcessRunner implements ProviderProcessRunner {
+    private readonly inner;
+    constructor(inner: ProviderProcessRunner);
+    run(request: ProviderProcessRunRequest, handlers?: ProviderProcessHandlers, signal?: AbortSignal): Promise<ProviderProcessRunResult>;
+}
+/**
+ * Some Codex CLI builds can start new turns but cannot resume an older thread
+ * because the backing app does not implement the paginated thread lookup RPC.
+ * Preserve the prepared worktree and prompt, then retry once as a fresh turn.
+ */
+export declare class CodexResumeRecoveringProcessRunner implements ProviderProcessRunner {
+    private readonly inner;
+    constructor(inner: ProviderProcessRunner);
+    run(request: ProviderProcessRunRequest, handlers?: ProviderProcessHandlers, signal?: AbortSignal): Promise<ProviderProcessRunResult>;
+}
+/**
+ * Recognizes the exact nonzero Codex service response at the provider-process
+ * boundary. Provider stdout is deliberately excluded because it can contain
+ * arbitrary tool/command output and therefore cannot mint retry authority.
+ */
+export declare function isTransientCodexProviderNotFoundFailure(command: string, result: ProviderProcessRunResult): boolean;
 interface ProviderChildEnvironmentOptions {
     readonly parentEnv?: NodeJS.ProcessEnv;
     readonly platform?: NodeJS.Platform;
@@ -28,9 +69,19 @@ interface ProviderChildEnvironmentOptions {
 }
 export declare function buildProviderChildEnvironment(requestEnv?: Readonly<Record<string, string>>, options?: ProviderChildEnvironmentOptions): NodeJS.ProcessEnv;
 export declare class StreamingProviderProcessRunner implements ProviderProcessRunner {
+    private readonly terminalExitGraceMs;
+    constructor(terminalExitGraceMs?: number);
     run(request: ProviderProcessRunRequest, handlers?: ProviderProcessHandlers, signal?: AbortSignal): Promise<ProviderProcessRunResult>;
 }
+/** Returns aggregate resident bytes for the exact supervised Unix process group. */
+export declare function processGroupResidentMemoryBytes(processGroupId: number, platform?: NodeJS.Platform, procRoot?: string): number | null;
 export declare function resolveCodexNpmDirectLaunch(commandPath: string, args: readonly string[]): LaunchCommand | null;
+/**
+ * npm installs of Claude Code (`npm i -g @anthropic-ai/claude-code`) put a `claude.cmd` shim on
+ * PATH; launch its cli.js directly for the same Job Object reasons as Codex. The native installer
+ * ships `claude.exe`, which is preferred by PATH resolution and needs no rewrite.
+ */
+export declare function resolveClaudeNpmDirectLaunch(commandPath: string, args: readonly string[]): LaunchCommand | null;
 /**
  * Avoids cmd.exe's nested-quote handling for package-manager shims. That
  * quoting loses executable paths containing spaces after the command is