@loucompanion/forge-bridge 0.1.3-dev.fbe15023cdfe → 0.1.4-dev.04a1e5b9e484

package/dist/cleanup/cleanup.service.d.ts

@@ -10,6 +10,7 @@ export declare class ManagedWorktreeCleanupService implements CleanupService {
     run(request: CleanupRequest): Promise<CleanupResult>;
     private runLocked;
     private listWorktrees;
+    private staleRuntimeReadinessPaths;
     private scanManagedCandidates;
     private readRuntimeLeases;
     private worktreeMetadataRoot;

package/dist/cleanup/cleanup.service.js

@@ -4,9 +4,10 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { RepositoryCoordinatorLock } from "../sandbox/repository-lock.js";
 import { GitClient } from "../shared/git/git.js";
-import { isSubPath, resolveExistingDirectoryPath } from "../shared/path/path.js";
+import { isSubPath, resolveExistingDirectoryPath, resolvePathIdentity } from "../shared/path/path.js";
 import { validRuntimeIsolationLease } from "../runtime/runtime-isolation-lease.js";
 import { defaultWorktreeCoordinatorStateRoot, resolveManagedWorktreeRootForRepo, } from "../worktree/worktree-paths.js";
+const staleRuntimeReadinessAgeMs = 30 * 60 * 1000;
 export class ManagedWorktreeCleanupService {
     stateRoot;
     git;
@@ -17,8 +18,13 @@ export class ManagedWorktreeCleanupService {
         this.coordinator = coordinator;
     }
     async run(request) {
-        const repoPath = await resolveExistingDirectoryPath(request.repoRoot);
-        const worktreeRoot = resolveManagedWorktreeRootForRepo(repoPath, request.allowedRepoRoot);
+        const [repoPath, allowedRepoRoot] = await Promise.all([
+            resolveExistingDirectoryPath(request.repoRoot),
+            request.allowedRepoRoot
+                ? resolvePathIdentity(request.allowedRepoRoot)
+                : Promise.resolve(undefined),
+        ]);
+        const worktreeRoot = resolveManagedWorktreeRootForRepo(repoPath, allowedRepoRoot);
         return await this.coordinator.withLock(repoPath, async () => {
             return await this.runLocked(repoPath, worktreeRoot, request);
         });
@@ -39,11 +45,13 @@ export class ManagedWorktreeCleanupService {
             this.listWorktrees(repoPath),
             this.readRuntimeLeases(),
         ]);
-        const metadataRoot = await this.worktreeMetadataRoot(repoPath);
-        const activeWorktrees = activePaths(listedWorktrees);
-        const activeRuntimePaths = runtimeLeases
+        const activeRuntimePaths = await Promise.all(runtimeLeases
             .filter(lease => lease.state !== "released")
-            .map(lease => path.resolve(lease.worktreePath));
+            .map(lease => resolveRuntimeLeasePath(lease.worktreePath)));
+        const metadataRoot = await this.worktreeMetadataRoot(repoPath);
+        const staleReadinessPaths = await this.staleRuntimeReadinessPaths(listedWorktrees, activeRuntimePaths);
+        const activeWorktrees = activePaths(listedWorktrees)
+            .filter(activePath => !staleReadinessPaths.some(stalePath => samePath(stalePath, activePath)));
         if (request.mode === "all") {
             const protectedPaths = uniquePaths([
                 ...activeWorktrees.filter(activePath => isSubPath(safeRoot, activePath)),
@@ -88,9 +96,14 @@ export class ManagedWorktreeCleanupService {
                 this.listWorktrees(repoPath),
                 this.readRuntimeLeases(),
             ]);
+            const currentRuntimePaths = await Promise.all(currentLeases
+                .filter(lease => lease.state !== "released")
+                .map(lease => resolveRuntimeLeasePath(lease.worktreePath)));
+            const currentStaleReadinessPaths = await this.staleRuntimeReadinessPaths(currentWorktrees, currentRuntimePaths);
             const currentlyProtected = [
-                ...activePaths(currentWorktrees),
-                ...currentLeases.filter(lease => lease.state !== "released").map(lease => path.resolve(lease.worktreePath)),
+                ...activePaths(currentWorktrees)
+                    .filter(activePath => !currentStaleReadinessPaths.some(stalePath => samePath(stalePath, activePath))),
+                ...currentRuntimePaths,
             ];
             if (worktreePathState(candidate, currentlyProtected) !== "none") {
                 continue;
@@ -118,6 +131,24 @@ export class ManagedWorktreeCleanupService {
         const output = await this.git.run(repoPath, ["worktree", "list", "--porcelain", "-z"]);
         return parseWorktreeListing(repoPath, output);
     }
+    async staleRuntimeReadinessPaths(worktrees, runtimePaths) {
+        const stale = [];
+        for (const worktree of worktrees) {
+            if (worktree.prunable || !isRuntimeReadinessWorktree(worktree))
+                continue;
+            if (worktreePathState(worktree.worktreePath, runtimePaths) !== "none")
+                continue;
+            const stat = await fs.stat(worktree.worktreePath).catch(error => {
+                if (isEnoent(error))
+                    return null;
+                throw error;
+            });
+            if (stat && Date.now() - stat.mtimeMs >= staleRuntimeReadinessAgeMs) {
+                stale.push(worktree.worktreePath);
+            }
+        }
+        return stale;
+    }
     async scanManagedCandidates(metadataRoot, worktreeRoot, activeWorktrees, runtimePaths) {
         const candidates = [];
         let protectedWorktrees = 0;
@@ -215,6 +246,28 @@ export class ManagedWorktreeCleanupService {
         return path.join(await fs.realpath(commonDirPath), "worktrees");
     }
 }
+async function resolveRuntimeLeasePath(leasePath) {
+    const resolved = path.resolve(leasePath);
+    const before = await fs.lstat(resolved).catch(error => {
+        if (isEnoent(error))
+            return null;
+        throw error;
+    });
+    if (!before)
+        return await resolvePathIdentity(resolved);
+    if (before.isSymbolicLink() || !before.isDirectory()) {
+        throw new Error(`Refusing managed worktree cleanup because runtime lease path ${resolved} is redirected or is not a directory.`);
+    }
+    const real = await fs.realpath(resolved);
+    const after = await fs.lstat(resolved);
+    if (after.isSymbolicLink()
+        || !after.isDirectory()
+        || (before.dev !== 0 && before.ino !== 0 && after.dev !== 0 && after.ino !== 0
+            && (before.dev !== after.dev || before.ino !== after.ino))) {
+        throw new Error(`Refusing managed worktree cleanup because runtime lease path ${resolved} changed while being resolved.`);
+    }
+    return real;
+}
 async function readRuntimeLedger(target, entryName) {
     const pathStat = await fs.lstat(target).catch(error => {
         if (isEnoent(error))
@@ -399,16 +452,24 @@ function parseWorktreeListing(repoPath, output) {
             current = {
                 worktreePath: path.resolve(path.isAbsolute(rawPath) ? rawPath : path.join(repoPath, rawPath)),
                 prunable: false,
+                branchName: null,
             };
         }
         else if (field.startsWith("prunable") && current) {
             current.prunable = true;
         }
+        else if (field.startsWith("branch ") && current) {
+            current.branchName = field.slice("branch ".length).trim();
+        }
     }
     if (current)
         worktrees.push(current);
     return worktrees;
 }
+function isRuntimeReadinessWorktree(worktree) {
+    return worktree.branchName?.startsWith("refs/heads/runtime-readiness-") === true
+        || path.basename(worktree.worktreePath).startsWith("runtime-readiness-");
+}
 function activePaths(worktrees) {
     return worktrees.filter(entry => !entry.prunable).map(entry => entry.worktreePath);
 }

package/dist/cli/cli.help.js

@@ -60,7 +60,7 @@ export function commandHelpText(command) {
                 "  --repo-root <path>          Folder where bridge-managed repos/worktrees live.",
                 "  --name <name>               Display name for this runner.",
                 "  --fingerprint <value>       Stable device fingerprint override.",
-                "  --cli-provider <list>       Comma-separated providers, e.g. codex,cursor.",
+                "  --cli-provider <list>       Comma-separated providers, e.g. codex,cursor,claude.",
                 "  --cleanup-worktrees         Enable managed worktree cleanup.",
                 "  --no-cleanup-worktrees      Disable managed worktree cleanup.",
                 "",
@@ -81,7 +81,7 @@ export function commandHelpText(command) {
                 "  --runner-id <id>            Runner id; saved config is used when omitted.",
                 "  --device-token <token>      Device token; saved config is used when omitted.",
                 "  --repo-root <path>          Override repo/worktree folder for this run.",
-                "  --cli-provider <list>       Comma-separated providers, e.g. codex,cursor.",
+                "  --cli-provider <list>       Comma-separated providers, e.g. codex,cursor,claude.",
                 "  --heartbeat-interval-ms <n> Heartbeat interval in milliseconds.",
                 "  --cleanup-worktrees         Enable managed worktree cleanup for this run.",
                 "  --no-cleanup-worktrees      Disable managed worktree cleanup for this run.",

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

@@ -1,15 +1,20 @@
+import { type DotNetToolchainSelection } from "../shared/process/dotnet-toolchain.js";
 import type { BridgeService } from "../bridge/bridge.base.js";
 import type { BridgeServiceConfig } from "../bridge/bridge.types.js";
 import type { CleanupMode } from "../cleanup/cleanup.types.js";
 import type { CleanupService } from "../cleanup/cleanup.base.js";
 import type { SessionService } from "../session/session.base.js";
 import type { CliIo, CliService } from "./cli.base.js";
+type DotNetToolchainConfigurator = (repoRoots: readonly string[], options?: {
+    readonly cloneFolders?: readonly string[];
+}) => Promise<DotNetToolchainSelection | null>;
 export declare class ForgeBridgeCliService implements CliService {
     private readonly sessions;
     private readonly bridgeFactory;
     private readonly pairRunner;
     private readonly cleanupFactory;
-    constructor(sessions?: SessionService, bridgeFactory?: (config: BridgeServiceConfig) => BridgeService, pairRunner?: PairRunnerClient, cleanupFactory?: CleanupServiceFactory);
+    private readonly dotNetToolchainConfigurator;
+    constructor(sessions?: SessionService, bridgeFactory?: (config: BridgeServiceConfig) => BridgeService, pairRunner?: PairRunnerClient, cleanupFactory?: CleanupServiceFactory, dotNetToolchainConfigurator?: DotNetToolchainConfigurator);
     run(argv: readonly string[], io?: CliIo): Promise<number>;
 }
 export declare function parseArgs(argv: readonly string[]): {
@@ -21,11 +26,7 @@ export declare function parseArgs(argv: readonly string[]): {
     readonly ok: true;
     readonly command: "mcp";
     readonly argv: readonly string[];
-} | {
-    readonly ok: true;
-    readonly command: "connect";
-    readonly config: BridgeServiceConfig;
-} | ({
+} | ConnectArgs | ({
     readonly ok: true;
     readonly command: "pair";
 } & PairArgs) | {
@@ -89,6 +90,12 @@ export declare function parseArgs(argv: readonly string[]): {
     readonly ok: false;
     readonly error: string;
 };
+interface ConnectArgs {
+    readonly ok: true;
+    readonly command: "connect";
+    readonly config: BridgeServiceConfig;
+    readonly implicitCloneDestination: boolean;
+}
 interface PairArgs {
     readonly serverUrl: string;
     readonly code?: string;
@@ -104,6 +111,7 @@ interface PairRunnerClaim {
     readonly deviceToken: string;
 }
 type PairRunnerClient = (args: PairArgs) => Promise<PairRunnerClaim>;
+export declare const claudeDefaultModels: readonly string[];
 export declare function parseCodexModelCatalog(raw: string): string[];
 export declare function parseCursorModelList(raw: string): string[];
 type CleanupServiceFactory = (stateRoot: string) => CleanupService;

package/dist/cli/cli.service.js

@@ -6,6 +6,7 @@ import { createInterface } from "node:readline/promises";
 import { promisify } from "node:util";
 import { resolveCursorAgentDirectLaunch } from "../shared/cursor-agent/cursor-agent.launch.js";
 import { buildWindowsCmdLaunch } from "../shared/process/windows-launch.js";
+import { configureDotNetToolchain } from "../shared/process/dotnet-toolchain.js";
 import { supportsDraftImageAttachmentsFor } from "../shared/provider-capabilities.js";
 import { redactText } from "../shared/redaction/redaction.js";
 import { defaultBridgeServiceConfig, ForgeBridgeService } from "../bridge/bridge.service.js";
@@ -19,7 +20,7 @@ import { DockerPreflight } from "../sandbox/preflight.js";
 import { DockerSandboxRuntime } from "../sandbox/runtime.js";
 import { DockerSandboxSmoke } from "../sandbox/smoke.js";
 import { parseCompletionMcpArgs, runCompletionMcpServer } from "../session/phase-completion.js";
-import { failureResult, parseRunOnceDispatchPacket } from "../session/session.types.js";
+import { failureFactsFromError, failureResult, parseRunOnceDispatchPacket } from "../session/session.types.js";
 import { commandHelpText, helpText } from "./cli.help.js";
 const apiKeySecretGrantEnv = "FORGE_API_KEY_SECRET_GRANT";
 const execFileAsync = promisify(execFile);
@@ -28,11 +29,13 @@ export class ForgeBridgeCliService {
     bridgeFactory;
     pairRunner;
     cleanupFactory;
-    constructor(sessions = new BridgeSessionService(), bridgeFactory = (config) => new ForgeBridgeService(config), pairRunner = claimBridgeRunner, cleanupFactory = stateRoot => new ManagedWorktreeCleanupService(stateRoot)) {
+    dotNetToolchainConfigurator;
+    constructor(sessions = new BridgeSessionService(), bridgeFactory = (config) => new ForgeBridgeService(config), pairRunner = claimBridgeRunner, cleanupFactory = stateRoot => new ManagedWorktreeCleanupService(stateRoot), dotNetToolchainConfigurator = configureDotNetToolchain) {
         this.sessions = sessions;
         this.bridgeFactory = bridgeFactory;
         this.pairRunner = pairRunner;
         this.cleanupFactory = cleanupFactory;
+        this.dotNetToolchainConfigurator = dotNetToolchainConfigurator;
     }
     async run(argv, io = { stdout: process.stdout, stderr: process.stderr }) {
         if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
@@ -67,11 +70,26 @@ export class ForgeBridgeCliService {
                 io.stderr.write(`forge-bridge connect requires ${missing[0]}.\n`);
                 return 2;
             }
+            let dotNetToolchain;
+            try {
+                dotNetToolchain = await this.dotNetToolchainConfigurator(await dotNetPreflightRoots(config, args.implicitCloneDestination), { cloneFolders: [config.defaultRepoRoot.trim()].filter(Boolean) });
+            }
+            catch (error) {
+                io.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                return 1;
+            }
+            if (dotNetToolchain) {
+                io.stdout.write(`Using .NET SDK ${dotNetToolchain.sdkVersion}: ${dotNetToolchain.executablePath}\n`);
+            }
             const controller = new AbortController();
             const stop = () => controller.abort("signal received");
             process.once("SIGINT", stop);
             process.once("SIGTERM", stop);
             try {
+                if (config.cleanupWorktrees && config.repoMappings.some(mapping => mapping.localPath?.trim())) {
+                    io.stdout.write("Cleaning stale managed worktrees before accepting dispatches.\n");
+                    await cleanupRepos(config, "stale", true, this.cleanupFactory(config.sandboxStateRoot), io);
+                }
                 io.stdout.write(connectStartupText(config));
                 await this.bridgeFactory(config).run(controller.signal);
                 return 0;
@@ -216,7 +234,7 @@ export class ForgeBridgeCliService {
         }
         catch (error) {
             const summary = redactText(error instanceof Error ? error.message : String(error), redactionSecrets);
-            await writeJsonAtomic(args.resultPath, failureResult(summary)).catch(() => undefined);
+            await writeJsonAtomic(args.resultPath, redactRunOnceResultPacket(failureResult(summary, [], failureFactsFromError(error, { source: "bridge" })), redactionSecrets)).catch(() => undefined);
             io.stderr.write(`${summary}\n`);
             return 1;
         }
@@ -582,6 +600,28 @@ async function reapSandboxes(io) {
         await preflight.release();
     }
 }
+async function dotNetPreflightRoots(config, implicitCloneDestination) {
+    const roots = config.repoMappings.map((mapping) => mapping.localPath?.trim())
+        .filter((repoRoot) => Boolean(repoRoot));
+    const defaultRoot = config.defaultRepoRoot.trim();
+    if (!defaultRoot)
+        return roots;
+    if (implicitCloneDestination) {
+        try {
+            // The built-in clone destination need not exist on first connect. lstat
+            // deliberately retains dangling links for the strict SDK scanner to reject.
+            // Explicit mappings (including this same path) remain required inputs.
+            await fs.lstat(defaultRoot);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return roots;
+            throw error;
+        }
+    }
+    roots.push(defaultRoot);
+    return roots;
+}
 function parseConnectArgs(argv) {
     let serverUrl = null;
     let runnerId = null;
@@ -651,7 +691,10 @@ function parseConnectArgs(argv) {
     return {
         ok: true,
         command: "connect",
-        config: configuredBridgeServiceConfig(overrides, localConfig)
+        config: configuredBridgeServiceConfig(overrides, localConfig),
+        implicitCloneDestination: repoRoot === null
+            && process.env.FORGE_REPO_ROOT === undefined
+            && localConfig.defaultRepoRoot === undefined,
     };
 }
 function parsePairArgs(argv) {
@@ -714,7 +757,7 @@ function parsePairArgs(argv) {
         name: name?.trim() || defaultName,
         fingerprint: fingerprint?.trim() || `local-bridge:${os.hostname()}:${user}`,
         repoRoot: repoRoot?.trim() ? path.resolve(repoRoot) : undefined,
-        cleanupWorktrees: cleanupWorktrees ?? localConfig.cleanupWorktrees ?? false,
+        cleanupWorktrees: cleanupWorktrees ?? defaultConfig.cleanupWorktrees,
         cliProviders: cliProviders.length > 0 ? cliProviders : localConfig.cliProviders && localConfig.cliProviders.length > 0 ? [...localConfig.cliProviders] : ["codex"],
         projectLabels: projectLabels.length > 0 ? projectLabels : localConfig.projectLabels ? [...localConfig.projectLabels] : []
     };
@@ -869,6 +912,7 @@ function connectStartupText(config) {
         `  repo folder: ${config.defaultRepoRoot || "not configured"}`,
         `  providers: ${formatList(config.cliProviders)}`,
         `  cleanup worktrees: ${config.cleanupWorktrees ? "enabled" : "disabled"}`,
+        `  Docker Desktop auto-recovery: ${config.dockerDesktopRecoveryEnabled ? "enabled" : "disabled"}`,
         `  open public sandbox networking: ${config.allowOpenPublicSandbox ? "enabled" : "disabled"}`,
         "",
         "Press Ctrl+C to stop.",
@@ -900,7 +944,7 @@ async function writeJsonAtomic(outputPath, value) {
     await fs.rename(tempPath, outputPath);
 }
 async function writeStatus(config, checkUpdates, io) {
-    const detected = await detectCliProviders([...new Set([...config.cliProviders, "codex", "cursor"])]);
+    const detected = await detectCliProviders([...new Set([...config.cliProviders, "codex", "cursor", "claude"])]);
     const repos = config.repoMappings.filter((mapping) => mapping.localPath?.trim());
     io.stdout.write(`Forge bridge ${config.version}\n`);
     io.stdout.write(`Config: ${resolveLocalConfigPath()}\n`);
@@ -973,7 +1017,7 @@ async function detectCliProviders(providers) {
         let detected = null;
         for (const probe of cliProbeCommandsFor(provider)) {
             try {
-                detected = await execVersionCommand(probe);
+                detected = await execVersionCommand(probe, probe.timeoutMs);
                 break;
             }
             catch {
@@ -997,6 +1041,13 @@ function cliProbeCommandsFor(provider) {
             { command: "codex", args: ["--version"] }
         ];
     }
+    if (normalized === "claude") {
+        return [
+            // Claude Code's Node startup can exceed the default 2s probe on a cold Windows host.
+            { command: "claude", args: ["--version"], timeoutMs: 8000 },
+            { command: "claude", args: ["-v"], timeoutMs: 8000 }
+        ];
+    }
     if (normalized === "cursor") {
         return [
             { command: "cursor-agent", args: ["-v"] },
@@ -1010,22 +1061,22 @@ function cliProbeCommandsFor(provider) {
         { command: provider, args: ["-V"] }
     ];
 }
-async function execVersionCommand(probe, timeout = 2000) {
+async function execVersionCommand(probe, timeout = 2000, maxBuffer) {
     const directLaunch = process.platform === "win32"
         ? await resolveCursorAgentDirectLaunch(probe.command, probe.args)
         : null;
     if (directLaunch) {
-        return await execFileAsync(directLaunch.command, [...directLaunch.args], { timeout });
+        return await execFileAsync(directLaunch.command, [...directLaunch.args], { timeout, maxBuffer });
     }
     try {
-        return await execFileAsync(probe.command, probe.args, { timeout });
+        return await execFileAsync(probe.command, probe.args, { timeout, maxBuffer });
     }
     catch (error) {
         if (process.platform !== "win32") {
             throw error;
         }
         const launch = buildWindowsCmdLaunch(probe.command, probe.args);
-        return await execFileAsync(launch.command, [...launch.args], { timeout });
+        return await execFileAsync(launch.command, [...launch.args], { timeout, maxBuffer });
     }
 }
 function versionLine(output) {
@@ -1040,19 +1091,26 @@ async function detectCliModels(provider) {
     const normalized = provider.toLowerCase();
     try {
         if (normalized === "codex") {
-            const result = await execFileAsync("codex", ["debug", "models"], { timeout: 5000, maxBuffer: 10 * 1024 * 1024 });
+            // Windows installs codex as a .cmd shim, which execFile cannot launch directly.
+            const result = await execVersionCommand({ command: "codex", args: ["debug", "models"] }, 10_000, 10 * 1024 * 1024);
             return parseCodexModelCatalog(result.stdout);
         }
         if (normalized === "cursor") {
             const result = await execVersionCommand({ command: "cursor-agent", args: ["models"] }, 10_000);
             return parseCursorModelList(`${result.stdout || result.stderr}`);
         }
+        if (normalized === "claude") {
+            // Claude Code has no model-listing command; it accepts these aliases and full model IDs.
+            const configured = splitCsv(process.env.FORGE_CLAUDE_MODELS ?? "");
+            return configured.length > 0 ? configured : [...claudeDefaultModels];
+        }
     }
     catch {
         return [];
     }
     return [];
 }
+export const claudeDefaultModels = ["sonnet", "opus", "haiku"];
 export function parseCodexModelCatalog(raw) {
     try {
         const parsed = JSON.parse(raw);
@@ -1105,8 +1163,8 @@ function uniqueModels(models) {
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
-async function withDetectedCliProviders(config) {
-    const detected = await detectCliProviders(configuredProviderCandidates(config.cliProviders));
+async function withDetectedCliProviders(config, candidates = config.cliProviders) {
+    const detected = await detectCliProviders(uniqueProviders(candidates));
     const found = detected.filter((result) => result.found);
     if (found.length === 0) {
         return config;
@@ -1130,6 +1188,7 @@ async function withDetectedCliProviders(config) {
     };
 }
 async function withDetectedPairCliProviders(args) {
+    const configured = configuredProviderCandidates(args.cliProviders);
     const detectedConfig = await withDetectedCliProviders({
         ...defaultBridgeServiceConfig({
             serverUrl: args.serverUrl,
@@ -1139,14 +1198,14 @@ async function withDetectedPairCliProviders(args) {
             cleanupWorktrees: args.cleanupWorktrees,
             defaultRepoRoot: args.repoRoot ?? defaultBridgeServiceConfig().defaultRepoRoot
         })
-    });
+    }, configured);
     return {
         ...args,
         cliProviders: detectedConfig.cliProviders
     };
 }
 function configuredProviderCandidates(providers) {
-    return uniqueProviders([...providers, "codex", "cursor"]);
+    return uniqueProviders([...providers, "codex", "cursor", "claude"]);
 }
 function uniqueProviders(providers) {
     return providers

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

@@ -8,6 +8,7 @@ export interface BridgeLocalConfig {
     readonly defaultRepoRoot?: string;
     readonly cleanupWorktrees?: boolean;
     readonly dockerEnabled?: boolean;
+    readonly dockerDesktopRecoveryEnabled?: boolean;
     readonly allowOpenPublicSandbox?: boolean;
     readonly cliProviders?: readonly string[];
     readonly providerStatuses?: Readonly<Record<string, BridgeProviderStatus>>;

package/dist/cli/local-config.js

@@ -48,6 +48,9 @@ export function applyLocalConfigDefaults(config, local) {
         dockerEnabled: process.env.FORGE_DOCKER_SANDBOX === undefined
             ? local.dockerEnabled ?? config.dockerEnabled
             : config.dockerEnabled,
+        dockerDesktopRecoveryEnabled: process.env.FORGE_DOCKER_DESKTOP_AUTO_RECOVERY === undefined
+            ? local.dockerDesktopRecoveryEnabled ?? config.dockerDesktopRecoveryEnabled
+            : config.dockerDesktopRecoveryEnabled,
         allowOpenPublicSandbox: process.env.FORGE_ALLOW_OPEN_PUBLIC_SANDBOX === undefined
             ? local.allowOpenPublicSandbox ?? config.allowOpenPublicSandbox
             : config.allowOpenPublicSandbox,
@@ -126,6 +129,7 @@ function normalizeLocalConfig(config) {
         defaultRepoRoot: cleanString(config.defaultRepoRoot),
         cleanupWorktrees: config.cleanupWorktrees,
         dockerEnabled: config.dockerEnabled,
+        dockerDesktopRecoveryEnabled: config.dockerDesktopRecoveryEnabled,
         allowOpenPublicSandbox: config.allowOpenPublicSandbox,
         cliProviders: cleanList(config.cliProviders),
         providerStatuses: normalizeProviderStatuses(config.providerStatuses),

package/dist/runtime/aspnet-runtime-prebuild.d.ts

@@ -0,0 +1,36 @@
+export interface AspNetRuntimePrebuildPlan {
+    readonly fingerprint: string;
+    readonly receiptPath: string;
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly environment: Readonly<Record<string, string>>;
+    readonly projectPath: string;
+    readonly worktreePath: string;
+    readonly inputCommitSha: string;
+}
+export interface AspNetRuntimePrebuildResult {
+    readonly cacheHit: boolean;
+    readonly receiptPath: string;
+    readonly fingerprint: string;
+}
+export interface AspNetRuntimeBuildExecutionResult {
+    readonly exitCode: number;
+    readonly stdoutTail: string;
+    readonly stderrTail: string;
+    readonly stdoutLogPath: string;
+    readonly stderrLogPath: string;
+}
+export type AspNetRuntimeBuildExecutor = (plan: AspNetRuntimePrebuildPlan, signal?: AbortSignal) => Promise<AspNetRuntimeBuildExecutionResult>;
+export declare function createAspNetRuntimePrebuildPlan(options: {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly worktreePath: string;
+    readonly environment?: Readonly<Record<string, string>>;
+    readonly inputCommitSha: string;
+    readonly runtimeContractFingerprint: string;
+}): AspNetRuntimePrebuildPlan | null;
+export declare function ensureAspNetRuntimePrebuilt(plan: AspNetRuntimePrebuildPlan, execute: AspNetRuntimeBuildExecutor, signal?: AbortSignal): Promise<AspNetRuntimePrebuildResult>;
+export declare function withAspNetPrebuiltRunArguments(command: string, args: readonly string[]): readonly string[];
+export declare function resolveWorktreeCommitSha(worktreePath: string, supplied?: string | null): Promise<string>;