@loucompanion/forge-bridge 0.1.3-dev.d46a8e73d03d → 0.1.3-dev.eeefdb0d19c1

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

@@ -5,6 +5,7 @@ import { ensureNoSymbolicLinkPathSegments, isPathUnderRoot, sha256File } from ".
 import { hasLaunchTarget } from "./provider-cli.qa-sidecars.js";
 import { clip, isNodeError, messageFromError, normalizedString, parseJsonLine, stringField } from "./provider-output-state.js";
 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 +148,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())
@@ -237,18 +240,39 @@ 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) {
     const artifactRoot = ownerType && ownerId
         ? artifactRootForOwner(worktreePath, ownerType, ownerId)
@@ -444,7 +468,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.deterministic.js

@@ -8,6 +8,7 @@ import { deterministicBrowserCheck, deterministicBrowserSidecar, hasLaunchTarget
 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 { deterministicArchitectPayload, deterministicCompletionPayload, deterministicQaGatePayload } from "./provider-cli.deterministic-payloads.js";
 export class DeterministicProviderCliService {
     git;
@@ -212,6 +213,31 @@ export class DeterministicProviderCliService {
         const { dispatch, worktree } = context;
         const repairChecks = route === "ci_repair" || isPullRequestCheckRepairDispatch(dispatch);
         const addressComments = isPullRequestCommentsDispatch(dispatch);
+        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({
@@ -229,10 +255,30 @@ export class DeterministicProviderCliService {
                 ? `forge-bridge repaired PR checks for ${worktree.branchName}.`
                 : addressComments
                     ? `forge-bridge addressed PR comments for ${worktree.branchName}.`
-                    : `forge-bridge resolved conflicts 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

@@ -6,6 +6,7 @@ export interface ProviderProcessRunRequest {
     readonly cwd: string;
     readonly env?: Readonly<Record<string, string>>;
     readonly stdin?: string;
+    readonly captureOutput?: boolean;
 }
 export interface ProviderProcessRunResult {
     readonly exitCode: number;
@@ -16,6 +17,7 @@ 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;
 }
@@ -28,5 +30,19 @@ export declare function buildProviderChildEnvironment(requestEnv?: Readonly<Reco
 export declare class StreamingProviderProcessRunner implements ProviderProcessRunner {
     run(request: ProviderProcessRunRequest, handlers?: ProviderProcessHandlers, signal?: AbortSignal): Promise<ProviderProcessRunResult>;
 }
+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 {};

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

@@ -1,9 +1,11 @@
 import { execFile, spawn } from "node:child_process";
+import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
 import { promisify } from "node:util";
 import { resolveCursorAgentDirectLaunch } from "../../shared/cursor-agent/cursor-agent.launch.js";
+import { persistHostProcessSupervisorMetadata, resolveHostProcessSupervisedLaunch, terminateHostProcessTree, } from "../../shared/process/host-process-supervisor.js";
 import { buildWindowsLaunchCommand } from "../../shared/process/windows-launch.js";
 const execFileAsync = promisify(execFile);
 const allowedProviderParentEnvNames = [
@@ -137,24 +139,35 @@ function setEnvironmentValueIfMissing(env, name, value) {
 }
 export class StreamingProviderProcessRunner {
     async run(request, handlers = {}, signal) {
-        const launch = await resolveProviderProcessLaunch(request.command, request.args);
+        const providerLaunch = await resolveProviderProcessLaunch(request.command, request.args);
+        const supervisedLaunch = resolveHostProcessSupervisedLaunch(request, providerLaunch.command, providerLaunch.args);
+        const launch = supervisedLaunch ?? { ...providerLaunch, detached: false };
         return await new Promise((resolve, reject) => {
+            const rootCreatedAt = new Date().toISOString();
             const child = spawn(launch.command, launch.args, {
                 cwd: request.cwd,
                 env: buildProviderChildEnvironment(request.env),
                 stdio: [request.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
-                windowsHide: true
+                windowsHide: true,
+                detached: launch.detached,
             });
+            let termination = null;
+            const terminate = () => {
+                termination ??= terminateHostProcessTree(child, supervisedLaunch);
+                return termination;
+            };
             const childStdout = child.stdout;
             const childStderr = child.stderr;
             if (!childStdout || !childStderr) {
-                child.kill("SIGTERM");
+                void terminate();
                 reject(new Error("Provider process stdout/stderr streams were not piped."));
                 return;
             }
             let stdout = "";
             let stderr = "";
             let settled = false;
+            let closed = false;
+            let readiness = null;
             const cleanup = () => {
                 signal?.removeEventListener("abort", abort);
             };
@@ -164,15 +177,14 @@ export class StreamingProviderProcessRunner {
                 }
                 settled = true;
                 cleanup();
+                void terminate().catch(() => undefined);
                 reject(error);
             };
             const abort = () => {
-                try {
-                    child.kill("SIGTERM");
-                }
-                catch {
-                    // Best effort; close/error will settle the promise.
-                }
+                // Cancellation is not a launch failure when the supervised tree can be
+                // proven stopped. Let the close handler settle the command after exact
+                // termination; only a failed termination proof rejects the run.
+                void terminate().catch(fail);
             };
             if (signal?.aborted) {
                 abort();
@@ -181,40 +193,66 @@ export class StreamingProviderProcessRunner {
                 signal?.addEventListener("abort", abort, { once: true });
             }
             child.on("error", fail);
-            if (request.stdin !== undefined) {
-                if (!child.stdin) {
-                    try {
-                        child.kill("SIGTERM");
+            child.once("spawn", () => {
+                readiness = (async () => {
+                    const providerReady = supervisedLaunch?.strategy === "windows_job_object"
+                        ? await waitForWindowsProviderReady(supervisedLaunch, signal, () => closed)
+                        : undefined;
+                    if (supervisedLaunch) {
+                        persistHostProcessSupervisorMetadata(supervisedLaunch, request, child.pid ?? 0, rootCreatedAt, providerReady);
                     }
-                    catch {
-                        // Best effort; the missing stdin pipe will fail the provider run.
+                    await handlers.onStarted?.();
+                    if (supervisedLaunch?.strategy === "windows_job_object") {
+                        grantWindowsProviderStart(supervisedLaunch);
                     }
+                })();
+                void readiness.catch(error => {
+                    if (!closed && !signal?.aborted)
+                        fail(error);
+                });
+            });
+            const writeProviderInput = () => {
+                if (request.stdin === undefined)
+                    return;
+                if (!child.stdin) {
+                    void terminate();
                     fail(new Error("Provider process stdin stream was not piped."));
                     return;
                 }
                 child.stdin.on("error", (error) => {
-                    try {
-                        child.kill("SIGTERM");
-                    }
-                    catch {
-                        // Best effort; the stdin error will fail the provider run.
-                    }
+                    void terminate();
                     fail(error);
                 });
                 child.stdin.end(request.stdin, "utf8");
+            };
+            if (request.stdin !== undefined) {
+                if (supervisedLaunch?.strategy === "windows_job_object") {
+                    // The outer supervisor must receive stdin before it can launch the
+                    // inner provider. Its start-grant file prevents prompt delivery.
+                    writeProviderInput();
+                }
+                else {
+                    child.once("spawn", () => {
+                        void readiness?.then(writeProviderInput).catch(fail);
+                    });
+                }
             }
             const readers = [
                 readProcessLines(childStdout, (line) => {
-                    stdout += `${line}\n`;
+                    if (request.captureOutput !== false)
+                        stdout += `${line}\n`;
                     return handlers.onStdoutLine?.(line);
                 }),
                 readProcessLines(childStderr, (line) => {
-                    stderr += `${line}\n`;
+                    if (request.captureOutput !== false)
+                        stderr += `${line}\n`;
                     return handlers.onStderrLine?.(line);
                 })
             ];
             child.on("close", (code) => {
-                Promise.allSettled(readers).then((readerResults) => {
+                closed = true;
+                Promise.allSettled(readers).then(async (readerResults) => {
+                    await readiness?.catch(() => undefined);
                     const rejected = readerResults.find((result) => result.status === "rejected");
                     if (rejected?.status === "rejected") {
                         fail(rejected.reason);
@@ -223,6 +261,18 @@ export class StreamingProviderProcessRunner {
                     if (settled) {
                         return;
                     }
+                    try {
+                        if (supervisedLaunch?.strategy === "unix_process_group") {
+                            await terminate();
+                        }
+                        else if (termination) {
+                            await termination;
+                        }
+                    }
+                    catch (error) {
+                        fail(error);
+                        return;
+                    }
                     settled = true;
                     cleanup();
                     resolve({
@@ -244,12 +294,115 @@ async function resolveProviderProcessLaunch(command, args) {
         return cursorDirect;
     }
     const resolved = await resolveWindowsCommand(command);
-    return resolved ? buildWindowsLaunchCommand(resolved, args) : { command, args };
+    if (!resolved) {
+        return { command, args };
+    }
+    return resolveCodexNpmDirectLaunch(resolved, args)
+        ?? resolvePackageManagerDirectLaunch(resolved, args)
+        ?? buildWindowsLaunchCommand(resolved, args);
+}
+function grantWindowsProviderStart(launch) {
+    if (!launch.startGrantPath) {
+        throw new Error("host_process_supervisor_invalid: Windows provider start-grant path was not assigned.");
+    }
+    fs.writeFileSync(launch.startGrantPath, "granted\n", {
+        encoding: "utf8",
+        flag: "wx",
+        mode: 0o600,
+    });
+}
+async function waitForWindowsProviderReady(launch, signal, isClosed) {
+    const readyPath = launch.readyPath;
+    if (!readyPath) {
+        throw new Error("host_process_supervisor_invalid: Windows provider-ready path was not assigned.");
+    }
+    while (true) {
+        try {
+            const parsed = JSON.parse(await fs.promises.readFile(readyPath, "utf8"));
+            if (parsed.schemaVersion !== 1
+                || parsed.supervisorId !== launch.supervisorId
+                || !Number.isSafeInteger(parsed.rootPid)
+                || (parsed.rootPid ?? 0) <= 0
+                || typeof parsed.rootIdentity !== "string"
+                || !/^win32:\d+$/u.test(parsed.rootIdentity)
+                || !Number.isSafeInteger(parsed.providerPid)
+                || (parsed.providerPid ?? 0) <= 0
+                || typeof parsed.providerCreatedAt !== "string"
+                || Number.isNaN(Date.parse(parsed.providerCreatedAt))
+                || (parsed.providerIdentity !== undefined
+                    && (typeof parsed.providerIdentity !== "string" || !/^win32:\d+$/u.test(parsed.providerIdentity)))
+                || !Number.isSafeInteger(parsed.startAttempt)
+                || (parsed.startAttempt ?? 0) < 1) {
+                throw new Error("host_process_supervisor_invalid: provider-ready receipt was invalid.");
+            }
+            return parsed;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (isClosed()) {
+            throw new Error("host_process_supervisor_start_failed: supervisor exited before the provider became ready.");
+        }
+        if (signal?.aborted) {
+            throw signal.reason instanceof Error ? signal.reason : new Error("Provider process launch was aborted.");
+        }
+        await new Promise(resolve => setTimeout(resolve, 25));
+    }
+}
+export function resolveCodexNpmDirectLaunch(commandPath, args) {
+    const extension = path.extname(commandPath).toLowerCase();
+    if ((extension !== ".cmd" && extension !== ".ps1")
+        || path.basename(commandPath, extension).toLowerCase() !== "codex") {
+        return null;
+    }
+    const entryPoint = path.join(path.dirname(commandPath), "node_modules", "@openai", "codex", "bin", "codex.js");
+    return fs.existsSync(entryPoint)
+        ? { command: process.execPath, args: [entryPoint, ...args] }
+        : 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 function resolvePackageManagerDirectLaunch(commandPath, args) {
+    const extension = path.extname(commandPath).toLowerCase();
+    if (extension !== ".cmd" && extension !== ".ps1")
+        return null;
+    const packageManager = path.basename(commandPath, extension).toLowerCase();
+    if (!["npm", "npx", "pnpm", "pnpx", "yarn", "yarnpkg"].includes(packageManager))
+        return null;
+    const root = path.dirname(commandPath);
+    const candidates = [
+        path.join(root, "node_modules", "corepack", "dist", `${packageManager}.js`),
+        ...(packageManager === "npm" || packageManager === "npx"
+            ? [path.join(root, "node_modules", "npm", "bin", `${packageManager}-cli.js`)]
+            : []),
+        ...(packageManager === "pnpm" || packageManager === "pnpx"
+            ? [path.join(root, "node_modules", "pnpm", "bin", `${packageManager}.cjs`)]
+            : []),
+        ...(packageManager === "yarn" || packageManager === "yarnpkg"
+            ? [path.join(root, "node_modules", "yarn", "bin", "yarn.js")]
+            : []),
+    ];
+    const entryPoint = candidates.find(candidate => fs.existsSync(candidate));
+    if (!entryPoint)
+        return null;
+    const adjacentNode = path.join(root, "node.exe");
+    return {
+        command: fs.existsSync(adjacentNode) ? adjacentNode : process.execPath,
+        args: [entryPoint, ...args],
+    };
 }
 async function resolveWindowsCommand(command) {
     if (path.isAbsolute(command)) {
         return command;
     }
+    const resolvedFromPath = resolveWindowsCommandFromPath(command);
+    if (resolvedFromPath) {
+        return resolvedFromPath;
+    }
     try {
         const result = await execFileAsync("where.exe", [command], { timeout: 2000 });
         return chooseWindowsCommandCandidate(result.stdout.split(/\r?\n/));
@@ -258,6 +411,40 @@ async function resolveWindowsCommand(command) {
         return 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 function resolveWindowsCommandFromPath(command, pathValue = process.env.PATH ?? "", pathExtValue = process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD") {
+    if (!command || path.isAbsolute(command) || command.includes("/") || command.includes("\\")) {
+        return null;
+    }
+    const hasExtension = path.extname(command).length > 0;
+    const extensions = hasExtension
+        ? [""]
+        : [...new Set([
+                "",
+                ".exe",
+                ".ps1",
+                ".cmd",
+                ".bat",
+                ...pathExtValue.split(";").map(value => value.trim().toLowerCase()).filter(Boolean),
+            ])];
+    const candidates = [];
+    for (const rawDirectory of pathValue.split(path.delimiter)) {
+        const directory = rawDirectory.trim().replace(/^"|"$/gu, "");
+        if (!directory)
+            continue;
+        for (const extension of extensions) {
+            const candidate = path.join(directory, `${command}${extension}`);
+            if (fs.existsSync(candidate))
+                candidates.push(candidate);
+        }
+    }
+    return chooseWindowsCommandCandidate(candidates);
+}
 export function chooseWindowsCommandCandidate(candidates) {
     const normalized = candidates
         .map((candidate) => candidate.trim())

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

@@ -17,12 +17,15 @@ export declare function formatProviderCliCommandForCheckpoint(command: ProviderC
 export declare function singleLine(value: string): string;
 export declare function buildProviderCliCommand(dispatch: RunOnceDispatchPacket, run?: {
     readonly prompt?: string;
+    readonly promptFromStdin?: boolean;
     readonly worktreePath?: string;
     readonly completionTools?: CompletionToolRuntime;
     readonly skipGitRepoCheck?: boolean;
     readonly imagePaths?: readonly string[];
+    readonly runtimeEnvironment?: Readonly<Record<string, string>>;
 }): ProviderCliCommand;
-export declare function codexSandboxModeForPlatform(platform?: NodeJS.Platform): "workspace-write" | "danger-full-access";
+export declare function buildProviderCliPrompt(dispatch: RunOnceDispatchPacket, prompt: string, runtimeEnvironment?: Readonly<Record<string, string>>): string;
+export declare function codexSandboxModeForPlatform(platform?: NodeJS.Platform, executionMode?: string): "workspace-write" | "danger-full-access";
 export declare function buildArchitectPrompt(dispatch: RunOnceDispatchPacket): string;
 export declare function architectDependencyInstruction(dispatch: RunOnceDispatchPacket): string;
 export declare function designerRefInstruction(dispatch: RunOnceDispatchPacket): string;