@loucompanion/forge-bridge 0.1.1-dev.03b8ba168599 → 0.1.1-dev.040867847f42

package/dist/bridge/bridge.service.d.ts

@@ -15,6 +15,7 @@ export declare class ForgeBridgeService implements BridgeService {
     run(signal?: AbortSignal): Promise<void>;
     stop(): Promise<void>;
     private handleDispatch;
+    private parseDispatchOrReport;
     private handleCancel;
     private abortActiveSessions;
     private normalizeDispatch;

package/dist/bridge/bridge.service.js

@@ -51,7 +51,7 @@ export class ForgeBridgeService {
                     attempt = 0;
                     await this.waitForClose(signal);
                 }
-                catch (error) {
+                catch {
                     if (this.stopped || signal?.aborted) {
                         break;
                     }
@@ -73,10 +73,14 @@ export class ForgeBridgeService {
         this.abortActiveSessions("bridge stopping");
         await this.stopConnection();
     }
-    async handleDispatch(dispatch) {
+    async handleDispatch(rawDispatch) {
+        const dispatch = this.parseDispatchOrReport(rawDispatch);
+        if (!dispatch) {
+            return;
+        }
         const leaseId = dispatch.lease.id;
         const fencingToken = dispatch.lease.fencingToken;
-        const redactionSecrets = exactSecrets(dispatch);
+        const redactionSecrets = exactSecrets(dispatch, this.config);
         if (this.activeSessions.has(leaseId)) {
             await this.sendResult(leaseId, fencingToken, failureResult("Dispatch is already active on this bridge.")).catch(() => undefined);
             return;
@@ -87,11 +91,20 @@ export class ForgeBridgeService {
             const normalized = this.normalizeDispatch(dispatch);
             const result = await this.sessions.runOnce(normalized, {
                 emit: async (event) => {
-                    await this.invokeAck("DispatchEvent", {
-                        leaseId,
-                        fencingToken,
-                        event: redactSecrets(event, redactionSecrets)
-                    });
+                    try {
+                        await this.invokeAck("DispatchEvent", {
+                            leaseId,
+                            fencingToken,
+                            event: redactSecrets(event, redactionSecrets)
+                        });
+                    }
+                    catch (error) {
+                        if (isDispatchNoLongerPending(error)) {
+                            controller.abort(error instanceof Error ? error.message : "Dispatch is no longer pending.");
+                            return;
+                        }
+                        throw error;
+                    }
                 }
             }, controller.signal);
             await this.sendResult(leaseId, fencingToken, redactSecrets(result, redactionSecrets));
@@ -106,6 +119,27 @@ export class ForgeBridgeService {
             this.activeSessions.delete(leaseId);
         }
     }
+    parseDispatchOrReport(rawDispatch) {
+        try {
+            return parseRunOnceDispatchPacket(rawDispatch);
+        }
+        catch (error) {
+            const identifiers = readDispatchIdentifiers(rawDispatch);
+            if (!identifiers) {
+                return null;
+            }
+            const summary = invalidDispatchSummary(error);
+            void this.sendResult(identifiers.leaseId, identifiers.fencingToken, failureResult(summary, [
+                {
+                    role: "runner",
+                    kind: "error",
+                    content: summary,
+                    eventType: "invalid_dispatch"
+                }
+            ])).catch(() => undefined);
+            return null;
+        }
+    }
     async handleCancel(request) {
         const active = this.activeSessions.get(request.leaseId);
         if (!active || active.fencingToken !== request.fencingToken) {
@@ -123,6 +157,7 @@ export class ForgeBridgeService {
         const mapping = findRepoMapping(dispatch, this.config.repoMappings);
         const localPath = mapping?.localPath?.trim();
         const repoRoot = localPath ? path.dirname(path.resolve(localPath)) : this.config.defaultRepoRoot;
+        const qaLaunchTarget = normalizeQaAppLaunchTarget(mapping?.qaAppLaunchTarget) ?? dispatch.qaBrowser?.launchTarget ?? null;
         return {
             ...dispatch,
             repo: {
@@ -133,7 +168,13 @@ export class ForgeBridgeService {
             serverLocal: {
                 repoRoot,
                 cleanupWorktrees: this.config.cleanupWorktrees
-            }
+            },
+            qaBrowser: dispatch.qaBrowser
+                ? {
+                    ...dispatch.qaBrowser,
+                    launchTarget: qaLaunchTarget
+                }
+                : dispatch.qaBrowser
         };
     }
     async sendResult(leaseId, fencingToken, result) {
@@ -142,7 +183,15 @@ export class ForgeBridgeService {
             fencingToken,
             result
         };
-        await this.invokeAck("DispatchResult", payload);
+        try {
+            await this.invokeAck("DispatchResult", payload);
+        }
+        catch (error) {
+            if (isDispatchNoLongerPending(error)) {
+                return;
+            }
+            throw error;
+        }
     }
     startHeartbeat() {
         this.stopHeartbeat();
@@ -179,7 +228,8 @@ export class ForgeBridgeService {
             supportsApiSecretGrant: this.config.supportsApiSecretGrant,
             supportsManagedWorktrees: this.config.supportsManagedWorktrees,
             supportsManagedForgeArtifacts: this.config.supportsManagedForgeArtifacts,
-            supportsRunnerAuthoredPhaseArtifacts: this.config.supportsRunnerAuthoredPhaseArtifacts
+            supportsRunnerAuthoredPhaseArtifacts: this.config.supportsRunnerAuthoredPhaseArtifacts,
+            supportsDraftRunOnce: this.config.supportsDraftRunOnce
         };
     }
     async invokeAck(methodName, payload) {
@@ -189,7 +239,7 @@ export class ForgeBridgeService {
         }
         const ack = await connection.invoke(methodName, payload);
         if (!ack.accepted) {
-            throw new Error(ack.message ?? ack.code ?? `${methodName} callback was rejected.`);
+            throw new BridgeCallbackRejectedError(ack.code ?? null, ack.message ?? ack.code ?? `${methodName} callback was rejected.`);
         }
         return ack;
     }
@@ -207,6 +257,20 @@ export class ForgeBridgeService {
         }
     }
 }
+class BridgeCallbackRejectedError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "BridgeCallbackRejectedError";
+    }
+}
+function isDispatchNoLongerPending(error) {
+    if (error instanceof BridgeCallbackRejectedError) {
+        return error.code === "bridge.dispatch_not_pending" || error.code === "bridge.stale_dispatch";
+    }
+    return error instanceof Error && error.message === "Dispatch is no longer pending.";
+}
 export class SignalRBridgeConnectionFactory {
     create(config) {
         return new SignalRBridgeConnection(config);
@@ -237,14 +301,7 @@ export class SignalRBridgeConnection {
     }
     onDispatch(handler) {
         this.connection.on("Dispatch", (raw) => {
-            let dispatch;
-            try {
-                dispatch = parseRunOnceDispatchPacket(raw);
-            }
-            catch {
-                return;
-            }
-            void handler(dispatch).catch(() => undefined);
+            void handler(raw).catch(() => undefined);
         });
     }
     onCancel(handler) {
@@ -271,11 +328,12 @@ export function defaultBridgeServiceConfig(overrides = {}) {
         projectLabels: splitCsv(process.env.FORGE_PROJECT_LABELS ?? ""),
         repoMappings: [],
         os: process.platform,
-        sandboxProfiles: ["default"],
+        sandboxProfiles: overrides.sandboxProfiles,
         supportsApiSecretGrant: true,
         supportsManagedWorktrees: true,
         supportsManagedForgeArtifacts: true,
         supportsRunnerAuthoredPhaseArtifacts: true,
+        supportsDraftRunOnce: true,
         version: process.env.FORGE_BRIDGE_VERSION ?? forgeBridgeVersion,
         protocolVersion: 1,
         minServerVersion: null,
@@ -285,6 +343,7 @@ export function defaultBridgeServiceConfig(overrides = {}) {
     };
     return {
         ...config,
+        sandboxProfiles: config.sandboxProfiles ?? defaultSandboxProfiles(config.cliProviders),
         heartbeatIntervalMs: positiveFiniteNumber(config.heartbeatIntervalMs, 30_000)
     };
 }
@@ -303,6 +362,11 @@ function positiveFiniteNumber(value, fallback) {
 function providerStatusesFor(providers) {
     return Object.fromEntries(providers.map((provider) => [provider, { signedIn: true, version: "", models: configuredModelsFor(provider) }]));
 }
+function defaultSandboxProfiles(providers) {
+    return providers.some((provider) => provider.toLowerCase() === "codex")
+        ? ["provider-workspace-write"]
+        : ["none"];
+}
 function configuredModelsFor(provider) {
     const envName = `FORGE_${provider.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase()}_MODELS`;
     return splitCsv(process.env[envName] ?? "");
@@ -323,16 +387,58 @@ function findRepoMapping(dispatch, mappings) {
             (!!mapping.remoteUrl?.trim() && equalsIgnoreCase(mapping.remoteUrl, dispatch.repo.remoteUrl)));
     });
 }
+function normalizeQaAppLaunchTarget(target) {
+    if (!target) {
+        return null;
+    }
+    const routes = [...new Set((target.routes ?? []).map((route) => route.trim()).filter(Boolean))];
+    const normalized = {
+        url: cleanString(target.url),
+        command: cleanString(target.command),
+        working_directory: cleanString(target.working_directory),
+        ready_url: cleanString(target.ready_url),
+        routes,
+        notes: cleanString(target.notes)
+    };
+    return normalized.url || normalized.command || normalized.ready_url || routes.length > 0
+        ? normalized
+        : null;
+}
+function cleanString(value) {
+    const clean = value?.trim();
+    return clean ? clean : null;
+}
 function equalsIgnoreCase(left, right) {
     return !!left?.trim() && !!right?.trim() && left.trim().toLowerCase() === right.trim().toLowerCase();
 }
+function readDispatchIdentifiers(rawDispatch) {
+    if (!rawDispatch || typeof rawDispatch !== "object" || Array.isArray(rawDispatch)) {
+        return null;
+    }
+    const packet = rawDispatch;
+    const rawLease = packet.lease ?? packet.Lease;
+    if (!rawLease || typeof rawLease !== "object" || Array.isArray(rawLease)) {
+        return null;
+    }
+    const lease = rawLease;
+    const leaseId = readString(lease, "id", "Id");
+    const fencingToken = readString(lease, "fencingToken", "FencingToken");
+    return leaseId && fencingToken ? { leaseId, fencingToken } : null;
+}
+function readString(source, camelKey, pascalKey) {
+    const value = source[camelKey] ?? source[pascalKey];
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function invalidDispatchSummary(error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return `Invalid bridge dispatch packet: ${detail}`;
+}
 function delay(ms, signal) {
     if (signal?.aborted) {
         return Promise.resolve();
     }
     return new Promise((resolve) => {
         const timeout = setTimeout(resolve, ms);
-        timeout.unref?.();
         signal?.addEventListener("abort", () => {
             clearTimeout(timeout);
             resolve();
@@ -348,6 +454,9 @@ function abortPromise(signal) {
     }
     return new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
 }
-function exactSecrets(dispatch) {
-    return dispatch.apiKeySecretGrant?.secret ? [dispatch.apiKeySecretGrant.secret] : [];
+function exactSecrets(dispatch, config) {
+    return [
+        dispatch.apiKeySecretGrant?.secret,
+        config.deviceToken
+    ].filter((secret) => typeof secret === "string" && secret.length > 0);
 }

package/dist/bridge/bridge.types.d.ts

@@ -1,4 +1,4 @@
-import type { RunOnceDispatchPacket, RunOnceResultPacket, RunnerDispatchEvent } from "../session/session.types.js";
+import type { RunOnceResultPacket, RunnerDispatchEvent } from "../session/session.types.js";
 export interface BridgeServiceConfig {
     readonly serverUrl: string;
     readonly runnerId: string;
@@ -16,6 +16,7 @@ export interface BridgeServiceConfig {
     readonly supportsManagedWorktrees: boolean;
     readonly supportsManagedForgeArtifacts: boolean;
     readonly supportsRunnerAuthoredPhaseArtifacts: boolean;
+    readonly supportsDraftRunOnce: boolean;
     readonly version: string;
     readonly protocolVersion: number;
     readonly minServerVersion?: string | null;
@@ -27,6 +28,15 @@ export interface BridgeRepoMapping {
     readonly name?: string | null;
     readonly remoteUrl?: string | null;
     readonly localPath?: string | null;
+    readonly qaAppLaunchTarget?: QaAppLaunchTarget | null;
+}
+export interface QaAppLaunchTarget {
+    readonly url?: string | null;
+    readonly command?: string | null;
+    readonly working_directory?: string | null;
+    readonly ready_url?: string | null;
+    readonly routes?: readonly string[] | null;
+    readonly notes?: string | null;
 }
 export interface BridgeProviderStatus {
     readonly signedIn?: boolean | null;
@@ -46,6 +56,7 @@ export interface BridgeCapabilities {
     readonly supportsManagedWorktrees?: boolean | null;
     readonly supportsManagedForgeArtifacts?: boolean | null;
     readonly supportsRunnerAuthoredPhaseArtifacts?: boolean | null;
+    readonly supportsDraftRunOnce?: boolean | null;
 }
 export interface BridgeHelloRequest {
     readonly version: string;
@@ -79,5 +90,5 @@ export interface BridgeCancelRequest {
     readonly fencingToken: string;
     readonly reason?: string | null;
 }
-export type BridgeDispatchHandler = (dispatch: RunOnceDispatchPacket) => Promise<void>;
+export type BridgeDispatchHandler = (dispatch: unknown) => Promise<void>;
 export type BridgeCancelHandler = (request: BridgeCancelRequest) => Promise<void>;

package/dist/cli/cli.service.d.ts

@@ -14,6 +14,10 @@ export declare function parseArgs(argv: readonly string[]): {
     readonly command: "run-once";
     readonly dispatchPath: string;
     readonly resultPath: string;
+} | {
+    readonly ok: true;
+    readonly command: "mcp";
+    readonly argv: readonly string[];
 } | {
     readonly ok: true;
     readonly command: "connect";

package/dist/cli/cli.service.js

@@ -4,10 +4,13 @@ import os from "node:os";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
 import { promisify } from "node:util";
+import { resolveCursorAgentDirectLaunch } from "../shared/cursor-agent/cursor-agent.launch.js";
 import { redactSecrets, redactText } from "../shared/redaction/redaction.js";
 import { defaultBridgeServiceConfig, ForgeBridgeService } from "../bridge/bridge.service.js";
+import { forgeBridgeVersion } from "../version.js";
 import { addRepoMapping, applyLocalConfigDefaults, providerStatusesFor, readLocalConfigSync, removeRepoMapping, resolveLocalConfigPath, writeLocalConfig } from "./local-config.js";
 import { BridgeSessionService } from "../session/session.service.js";
+import { parseCompletionMcpArgs, runCompletionMcpServer } from "../session/phase-completion.js";
 import { failureResult, parseRunOnceDispatchPacket } from "../session/session.types.js";
 const apiKeySecretGrantEnv = "FORGE_API_KEY_SECRET_GRANT";
 const execFileAsync = promisify(execFile);
@@ -21,6 +24,14 @@ export class ForgeBridgeCliService {
         this.pairRunner = pairRunner;
     }
     async run(argv, io = { stdout: process.stdout, stderr: process.stderr }) {
+        if (argv.length === 0 || isHelpArg(argv[0])) {
+            io.stdout.write(helpText());
+            return 0;
+        }
+        if (argv[0] === "version" || argv[0] === "--version" || argv[0] === "-v") {
+            io.stdout.write(`forge-bridge ${defaultBridgeServiceConfig().version ?? forgeBridgeVersion}\n`);
+            return 0;
+        }
         const args = parseArgs(argv);
         if (!args.ok) {
             io.stderr.write(`${args.error}\n`);
@@ -42,6 +53,7 @@ export class ForgeBridgeCliService {
             process.once("SIGINT", stop);
             process.once("SIGTERM", stop);
             try {
+                io.stdout.write(connectStartupText(config));
                 await this.bridgeFactory(config).run(controller.signal);
                 return 0;
             }
@@ -102,6 +114,15 @@ export class ForgeBridgeCliService {
         if (args.command === "cleanup") {
             return await cleanupRepos(args.config, args.mode, args.force, io);
         }
+        if (args.command === "mcp") {
+            const parsed = parseCompletionMcpArgs(args.argv);
+            if (!parsed.ok) {
+                io.stderr.write(`${parsed.error}\n`);
+                return 2;
+            }
+            await runCompletionMcpServer(parsed.config);
+            return 0;
+        }
         let redactionSecrets = readEnvSecretValuesForRedaction();
         try {
             const dispatchJson = await fs.readFile(args.dispatchPath, "utf8");
@@ -165,19 +186,23 @@ function parseEnvSecretGrant(raw) {
     };
 }
 function exactSecrets(dispatch) {
-    return dispatch.apiKeySecretGrant?.secret ? [dispatch.apiKeySecretGrant.secret] : [];
+    return exactSecretValues(dispatch.apiKeySecretGrant?.secret, process.env.FORGE_DEVICE_TOKEN);
 }
 function readEnvSecretValuesForRedaction() {
+    const secrets = [];
     const raw = process.env[apiKeySecretGrantEnv];
-    if (!raw) {
-        return [];
-    }
-    try {
-        return [parseEnvSecretGrant(raw).secret];
-    }
-    catch {
-        return [];
+    if (raw) {
+        try {
+            secrets.push(parseEnvSecretGrant(raw).secret);
+        }
+        catch {
+            // Ignore malformed grant env here; command handling will report the parse error.
+        }
     }
+    return exactSecretValues(...secrets, process.env.FORGE_DEVICE_TOKEN);
+}
+function exactSecretValues(...values) {
+    return values.filter((value) => typeof value === "string" && value.length > 0);
 }
 export function parseArgs(argv) {
     if (argv[0] === "connect") {
@@ -214,6 +239,9 @@ export function parseArgs(argv) {
     if (argv[0] === "cleanup") {
         return parseCleanupArgs(argv);
     }
+    if (argv[0] === "mcp") {
+        return { ok: true, command: "mcp", argv };
+    }
     if (argv[0] !== "run-once") {
         return {
             ok: false,
@@ -460,6 +488,7 @@ function pairedConfig(current, args, claim) {
         supportsManagedWorktrees: current.supportsManagedWorktrees ?? true,
         supportsManagedForgeArtifacts: current.supportsManagedForgeArtifacts ?? true,
         supportsRunnerAuthoredPhaseArtifacts: current.supportsRunnerAuthoredPhaseArtifacts ?? true,
+        supportsDraftRunOnce: current.supportsDraftRunOnce ?? true,
         repoMappings: current.repoMappings ?? []
     };
 }
@@ -507,8 +536,74 @@ function normalizePairingCode(code) {
 function normalizeServerUrl(serverUrl) {
     return serverUrl.endsWith("/") ? serverUrl : `${serverUrl}/`;
 }
+function isHelpArg(arg) {
+    return arg === "help" || arg === "--help" || arg === "-h";
+}
 function usage() {
-    return "Usage: forge-bridge run-once --dispatch <dispatch-json-path> --result <result-json-path> | forge-bridge pair [code] [--server <url>] | forge-bridge connect --server <url> --runner-id <id> --device-token <token> | forge-bridge add-repo <label> <path> | forge-bridge remove-repo <label> | forge-bridge status [--check-updates] | forge-bridge cleanup [--stale|--merged|--all|--force]";
+    return helpText();
+}
+function helpText() {
+    const version = defaultBridgeServiceConfig().version ?? forgeBridgeVersion;
+    return [
+        `Forge Bridge ${version}`,
+        "Connect this machine to Forge as a local runner for agent dispatch.",
+        "",
+        "Usage:",
+        "  forge-bridge <command> [options]",
+        "",
+        "Options:",
+        "  -h, --help       Show this help.",
+        "  -v, --version    Print the bridge version.",
+        "",
+        "Commands:",
+        "  pair [code]       Pair this machine with Forge and save runner credentials.",
+        "  connect           Start the bridge and wait for Forge dispatches.",
+        "  status            Show saved config, runner identity, repos, and detected CLIs.",
+        "  add-repo          Map a Forge project/repo label to a local checkout path.",
+        "  remove-repo       Remove a saved repo mapping.",
+        "  cleanup           Prune or remove managed bridge worktrees.",
+        "  run-once          Internal worker entrypoint used by Forge dispatch.",
+        "  mcp               Internal MCP server for phase completion.",
+        "",
+        "Examples:",
+        "  npm install -g @loucompanion/forge-bridge@next",
+        "  forge-bridge pair <code> --server https://forge.example.com --repo-root \"%USERPROFILE%\\ForgeRepos\"",
+        "  forge-bridge connect",
+        "  forge-bridge status --check-updates",
+        "  forge-bridge add-repo Forge C:\\Users\\you\\src\\Forge",
+        "",
+        "Setup:",
+        "  1. In Forge, open Profile Settings -> Runners -> Pair runner.",
+        "  2. Copy the pairing code and command shown there.",
+        "  3. Run forge-bridge connect and keep the terminal open.",
+        "",
+        "Docs:",
+        "  https://github.com/coleman399/Forge/tree/develop/tools/forge-bridge#readme",
+        "",
+    ].join("\n");
+}
+function connectStartupText(config) {
+    const runner = config.runnerId
+        ? `${config.runnerId}${config.deviceName ? ` (${config.deviceName})` : ""}`
+        : "not configured";
+    return [
+        `Forge Bridge ${config.version}`,
+        "Starting runner bridge...",
+        "",
+        "Startup:",
+        `  server: ${config.serverUrl || "not configured"}`,
+        `  runner: ${runner}`,
+        `  config: ${resolveLocalConfigPath()}`,
+        `  repo folder: ${config.defaultRepoRoot || "not configured"}`,
+        `  providers: ${formatList(config.cliProviders)}`,
+        `  cleanup worktrees: ${config.cleanupWorktrees ? "enabled" : "disabled"}`,
+        "",
+        "Press Ctrl+C to stop.",
+        "",
+    ].join("\n");
+}
+function formatList(values) {
+    return values.length > 0 ? values.join(", ") : "none";
 }
 async function writeJsonAtomic(outputPath, value) {
     await fs.mkdir(path.dirname(outputPath), { recursive: true });
@@ -620,6 +715,12 @@ function cliProbeCommandsFor(provider) {
     ];
 }
 async function execVersionCommand(probe, timeout = 2000) {
+    const directLaunch = process.platform === "win32"
+        ? await resolveCursorAgentDirectLaunch(probe.command, probe.args)
+        : null;
+    if (directLaunch) {
+        return await execFileAsync(directLaunch.command, [...directLaunch.args], { timeout });
+    }
     try {
         return await execFileAsync(probe.command, probe.args, { timeout });
     }

package/dist/cli/local-config.d.ts

@@ -16,6 +16,7 @@ export interface BridgeLocalConfig {
     readonly supportsManagedWorktrees?: boolean;
     readonly supportsManagedForgeArtifacts?: boolean;
     readonly supportsRunnerAuthoredPhaseArtifacts?: boolean;
+    readonly supportsDraftRunOnce?: boolean;
 }
 export interface LocalRepoMapping extends BridgeRepoMapping {
     readonly label: string;

package/dist/cli/local-config.js

@@ -53,7 +53,8 @@ export function applyLocalConfigDefaults(config, local) {
         supportsApiSecretGrant: local.supportsApiSecretGrant ?? config.supportsApiSecretGrant,
         supportsManagedWorktrees: local.supportsManagedWorktrees ?? config.supportsManagedWorktrees,
         supportsManagedForgeArtifacts: local.supportsManagedForgeArtifacts ?? config.supportsManagedForgeArtifacts,
-        supportsRunnerAuthoredPhaseArtifacts: local.supportsRunnerAuthoredPhaseArtifacts ?? config.supportsRunnerAuthoredPhaseArtifacts
+        supportsRunnerAuthoredPhaseArtifacts: local.supportsRunnerAuthoredPhaseArtifacts ?? config.supportsRunnerAuthoredPhaseArtifacts,
+        supportsDraftRunOnce: local.supportsDraftRunOnce ?? config.supportsDraftRunOnce
     };
 }
 export async function addRepoMapping(label, repoPath) {
@@ -111,7 +112,8 @@ function normalizeLocalConfig(config) {
         supportsApiSecretGrant: config.supportsApiSecretGrant,
         supportsManagedWorktrees: config.supportsManagedWorktrees,
         supportsManagedForgeArtifacts: config.supportsManagedForgeArtifacts,
-        supportsRunnerAuthoredPhaseArtifacts: config.supportsRunnerAuthoredPhaseArtifacts
+        supportsRunnerAuthoredPhaseArtifacts: config.supportsRunnerAuthoredPhaseArtifacts,
+        supportsDraftRunOnce: config.supportsDraftRunOnce
     };
 }
 function emptyConfig() {
@@ -159,7 +161,8 @@ function normalizeRepoMappings(values) {
             repoId: cleanString(mapping.repoId),
             name: cleanString(mapping.name) ?? label,
             remoteUrl: cleanString(mapping.remoteUrl),
-            localPath: path.resolve(mapping.localPath)
+            localPath: path.resolve(mapping.localPath),
+            qaAppLaunchTarget: normalizeQaAppLaunchTarget(mapping.qaAppLaunchTarget)
         };
     })
         .sort((left, right) => left.label.localeCompare(right.label));
@@ -171,6 +174,22 @@ function normalizeLabel(value) {
     }
     return label;
 }
+function normalizeQaAppLaunchTarget(value) {
+    if (!value)
+        return undefined;
+    const routes = cleanList(value.routes);
+    const normalized = {
+        url: cleanString(value.url),
+        command: cleanString(value.command),
+        working_directory: cleanString(value.working_directory),
+        ready_url: cleanString(value.ready_url),
+        routes,
+        notes: cleanString(value.notes)
+    };
+    return normalized.url || normalized.command || normalized.ready_url || routes?.length
+        ? normalized
+        : undefined;
+}
 function cleanString(value) {
     const clean = value?.trim();
     return clean ? clean : undefined;

package/dist/config.js

@@ -2,7 +2,7 @@ import os from "node:os";
 import path from "node:path";
 export function defaultForgeBridgeConfig() {
     return {
-        defaultRepoRoot: path.join(os.tmpdir(), "forge-phase5-repos"),
+        defaultRepoRoot: path.join(os.tmpdir(), "forge-repos"),
         cleanupWorktrees: true
     };
 }

package/dist/session/index.d.ts

@@ -1,2 +1,4 @@
 export { BridgeSessionService } from "./session.service.js";
+export { buildCompletionToolServerArgs, codexMcpConfigArgs, completionPhaseFromDispatch, expectedCompletionToolName, prepareCompletionToolRuntime, readCompletionArtifact, writeCompletionArtifact } from "./phase-completion.js";
+export type { CompletionArtifactReference, CompletionPhase, CompletionToolRuntime } from "./phase-completion.js";
 export type { SessionService } from "./session.base.js";

package/dist/session/index.js

@@ -1 +1,2 @@
 export { BridgeSessionService } from "./session.service.js";
+export { buildCompletionToolServerArgs, codexMcpConfigArgs, completionPhaseFromDispatch, expectedCompletionToolName, prepareCompletionToolRuntime, readCompletionArtifact, writeCompletionArtifact } from "./phase-completion.js";

package/dist/session/internals.d.ts

@@ -1,6 +1,8 @@
 export { parseRunOnceDispatchPacket, failureResult } from "./session.types.js";
+export { buildCompletionToolServerArgs, codexMcpConfigArgs, completionPhaseFromDispatch, expectedCompletionToolName, prepareCompletionToolRuntime, readCompletionArtifact, writeCompletionArtifact } from "./phase-completion.js";
+export type { CompletionArtifactReference, CompletionPhase, CompletionToolRuntime } from "./phase-completion.js";
 export type { SessionEventSink, SessionService } from "./session.base.js";
-export type { ApiKeySecretGrant, DispatchCycleRun, DispatchExecution, DispatchLease, DispatchSession, DispatchRepo, DispatchServerLocalConfig, DispatchWorkItem, RunOnceDispatchPacket, RunOnceResultPacket, RunnerDispatchArtifact, RunnerDispatchEvent, RunnerDispatchSpec, RunnerEventLine } from "./session.types.js";
+export type { ApiKeySecretGrant, DispatchCycleRun, DispatchExecution, DispatchLease, DispatchPullRequestContext, DispatchSession, DispatchRepo, DispatchServerLocalConfig, DispatchWorkItem, RunOnceDispatchPacket, RunOnceResultPacket, RunnerDispatchArtifact, RunnerDispatchEvent, RunnerDispatchSpec, RunnerEventLine } from "./session.types.js";
 export { DeterministicProviderCliService, ProcessBackedProviderCliService, RoutingProviderCliService, buildProviderCliCommand } from "./provider-cli/provider-cli.service.js";
 export type { ProviderCliService } from "./provider-cli/provider-cli.base.js";
 export type { ProviderCliCommand, ProviderProcessRunner, ProviderProcessRunRequest, ProviderProcessRunResult } from "./provider-cli/provider-cli.service.js";

package/dist/session/internals.js

@@ -1,2 +1,3 @@
 export { parseRunOnceDispatchPacket, failureResult } from "./session.types.js";
+export { buildCompletionToolServerArgs, codexMcpConfigArgs, completionPhaseFromDispatch, expectedCompletionToolName, prepareCompletionToolRuntime, readCompletionArtifact, writeCompletionArtifact } from "./phase-completion.js";
 export { DeterministicProviderCliService, ProcessBackedProviderCliService, RoutingProviderCliService, buildProviderCliCommand } from "./provider-cli/provider-cli.service.js";