@loucompanion/forge-bridge 0.1.3-dev.b3bce6ba65a6 → 0.1.3-dev.ba7d36726eda

package/dist/shared/process/host-process-recovery.js

@@ -0,0 +1,78 @@
+import { captureHostProcessIdentity } from "./host-process-supervisor.js";
+/** Exact, birth-marker-fenced recovery for a process tree left by an old bridge. */
+export class ExactHostProcessRecovery {
+    platform;
+    graceMs;
+    constructor(platform = process.platform, graceMs = 2_000) {
+        this.platform = platform;
+        this.graceMs = graceMs;
+    }
+    async recover(metadata) {
+        if (!processExists(metadata.rootPid))
+            return "absent";
+        if (!metadata.rootIdentity)
+            return "unverifiable";
+        const currentIdentity = captureHostProcessIdentity(metadata.rootPid, this.platform);
+        if (!currentIdentity)
+            return processExists(metadata.rootPid) ? "unverifiable" : "absent";
+        if (currentIdentity !== metadata.rootIdentity)
+            return "pid_reused";
+        if (this.platform === "win32") {
+            signalExactProcess(metadata.rootPid, "SIGTERM");
+        }
+        else {
+            signalExactProcessGroup(metadata.rootPid, "SIGTERM");
+        }
+        await waitForExit(metadata.rootPid, this.graceMs);
+        if (processExists(metadata.rootPid)) {
+            if (captureHostProcessIdentity(metadata.rootPid, this.platform) !== metadata.rootIdentity) {
+                return "pid_reused";
+            }
+            if (this.platform === "win32") {
+                signalExactProcess(metadata.rootPid, "SIGKILL");
+            }
+            else {
+                signalExactProcessGroup(metadata.rootPid, "SIGKILL");
+            }
+            await waitForExit(metadata.rootPid, this.graceMs);
+        }
+        if (processExists(metadata.rootPid)
+            && captureHostProcessIdentity(metadata.rootPid, this.platform) === metadata.rootIdentity) {
+            throw new Error("host_process_recovery_degraded: exact supervised process tree did not stop.");
+        }
+        return "terminated";
+    }
+}
+function processExists(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+function signalExactProcess(pid, signal) {
+    try {
+        process.kill(pid, signal);
+    }
+    catch (error) {
+        if (error.code !== "ESRCH")
+            throw error;
+    }
+}
+function signalExactProcessGroup(pid, signal) {
+    try {
+        process.kill(-pid, signal);
+    }
+    catch (error) {
+        if (error.code !== "ESRCH")
+            throw error;
+    }
+}
+async function waitForExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline && processExists(pid)) {
+        await new Promise(resolve => setTimeout(resolve, 25));
+    }
+}

package/dist/shared/process/host-process-supervisor.d.ts

@@ -0,0 +1,40 @@
+import type { ChildProcess } from "node:child_process";
+export type HostProcessSupervisorStrategy = "windows_job_object" | "unix_process_group";
+export interface HostProcessSupervisionRequest {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly env?: Readonly<Record<string, string>>;
+}
+export interface HostProcessSupervisedLaunch {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly detached: boolean;
+    readonly supervisorId: string;
+    readonly strategy: HostProcessSupervisorStrategy;
+    readonly metadataPath: string;
+    readonly commandDigest: string;
+}
+export interface HostProcessSupervisorMetadata {
+    readonly schemaVersion: 1;
+    readonly supervisorId: string;
+    readonly strategy: HostProcessSupervisorStrategy;
+    readonly rootPid: number;
+    readonly rootCreatedAt: string;
+    readonly rootIdentity?: string | null;
+    readonly commandDigest: string;
+    readonly worktreePath: string;
+    readonly runtimeLeaseId: string;
+    readonly dispatchAttemptId: string;
+    readonly fencingToken: string;
+    readonly bridgePid: number;
+}
+export declare function resolveHostProcessSupervisedLaunch(request: HostProcessSupervisionRequest, resolvedCommand: string, resolvedArgs: readonly string[], platform?: NodeJS.Platform): HostProcessSupervisedLaunch | null;
+export declare function persistHostProcessSupervisorMetadata(launch: HostProcessSupervisedLaunch, request: HostProcessSupervisionRequest, rootPid: number, rootCreatedAt: string): HostProcessSupervisorMetadata;
+/**
+ * Captures an OS-issued process birth marker. Recovery compares this marker
+ * before signalling a persisted PID so PID reuse can never redirect cleanup
+ * at an unrelated process.
+ */
+export declare function captureHostProcessIdentity(pid: number, platform?: NodeJS.Platform): string | null;
+export declare function terminateHostProcessTree(child: ChildProcess, launch: HostProcessSupervisedLaunch | null, graceMs?: number): Promise<void>;

package/dist/shared/process/host-process-supervisor.js

@@ -0,0 +1,195 @@
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const windowsJobSupervisorPath = fileURLToPath(new URL("../../../runtime/windows-job-supervisor.ps1", import.meta.url));
+export function resolveHostProcessSupervisedLaunch(request, resolvedCommand, resolvedArgs, platform = process.platform) {
+    const env = request.env;
+    if (env?.FORGE_RUNTIME_MODE !== "host")
+        return null;
+    const supervisorId = requiredEnvironment(env, "FORGE_PROCESS_SUPERVISOR_ID");
+    const metadataPath = requiredEnvironment(env, "FORGE_PROCESS_SUPERVISOR_METADATA_PATH");
+    const logDirectory = requiredEnvironment(env, "FORGE_LOG_DIR");
+    assertMetadataPath(logDirectory, metadataPath);
+    const commandDigest = createHash("sha256")
+        .update(JSON.stringify([resolvedCommand, ...resolvedArgs]))
+        .digest("hex");
+    if (platform === "win32") {
+        if (!fs.existsSync(windowsJobSupervisorPath)) {
+            throw new Error(`host_process_supervisor_missing: ${windowsJobSupervisorPath}`);
+        }
+        const payload = Buffer.from(JSON.stringify({
+            command: resolvedCommand,
+            args: resolvedArgs,
+            cwd: request.cwd,
+            parentPid: process.pid,
+            supervisorId,
+        }), "utf8").toString("base64");
+        return {
+            command: windowsPowerShellPath(),
+            args: [
+                "-NoLogo",
+                "-NoProfile",
+                "-NonInteractive",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-File",
+                windowsJobSupervisorPath,
+                "-Mode",
+                "Outer",
+                "-Payload",
+                payload,
+            ],
+            detached: false,
+            supervisorId,
+            strategy: "windows_job_object",
+            metadataPath,
+            commandDigest,
+        };
+    }
+    return {
+        command: resolvedCommand,
+        args: resolvedArgs,
+        detached: true,
+        supervisorId,
+        strategy: "unix_process_group",
+        metadataPath,
+        commandDigest,
+    };
+}
+export function persistHostProcessSupervisorMetadata(launch, request, rootPid, rootCreatedAt) {
+    if (!Number.isSafeInteger(rootPid) || rootPid <= 0) {
+        throw new Error("host_process_supervisor_invalid: supervised root PID was not assigned.");
+    }
+    const env = request.env ?? {};
+    const metadata = {
+        schemaVersion: 1,
+        supervisorId: launch.supervisorId,
+        strategy: launch.strategy,
+        rootPid,
+        rootCreatedAt,
+        rootIdentity: captureHostProcessIdentity(rootPid),
+        commandDigest: launch.commandDigest,
+        worktreePath: request.cwd,
+        runtimeLeaseId: requiredEnvironment(env, "FORGE_RESOURCE_LEASE_ID"),
+        dispatchAttemptId: requiredEnvironment(env, "FORGE_DISPATCH_ATTEMPT_ID"),
+        fencingToken: requiredEnvironment(env, "FORGE_FENCING_TOKEN"),
+        bridgePid: process.pid,
+    };
+    fs.writeFileSync(launch.metadataPath, `${JSON.stringify(metadata)}\n`, {
+        encoding: "utf8",
+        flag: "wx",
+        mode: 0o600,
+    });
+    return metadata;
+}
+/**
+ * Captures an OS-issued process birth marker. Recovery compares this marker
+ * before signalling a persisted PID so PID reuse can never redirect cleanup
+ * at an unrelated process.
+ */
+export function captureHostProcessIdentity(pid, platform = process.platform) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return null;
+    try {
+        if (platform === "linux") {
+            const bootId = fs.readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+            const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+            const close = stat.lastIndexOf(")");
+            const fields = close >= 0 ? stat.slice(close + 2).trim().split(/\s+/u) : [];
+            const startTicks = fields[19];
+            return bootId && startTicks && /^\d+$/u.test(startTicks)
+                ? `linux:${bootId}:${startTicks}`
+                : null;
+        }
+        if (platform === "win32") {
+            const output = execFileSync(windowsPowerShellPath(), [
+                "-NoLogo",
+                "-NoProfile",
+                "-NonInteractive",
+                "-Command",
+                `(Get-Process -Id ${pid} -ErrorAction Stop).StartTime.ToUniversalTime().Ticks`,
+            ], {
+                encoding: "utf8",
+                windowsHide: true,
+                timeout: 2_000,
+                stdio: ["ignore", "pipe", "ignore"],
+            }).trim();
+            return /^\d+$/u.test(output) ? `win32:${output}` : null;
+        }
+        // Other Unix variants do not expose a sufficiently strong birth marker
+        // through Node. Fail closed rather than trust a second-resolution ps time.
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function terminateHostProcessTree(child, launch, graceMs = 2_000) {
+    if (!launch) {
+        try {
+            child.kill("SIGTERM");
+        }
+        catch {
+            // The process already settled.
+        }
+        return;
+    }
+    if (launch.strategy === "windows_job_object") {
+        try {
+            child.kill("SIGTERM");
+        }
+        catch {
+            // Closing the launcher is best effort when the Job Object already settled.
+        }
+        return;
+    }
+    const processGroupId = child.pid;
+    if (!processGroupId || !signalUnixProcessGroup(processGroupId, "SIGTERM"))
+        return;
+    await new Promise(resolve => setTimeout(resolve, graceMs));
+    if (unixProcessGroupExists(processGroupId)) {
+        signalUnixProcessGroup(processGroupId, "SIGKILL");
+    }
+}
+function requiredEnvironment(env, name) {
+    const value = env[name]?.trim();
+    if (!value)
+        throw new Error(`host_process_supervisor_invalid: ${name} is required.`);
+    return value;
+}
+function assertMetadataPath(logDirectory, metadataPath) {
+    const root = path.resolve(logDirectory);
+    const target = path.resolve(metadataPath);
+    if (target !== root && !target.startsWith(`${root}${path.sep}`)) {
+        throw new Error("host_process_supervisor_invalid: metadata path must be inside FORGE_LOG_DIR.");
+    }
+}
+function windowsPowerShellPath() {
+    const systemRoot = process.env.SystemRoot?.trim() || "C:\\Windows";
+    const candidate = path.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+    return fs.existsSync(candidate) ? candidate : "powershell.exe";
+}
+function signalUnixProcessGroup(processGroupId, signal) {
+    try {
+        process.kill(-processGroupId, signal);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ESRCH")
+            return false;
+        throw error;
+    }
+}
+function unixProcessGroupExists(processGroupId) {
+    try {
+        process.kill(-processGroupId, 0);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ESRCH")
+            return false;
+        throw error;
+    }
+}

package/dist/shared/provider-capabilities.d.ts

@@ -0,0 +1 @@
+export declare function supportsDraftImageAttachmentsFor(cliProviders: readonly string[]): boolean;

package/dist/shared/provider-capabilities.js

@@ -0,0 +1,3 @@
+export function supportsDraftImageAttachmentsFor(cliProviders) {
+    return cliProviders.some((provider) => provider.trim().toLowerCase() === "codex");
+}

package/dist/shared/redaction/redaction.js

@@ -1,6 +1,9 @@
 const secretKeyPattern = /(api[_-]?key|authorization|bearer|client[_-]?secret|password|secret|token)/i;
 const attachmentContentKeyPattern = /^(textContent|contentBase64)$/i;
 const serializedAttachmentContentPattern = /("(?:textContent|contentBase64)"\s*:\s*")(?:(?:\\.)|[^"\\])*(")/gi;
+const authorizationCredentialPattern = /(\bauthorization\s*[:=]\s*(?:bearer|basic)?\s*)([^"',\s]+)/gi;
+const bearerCredentialPattern = /(\bbearer\s+)([^"',\s]+)/gi;
+const secretAssignmentPattern = /(api[_-]?key|client[_-]?secret|password|secret|token)(\s*["']?\s*[:=]\s*["']?\s*)([^"',\s]+)/gi;
 export function redactSecrets(value, exactSecrets = []) {
     return redactValue(value, exactSecrets);
 }
@@ -12,7 +15,9 @@ export function redactText(value, exactSecrets = []) {
         }
     }
     return redacted
-        .replace(/(api[_-]?key|authorization|bearer|client[_-]?secret|password|secret|token)(["':=\s]+)([^"',\s]+)/gi, "$1$2[REDACTED]")
+        .replace(authorizationCredentialPattern, "$1[REDACTED]")
+        .replace(bearerCredentialPattern, "$1[REDACTED]")
+        .replace(secretAssignmentPattern, "$1$2[REDACTED]")
         .replace(/(sk-[a-zA-Z0-9_-]{12,})/g, "[REDACTED]");
 }
 function redactValue(value, exactSecrets) {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const forgeBridgeVersion = "0.1.3-dev.b3bce6ba65a6";
+export declare const forgeBridgeVersion = "0.1.3-dev.ba7d36726eda";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.3-dev.b3bce6ba65a6";
+export const forgeBridgeVersion = "0.1.3-dev.ba7d36726eda";

package/dist/worktree/index.d.ts

@@ -1,4 +1,5 @@
 export { GitWorktreeService } from "./worktree.service.js";
+export { managedRepoRoot, resolveManagedWorktreeRoot, resolveManagedWorktreeRootForRepo, } from "./worktree-paths.js";
 export { detectWarmPaths, warmWorktreeDependencies, createDirectoryLink, lockfilesDiffer, requiresInstallFallback } from "./dependency-warmer.js";
 export type { WarmDependenciesResult, WarmPathEntry, InstallFallbackResult } from "./dependency-warmer.js";
 export type { WorktreeService } from "./worktree.base.js";

package/dist/worktree/index.js

@@ -1,2 +1,3 @@
 export { GitWorktreeService } from "./worktree.service.js";
+export { managedRepoRoot, resolveManagedWorktreeRoot, resolveManagedWorktreeRootForRepo, } from "./worktree-paths.js";
 export { detectWarmPaths, warmWorktreeDependencies, createDirectoryLink, lockfilesDiffer, requiresInstallFallback } from "./dependency-warmer.js";

package/dist/worktree/prior-phase-artifact-hydrator.d.ts

@@ -0,0 +1,2 @@
+import type { DispatchPriorPhaseArtifact } from "../session/session.types.js";
+export declare function hydratePriorPhaseArtifacts(worktreePath: string, artifacts?: readonly DispatchPriorPhaseArtifact[]): Promise<number>;

package/dist/worktree/prior-phase-artifact-hydrator.js

@@ -0,0 +1,136 @@
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { isSubPath } from "../shared/path/path.js";
+const MAX_ARTIFACT_COUNT = 128;
+const MAX_CONTENT_BYTES = 2 * 1024 * 1024;
+const MAX_TOTAL_BYTES = 12 * 1024 * 1024;
+const phaseFiles = {
+    implementation: {
+        verdict: "implementation.completeness.json",
+        report: "implementation.report.md"
+    },
+    self_review: {
+        verdict: "self-review.report.json",
+        report: "self-review.summary.md"
+    },
+    validation: {
+        verdict: "validation.verdict.json",
+        report: "validation.report.md"
+    }
+};
+export async function hydratePriorPhaseArtifacts(worktreePath, artifacts = []) {
+    if (artifacts.length === 0)
+        return 0;
+    if (artifacts.length > MAX_ARTIFACT_COUNT) {
+        throw new Error(`Prior phase artifact handoff exceeds ${MAX_ARTIFACT_COUNT} artifacts.`);
+    }
+    const targets = new Set();
+    let totalBytes = 0;
+    for (const artifact of artifacts) {
+        const workItemId = safeArtifactSegment(artifact.workItemId, "work item id");
+        const files = phaseFiles[artifact.phase];
+        if (!files) {
+            throw new Error(`Unsupported prior phase artifact phase '${artifact.phase}'.`);
+        }
+        const verdictBytes = Buffer.byteLength(artifact.verdictJson, "utf8");
+        const reportBytes = Buffer.byteLength(artifact.report, "utf8");
+        if (verdictBytes > MAX_CONTENT_BYTES || reportBytes > MAX_CONTENT_BYTES) {
+            throw new Error(`Prior phase artifact '${artifact.artifactId}' exceeds the per-file hydration limit.`);
+        }
+        totalBytes += verdictBytes + reportBytes;
+        if (totalBytes > MAX_TOTAL_BYTES) {
+            throw new Error("Prior phase artifact handoff exceeds the total hydration limit.");
+        }
+        verifyContentHash(artifact.verdictJson, artifact.verdictContentHash, artifact.artifactId, "verdict");
+        verifyContentHash(artifact.report, artifact.reportContentHash, artifact.artifactId, "report");
+        validateVerdict(artifact);
+        const artifactRoot = path.resolve(worktreePath, ".forge", "work-items", workItemId, "artifacts");
+        if (!isSubPath(worktreePath, artifactRoot)) {
+            throw new Error("Prior phase artifact target must stay under the worktree.");
+        }
+        await ensureNoSymlinkPathSegments(worktreePath, artifactRoot);
+        await fs.mkdir(artifactRoot, { recursive: true });
+        await ensureNoSymlinkPathSegments(worktreePath, artifactRoot);
+        const verdictPath = path.join(artifactRoot, files.verdict);
+        const reportPath = path.join(artifactRoot, files.report);
+        const targetKey = verdictPath.toLowerCase();
+        if (targets.has(targetKey)) {
+            throw new Error(`Duplicate prior phase artifact target for work item '${workItemId}' phase '${artifact.phase}'.`);
+        }
+        targets.add(targetKey);
+        await writeAtomic(verdictPath, artifact.verdictJson);
+        await writeAtomic(reportPath, artifact.report);
+    }
+    return artifacts.length;
+}
+function validateVerdict(artifact) {
+    let parsed;
+    try {
+        parsed = JSON.parse(artifact.verdictJson);
+    }
+    catch {
+        throw new Error(`Prior phase artifact '${artifact.artifactId}' verdict is not valid JSON.`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`Prior phase artifact '${artifact.artifactId}' verdict must be a JSON object.`);
+    }
+    const recordedPhase = parsed["phase"];
+    const normalizedPhase = typeof recordedPhase === "string"
+        ? recordedPhase.trim().toLowerCase().replace(/-/g, "_")
+        : "";
+    if (normalizedPhase !== artifact.phase) {
+        throw new Error(`Prior phase artifact '${artifact.artifactId}' phase does not match its verdict.`);
+    }
+}
+function verifyContentHash(content, expected, artifactId, label) {
+    const normalizedExpected = expected.trim().toLowerCase().replace(/^sha256:/, "");
+    if (!/^[0-9a-f]{64}$/.test(normalizedExpected)) {
+        throw new Error(`Prior phase artifact '${artifactId}' ${label} hash is invalid.`);
+    }
+    const actual = createHash("sha256").update(content, "utf8").digest("hex");
+    if (actual !== normalizedExpected) {
+        throw new Error(`Prior phase artifact '${artifactId}' ${label} content_hash mismatch.`);
+    }
+}
+function safeArtifactSegment(value, label) {
+    const trimmed = value.trim();
+    if (!/^[a-zA-Z0-9_-]{1,128}$/.test(trimmed)) {
+        throw new Error(`Prior phase artifact ${label} is not a safe path segment.`);
+    }
+    return trimmed;
+}
+async function writeAtomic(targetPath, content) {
+    const temporaryPath = `${targetPath}.tmp-${randomUUID()}`;
+    try {
+        await fs.writeFile(temporaryPath, content, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        await fs.rename(temporaryPath, targetPath);
+    }
+    finally {
+        await fs.rm(temporaryPath, { force: true }).catch(() => undefined);
+    }
+}
+async function ensureNoSymlinkPathSegments(root, targetPath) {
+    const resolvedRoot = path.resolve(root);
+    const resolvedTarget = path.resolve(targetPath);
+    const relative = path.relative(resolvedRoot, resolvedTarget);
+    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new Error("Prior phase artifact path must stay under the worktree.");
+    }
+    let current = resolvedRoot;
+    for (const segment of relative.split(path.sep)) {
+        if (!segment)
+            continue;
+        current = path.join(current, segment);
+        const stat = await fs.lstat(current).catch((error) => {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        });
+        if (!stat)
+            return;
+        if (stat.isSymbolicLink()) {
+            throw new Error("Prior phase artifact path must not traverse symlinked path segments.");
+        }
+    }
+}

package/dist/worktree/worktree-paths.d.ts

@@ -0,0 +1,4 @@
+export declare function managedRepoRoot(allowedRoot: string): string;
+export declare function resolveManagedWorktreeRoot(allowedRoot: string, repoPath: string): string;
+export declare function resolveManagedWorktreeRootForRepo(repoPath: string, allowedRoot?: string): string;
+export declare function defaultWorktreeCoordinatorStateRoot(): string;

package/dist/worktree/worktree-paths.js

@@ -0,0 +1,30 @@
+import os from "node:os";
+import path from "node:path";
+import { isSubPath } from "../shared/path/path.js";
+export function managedRepoRoot(allowedRoot) {
+    return path.join(path.resolve(allowedRoot), ".forge-worktrees", "_repos");
+}
+export function resolveManagedWorktreeRoot(allowedRoot, repoPath) {
+    const resolvedAllowedRoot = path.resolve(allowedRoot);
+    const resolvedRepoPath = path.resolve(repoPath);
+    const baseName = path.basename(resolvedRepoPath);
+    return isSubPath(managedRepoRoot(resolvedAllowedRoot), resolvedRepoPath)
+        ? path.join(resolvedAllowedRoot, ".forge-worktrees", baseName)
+        : path.join(path.dirname(resolvedRepoPath), ".forge-worktrees", baseName);
+}
+export function resolveManagedWorktreeRootForRepo(repoPath, allowedRoot) {
+    const resolvedRepoPath = path.resolve(repoPath);
+    if (allowedRoot && isSubPath(path.resolve(allowedRoot), resolvedRepoPath)) {
+        return resolveManagedWorktreeRoot(allowedRoot, resolvedRepoPath);
+    }
+    const repoParent = path.dirname(resolvedRepoPath);
+    const managedRoot = path.dirname(repoParent);
+    if (path.basename(repoParent) === "_repos" && path.basename(managedRoot) === ".forge-worktrees") {
+        return path.join(managedRoot, path.basename(resolvedRepoPath));
+    }
+    return path.join(repoParent, ".forge-worktrees", path.basename(resolvedRepoPath));
+}
+export function defaultWorktreeCoordinatorStateRoot() {
+    return process.env.FORGE_SANDBOX_STATE_ROOT
+        ?? path.join(os.homedir(), ".forge", "bridge", "sandboxes");
+}

package/dist/worktree/worktree.base.d.ts

@@ -3,3 +3,6 @@ export interface WorktreeService {
     prepare(request: WorktreePrepareRequest): Promise<WorktreeHandle>;
     release(handle: WorktreeHandle): Promise<void>;
 }
+export interface WorktreeLifecycleCoordinator {
+    withLock<T>(repoPath: string, action: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+}

package/dist/worktree/worktree.service.d.ts

@@ -1,12 +1,15 @@
 import { GitClient } from "../shared/git/git.js";
-import type { WorktreeService } from "./worktree.base.js";
+import type { WorktreeLifecycleCoordinator, WorktreeService } from "./worktree.base.js";
 import type { WorktreeHandle, WorktreePrepareRequest } from "./worktree.types.js";
 export declare class GitWorktreeService implements WorktreeService {
     private readonly git;
-    constructor(git?: GitClient);
+    private readonly coordinator;
+    constructor(git?: GitClient, coordinator?: WorktreeLifecycleCoordinator);
     prepare(request: WorktreePrepareRequest): Promise<WorktreeHandle>;
+    private repoCreationCoordinationPath;
     release(handle: WorktreeHandle): Promise<void>;
     private resolveRepoPath;
+    private managedRepoPath;
     private findExistingRepoPath;
     private resolveMatchingRepo;
     private resolveBaseStartPoint;
@@ -15,4 +18,5 @@ export declare class GitWorktreeService implements WorktreeService {
     private currentBranch;
     private ensureGitIdentity;
 }
+export declare function clearRunArtifactRoots(worktreePath: string, request: WorktreePrepareRequest): Promise<void>;
 export declare function normalizeBranchName(value: string | null | undefined, fallback: string): string;