@loucompanion/forge-bridge 0.1.3-dev.d1ca67076aa9 → 0.1.3-dev.e7b62d8fdd33

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

@@ -1,6 +1,6 @@
 import { GitClient } from "../../shared/git/git.js";
 import { type CompletionPhase, type CompletionToolRuntime, type DebugCompletionPhase, type QaCompletionGate } from "../phase-completion.js";
-import type { RunOnceDispatchPacket, RunnerDispatchArtifact } from "../session.types.js";
+import type { RunOnceDispatchPacket, RunnerDispatchArtifact, RunnerDispatchSidecar } from "../session.types.js";
 import type { ProviderCliRunContext } from "./provider-cli.types.js";
 export declare function emitDraftGateArtifacts(emit: ProviderCliRunContext["emit"], worktreePath: string, workItemId: string): Promise<void>;
 export declare function emitDecomposeGateArtifacts(emit: ProviderCliRunContext["emit"], worktreePath: string, workItemId: string): Promise<void>;
@@ -18,8 +18,9 @@ export declare function isDebugCompletionPhaseForProvider(phase: CompletionPhase
 export declare function emitQaArtifactRecorded(emit: ProviderCliRunContext["emit"], worktreePath: string, artifact: RunnerDispatchArtifact): Promise<void>;
 export declare function readQaCompletionArtifactBundle(worktreePath: string, workItemId: string, ownerType?: string | null, ownerId?: string | null): Promise<RunnerDispatchArtifact | null>;
 export declare function hasCompleteQaArtifactBundle(worktreePath: string, workItemId: string, ownerType?: string | null, ownerId?: string | null): Promise<boolean>;
-export declare function enforceQaBrowserLaunchTargetGate(dispatch: RunOnceDispatchPacket, artifact: RunnerDispatchArtifact): void;
+export declare function enforceQaBrowserLaunchTargetGate(dispatch: RunOnceDispatchPacket, artifact: RunnerDispatchArtifact): Promise<void>;
 export declare function validateQaBundleSidecarReferences(worktreePath: string, workItemId: string, ownerType?: string | null, ownerId?: string | null): Promise<void>;
+export declare function readQaBundleSidecars(worktreePath: string, workItemId: string, ownerType?: string | null, ownerId?: string | null): Promise<RunnerDispatchSidecar[]>;
 export declare function emitQaStructuredEvents(emit: ProviderCliRunContext["emit"], artifact: RunnerDispatchArtifact): Promise<void>;
 interface QaGateArtifactSnapshot {
     readonly gate: QaCompletionGate;

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

@@ -4,7 +4,10 @@ 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) {
     const draftArtifactFiles = {
         draft_intent: "draft.intent.json",
@@ -147,7 +150,9 @@ export async function cleanupCompletionTools(completionTools, emit) {
 }
 export async function commitWorktreeChanges(git, worktreePath, workItemId) {
     await git.run(worktreePath, ["add", "-A"]);
-    await git.run(worktreePath, ["reset", "--", ".forge"]).catch(() => "");
+    for (const reservedPath of nonPublishableWorktreePaths) {
+        await git.run(worktreePath, ["reset", "--", reservedPath]).catch(() => "");
+    }
     const changedFiles = (await git.run(worktreePath, ["diff", "--cached", "--name-only"]))
         .split(/\r?\n/)
         .map((line) => line.trim())
@@ -209,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) {
@@ -237,28 +243,55 @@ export async function hasCompleteQaArtifactBundle(worktreePath, workItemId, owne
     }
     return true;
 }
-export function enforceQaBrowserLaunchTargetGate(dispatch, artifact) {
+export async function enforceQaBrowserLaunchTargetGate(dispatch, artifact) {
     const qaBrowser = dispatch.qaBrowser;
     if (!qaBrowser?.required || hasLaunchTarget(qaBrowser.launchTarget ?? null)) {
         return;
     }
+    const evidence = await readJsonObjectFile(path.join(path.dirname(artifact.path), qaArtifactFileNames.evidence));
+    if (hasPassingRepositoryPlaywrightEvidence(evidence)) {
+        return;
+    }
     const verdict = parseJsonLine(artifact.verdictJson) ?? {};
     const status = normalizedString(stringField(verdict, "status") ?? artifact.status ?? "");
     const blockerReason = normalizedString(stringField(verdict, "blocker_reason") ?? "");
     if (status !== "blocked" || blockerReason !== "missing_app_launch_target") {
-        throw new Error("QA browser testing is required but no app launch target was provided; provider must return blocked with blocker_reason missing_app_launch_target.");
+        throw new Error("QA browser testing is required but neither an app launch target nor passing repository Playwright evidence was provided; provider must return blocked with blocker_reason missing_app_launch_target.");
+    }
+}
+function hasPassingRepositoryPlaywrightEvidence(evidence) {
+    const passingBrowserCheck = arrayField(evidence, "browser_checks").some(check => normalizedString(stringField(check, "status") ?? "") === "pass"
+        && Boolean(stringField(check, "url") ?? stringField(check, "route")));
+    if (!passingBrowserCheck) {
+        return false;
     }
+    return arrayField(evidence, "commands").some(command => {
+        const status = normalizedString(stringField(command, "status") ?? "");
+        const exitCode = command.exit_code;
+        const description = [stringField(command, "command"), stringField(command, "summary")]
+            .filter((value) => Boolean(value))
+            .join(" ");
+        return status === "pass"
+            && exitCode === 0
+            && /(?:playwright|test:e2e|e2e(?:\s|:|$)|browser(?:\s|-)?test)/iu.test(description);
+    });
 }
 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");
@@ -288,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);
@@ -444,7 +502,7 @@ export class LiveQaArtifactEmitter {
         if (!artifact) {
             return;
         }
-        enforceQaBrowserLaunchTargetGate(this.dispatch, artifact);
+        await enforceQaBrowserLaunchTargetGate(this.dispatch, artifact);
         this.emittedBundle = true;
         await emitQaArtifactRecorded(this.emit, this.worktreePath, artifact);
         await emitQaStructuredEvents(this.emit, artifact);

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

@@ -2,6 +2,7 @@ import type { ProviderCliDraftContext, ProviderCliRunContext, ProviderCliRunResu
 export interface ProviderCliService {
     runImplementation(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runArchitect(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+    runCiRepair(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runConflictResolve(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runQa(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runDraft(context: ProviderCliDraftContext): Promise<ProviderCliRunResult>;

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

@@ -8,5 +8,7 @@ export declare class DeterministicProviderCliService implements ProviderCliServi
     runImplementation(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runArchitect(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runQa(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+    runCiRepair(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runConflictResolve(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+    private runPullRequestRepair;
 }

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

@@ -5,9 +5,11 @@ import { buildSpecBody, selectLaneCommand } from "../../worktree/artifact-inject
 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 { deterministicBrowserCheck, deterministicBrowserSidecar, hasLaunchTarget, writeQaSidecarFiles } from "./provider-cli.qa-sidecars.js";
-import { buildProviderCliCommand, formatProviderCliCommand, isPullRequestCommentsDispatch, singleLine } from "./provider-cli.prompts.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;
@@ -202,26 +204,83 @@ export class DeterministicProviderCliService {
             artifacts: [qaArtifact]
         };
     }
+    async runCiRepair(context) {
+        return await this.runPullRequestRepair(context, "ci_repair");
+    }
     async runConflictResolve(context) {
+        return await this.runPullRequestRepair(context, "conflict_resolve");
+    }
+    async runPullRequestRepair(context, route) {
         const { dispatch, worktree } = context;
+        await assertRepairHeadEpoch(context, this.git);
+        const repairChecks = route === "ci_repair" || isPullRequestCheckRepairDispatch(dispatch);
         const addressComments = isPullRequestCommentsDispatch(dispatch);
-        await this.git.run(worktree.worktreePath, ["commit", "--allow-empty", "-m", `forge bridge ${addressComments ? "pr comments" : "conflict resolve"} for ${dispatch.workItem.id.slice(0, 8)}`]);
+        let repairArtifact = null;
+        let repairSpec = null;
+        if (repairChecks) {
+            const metadataRoot = path.join(worktree.worktreePath, ".forge", "work-items", dispatch.workItem.id);
+            await fs.mkdir(metadataRoot, { recursive: true });
+            const laneCommand = selectLaneCommand(dispatch.artifacts, dispatch.execution.lane, dispatch.cycleRun.phase);
+            if (!laneCommand)
+                throw new Error("Deterministic CI repair could not materialize the approved lane spec.");
+            const specBody = buildSpecBody(laneCommand, dispatch.workItem, "ci_repair");
+            const specPath = path.join(metadataRoot, "spec.md");
+            await fs.writeFile(specPath, specBody, "utf8");
+            await fs.writeFile(path.join(metadataRoot, "spec.meta.json"), `${JSON.stringify({ schema_version: 1, status: "approved", produced_by: "forge-lane-command" })}\n`, "utf8");
+            repairSpec = { repoPath: worktree.worktreePath, path: specPath, body: specBody, producedBy: "forge-lane-command", status: "approved" };
+            await writeCiRepairReadinessManifest(dispatch, worktree.worktreePath, specPath, context.runtimeEnvironment);
+            const reference = await writeCompletionArtifact({
+                worktreePath: worktree.worktreePath,
+                workItemId: dispatch.workItem.id,
+                phase: "ci_repair",
+                producedBy: "forge-deterministic-provider",
+            }, expectedCompletionToolName("ci_repair"), deterministicCiRepairPayload());
+            repairArtifact = await readCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, "ci_repair");
+            if (!repairArtifact)
+                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)}`]);
         await context.emit(buildProviderUsageEvent(dispatch, estimatedDeterministicUsage()));
         await context.emit({
             role: "assistant",
             kind: "message",
-            content: addressComments
-                ? `Deterministic PR comment addressing completed for ${worktree.branchName}.`
-                : `Deterministic conflict resolve completed for ${worktree.branchName}.`,
-            eventType: addressComments ? "pr_comments_complete" : "conflict_resolve_complete"
+            content: repairChecks
+                ? `Deterministic CI repair completed for ${worktree.branchName}.`
+                : addressComments
+                    ? `Deterministic PR comment addressing completed for ${worktree.branchName}.`
+                    : `Deterministic conflict resolve completed for ${worktree.branchName}.`,
+            eventType: repairChecks ? "pr_checks_complete" : addressComments ? "pr_comments_complete" : "conflict_resolve_complete"
         });
         return {
-            summary: addressComments
-                ? `forge-bridge addressed PR comments for ${worktree.branchName}.`
-                : `forge-bridge resolved conflicts for ${worktree.branchName}.`
+            summary: repairChecks
+                ? `forge-bridge repaired PR checks for ${worktree.branchName}.`
+                : addressComments
+                    ? `forge-bridge addressed PR comments for ${worktree.branchName}.`
+                    : `forge-bridge resolved conflicts for ${worktree.branchName}.`,
+            spec: repairSpec,
+            artifact: repairArtifact,
+            artifacts: repairArtifact ? [repairArtifact] : [],
         };
     }
 }
+function deterministicCiRepairPayload() {
+    const command = { command: "forge deterministic ci-repair validation", exit_code: 0, status: "pass", summary: "Deterministic CI repair fixture passed." };
+    return {
+        status: "pass",
+        summary: "Deterministic CI repair handoff is ready for provider checks.",
+        failed_checks: [{ name: "CI / deterministic", provider_state: "failure", workflow: ".github/workflows/ci.yml", job: "deterministic", step: "fixture" }],
+        root_cause: { classification: "test expectation mismatch", summary: "Deterministic fixture failure repaired.", evidence: ["Fixture provider reported the expected failed check."] },
+        changed_files: [],
+        no_code_action: { action: "deterministic_fixture", reason: "The deterministic provider models the repair without a product diff." },
+        narrow_validation: [command],
+        workflow_validation: [{ step: "deterministic fixture", equivalence: "supported", command: command.command, exit_code: 0, status: "pass", summary: command.summary }],
+        broader_validation: [command],
+        remaining_risks: [],
+        provider_state: "ready_for_rerun",
+        ready_for_push: true,
+    };
+}
 function deterministicDraftPayload(dispatch) {
     const kind = dispatch.draft?.kind ?? "work_item";
     if (kind === "work_order_decomposition") {

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

@@ -1,20 +1,28 @@
 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;
     readonly args: readonly string[];
     readonly cwd: string;
     readonly env?: Readonly<Record<string, string>>;
+    readonly stdin?: string;
+    readonly captureOutput?: boolean;
 }
 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>;
 }
 export interface ProviderProcessHandlers {
+    onStarted?(): Promise<void> | void;
     onStdoutLine?(line: string): Promise<void> | void;
     onStderrLine?(line: string): Promise<void> | void;
 }
@@ -25,7 +33,25 @@ 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;
+/**
+ * Avoids cmd.exe's nested-quote handling for package-manager shims. That
+ * quoting loses executable paths containing spaces after the command is
+ * wrapped by the Windows Job Object supervisor.
+ */
+export declare function resolvePackageManagerDirectLaunch(commandPath: string, args: readonly string[]): LaunchCommand | null;
+/**
+ * Resolves Windows commands without spawning where.exe. Runtime launches can
+ * happen while the machine is under enough process pressure for where.exe to
+ * miss its timeout; returning the unresolved package-manager name in that case
+ * makes Node fall back to a shell shim that cannot survive Job Object wrapping.
+ */
+export declare function resolveWindowsCommandFromPath(command: string, pathValue?: string, pathExtValue?: string): string | null;
 export declare function chooseWindowsCommandCandidate(candidates: readonly string[]): string | null;
 export {};