@loucompanion/forge-bridge 0.1.3-dev.b6be5e7f9668 → 0.1.3-dev.bca7d0ccee53

package/dist/worktree/artifact-injector.js

@@ -1,4 +1,5 @@
 import crypto from "node:crypto";
+import { spawn } from "node:child_process";
 import fs from "node:fs/promises";
 import path from "node:path";
 const DEBUG_OPERATIONAL_SKILLS = new Set(["debug-repro", "debug-root-cause", "debug-fix", "debug-regression"]);
@@ -36,22 +37,32 @@ const DRAFT_OPERATIONAL_SKILLS = new Set([
     "draft-repo-context",
     "draft-graph-context",
     "draft-product-scope",
-    "draft-work-order-plan",
     "draft-critic",
     "draft-proposal"
 ]);
+const DRAFT_WORK_ITEM_OPERATIONAL_SKILLS = new Set([
+    "draft-work-item-plan"
+]);
+const DRAFT_WORK_ORDER_OPERATIONAL_SKILLS = new Set([
+    "draft-work-order-plan"
+]);
 const DRAFT_OPERATIONAL_HOOKS = new Set([
     "draft-intent",
     "draft-repo-context",
     "draft-graph-context",
     "draft-product-scope",
-    "draft-work-order-plan",
     "draft-critic",
     "draft-proposal"
 ]);
-export async function injectWorktreeArtifacts(worktreePath, artifacts) {
+const DRAFT_WORK_ITEM_OPERATIONAL_HOOKS = new Set([
+    "draft-work-item-plan"
+]);
+const DRAFT_WORK_ORDER_OPERATIONAL_HOOKS = new Set([
+    "draft-work-order-plan"
+]);
+export async function injectWorktreeArtifacts(worktreePath, artifacts, protectedRelativePaths = new Set()) {
     for (const artifact of artifacts) {
-        await writeArtifact(worktreePath, artifact);
+        await writeArtifact(worktreePath, artifact, protectedRelativePaths);
     }
 }
 export function filterArtifactsForLane(artifacts, lane, phase) {
@@ -64,11 +75,11 @@ export function filterArtifactsForLane(artifacts, lane, phase) {
         return artifacts.filter((artifact) => shouldInjectArchitectArtifact(artifact, commandSlug));
     }
     if (normalizedLane === "draft") {
-        return artifacts.filter((artifact) => shouldInjectDraftArtifact(artifact, commandSlug));
+        return artifacts.filter((artifact) => shouldInjectDraftArtifact(artifact, commandSlug, phase));
     }
     return artifacts;
 }
-export async function writeArtifact(worktreePath, artifact) {
+export async function writeArtifact(worktreePath, artifact, protectedRelativePaths = new Set()) {
     const writtenHash = sha256(artifact.body);
     if (writtenHash !== artifact.contentHash.toLowerCase()) {
         throw new Error(`Injected artifact '${artifact.slug}' content_hash mismatch (expected ${artifact.contentHash}, got ${writtenHash}).`);
@@ -83,6 +94,11 @@ export async function writeArtifact(worktreePath, artifact) {
         ? path.resolve(scopeDir, slug, "SKILL.md")
         : path.resolve(scopeDir, `${slug}.md`);
     assertInside(forgeRoot, filePath, "Artifact file");
+    const relativePath = path.relative(worktreePath, filePath).replaceAll(path.sep, "/");
+    if (protectedRelativePaths.has(relativePath)) {
+        await restoreTrackedArtifactIfItMatchesManagedBody(worktreePath, filePath, relativePath, artifact);
+        return;
+    }
     await fs.mkdir(path.dirname(filePath), { recursive: true });
     await fs.writeFile(filePath, artifact.body, "utf8");
 }
@@ -110,6 +126,39 @@ export function resolveCommandSlug(lane, phase) {
             return "dev-prompt";
     }
 }
+async function restoreTrackedArtifactIfItMatchesManagedBody(worktreePath, filePath, relativePath, artifact) {
+    const current = await fs.readFile(filePath, "utf8").catch(() => null);
+    if (current === null
+        || (current !== artifact.body && current !== artifactExecutionBody(artifact)))
+        return;
+    const result = await new Promise((resolve) => {
+        const child = spawn("git", ["show", `HEAD:${relativePath}`], {
+            cwd: worktreePath,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        let stdout = "";
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", chunk => { stdout += chunk; });
+        child.on("error", () => resolve({ exitCode: 1, stdout: "" }));
+        child.on("close", code => resolve({ exitCode: code ?? 1, stdout }));
+    });
+    if (result.exitCode === 0)
+        await fs.writeFile(filePath, result.stdout, "utf8");
+}
+export function artifactExecutionBody(artifact) {
+    const content = artifact.body;
+    if (!content.startsWith("---"))
+        return content;
+    const end = content.indexOf("\n---", 3);
+    if (end < 3)
+        return content;
+    let bodyStart = end + 4;
+    while (bodyStart < content.length && (content[bodyStart] === "\n" || content[bodyStart] === "\r")) {
+        bodyStart += 1;
+    }
+    return content.slice(bodyStart);
+}
 function shouldInjectDebugArtifact(artifact, commandSlug) {
     if (artifact.scope.trim().toLowerCase() !== "operational") {
         return false;
@@ -142,7 +191,7 @@ function shouldInjectArchitectArtifact(artifact, commandSlug) {
             return false;
     }
 }
-function shouldInjectDraftArtifact(artifact, commandSlug) {
+function shouldInjectDraftArtifact(artifact, commandSlug, phase) {
     if (artifact.scope.trim().toLowerCase() !== "operational") {
         return false;
     }
@@ -151,15 +200,38 @@ function shouldInjectDraftArtifact(artifact, commandSlug) {
         case "command":
             return slug === commandSlug;
         case "skill":
-            return DRAFT_OPERATIONAL_SKILLS.has(slug);
+            return DRAFT_OPERATIONAL_SKILLS.has(slug) || draftPhaseSkills(phase).has(slug);
         case "hook":
-            return DRAFT_OPERATIONAL_HOOKS.has(slug);
+            return DRAFT_OPERATIONAL_HOOKS.has(slug) || draftPhaseHooks(phase).has(slug);
         default:
             return false;
     }
 }
+function draftPhaseSkills(phase) {
+    switch (normalizeDraftPhase(phase)) {
+        case "work_order":
+            return DRAFT_WORK_ORDER_OPERATIONAL_SKILLS;
+        case "story":
+            return DRAFT_WORK_ITEM_OPERATIONAL_SKILLS;
+        default:
+            return DRAFT_WORK_ITEM_OPERATIONAL_SKILLS;
+    }
+}
+function draftPhaseHooks(phase) {
+    switch (normalizeDraftPhase(phase)) {
+        case "work_order":
+            return DRAFT_WORK_ORDER_OPERATIONAL_HOOKS;
+        case "story":
+            return DRAFT_WORK_ITEM_OPERATIONAL_HOOKS;
+        default:
+            return DRAFT_WORK_ITEM_OPERATIONAL_HOOKS;
+    }
+}
+function normalizeDraftPhase(phase) {
+    return phase.trim().toLowerCase().replaceAll("-", "_");
+}
 export function buildSpecBody(laneCommand, workItem, phase = "implementation") {
-    const prompt = laneCommand.body.replaceAll("{workItemId}", workItem.id);
+    const prompt = artifactExecutionBody(laneCommand).replaceAll("{workItemId}", workItem.id);
     return `---
 work_item_id: ${workItem.id}
 status: approved

package/dist/worktree/dependency-warmer.d.ts

@@ -22,7 +22,10 @@ export interface WarmDependenciesResult {
     readonly fallbacks: readonly InstallFallbackResult[];
 }
 export interface CommandExecutor {
-    run(cwd: string, command: string, args: readonly string[]): Promise<void>;
+    run(cwd: string, command: string, args: readonly string[], options?: CommandExecutionOptions): Promise<void>;
+}
+export interface CommandExecutionOptions {
+    readonly env?: NodeJS.ProcessEnv;
 }
 export declare function detectWarmPaths(repoRoot: string, warmPathOverrides?: readonly string[]): Promise<WarmPathEntry[]>;
 export declare function warmWorktreeDependencies(request: WarmDependenciesRequest, executor?: CommandExecutor): Promise<WarmDependenciesResult>;
@@ -30,3 +33,20 @@ export declare function createDirectoryLink(sourcePath: string, targetPath: stri
 export declare function lockfilesDiffer(baseCheckoutPath: string, worktreePath: string, packageRootRelative: string): Promise<boolean>;
 export declare function requiresInstallFallback(entry: WarmPathEntry, baseCheckoutPath: string, worktreePath: string, sourceExists: boolean): Promise<string | null>;
 export declare function declaresNativeModules(packageRootPath: string): Promise<boolean>;
+export interface NpmLaunchOptions {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly execPath?: string;
+    readonly platform?: NodeJS.Platform;
+    readonly homeDir?: string;
+    readonly candidates?: readonly string[];
+}
+export declare function resolveNpmLaunch(args: readonly string[], options?: NpmLaunchOptions): {
+    command: string;
+    args: readonly string[];
+};
+export declare function resolvePnpmLaunch(args: readonly string[]): {
+    command: string;
+    args: readonly string[];
+};
+export declare function formatCommandFailureOutput(stdout: string, stderr: string): string;
+export declare function unattendedPackageManagerEnvironment(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;

package/dist/worktree/dependency-warmer.js

@@ -1,6 +1,9 @@
+import { existsSync, realpathSync } from "node:fs";
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { NodeProcessRunner } from "../shared/process/process.js";
+import { buildWindowsCmdLaunch } from "../shared/process/windows-launch.js";
 import { isSubPath } from "../shared/path/path.js";
 const SKIP_DIR_NAMES = new Set([
     ".git",
@@ -20,6 +23,7 @@ const NATIVE_MODULE_HINTS = [
     "better-sqlite3",
     "@swc/core"
 ];
+const MAX_COMMAND_FAILURE_OUTPUT_LENGTH = 8_000;
 export async function detectWarmPaths(repoRoot, warmPathOverrides = []) {
     const entries = new Map();
     await collectDetectedPaths(repoRoot, repoRoot, entries, 0);
@@ -47,10 +51,39 @@ export async function warmWorktreeDependencies(request, executor = defaultComman
     const linked = [];
     const skipped = [];
     const fallbacks = [];
+    const restoredDotNetRoots = new Set();
+    const installedNodeRoots = new Set();
     for (const entry of warmPaths) {
         const sourcePath = path.join(baseCheckoutPath, entry.relativePath);
         const targetPath = path.join(worktreePath, entry.relativePath);
         assertWithinRoot(allowedRoot, targetPath, "Warm target");
+        if (entry.ecosystem === "node" && path.basename(entry.relativePath) === "node_modules") {
+            await removeLegacyDirectoryLink(targetPath, allowedRoot);
+            const installPackageRoot = await resolveNodeInstallPackageRoot(worktreePath, entry.packageRoot);
+            const packageRoot = path.resolve(worktreePath, installPackageRoot === "." ? "" : installPackageRoot);
+            const packageKey = process.platform === "win32" ? packageRoot.toLowerCase() : packageRoot;
+            if (installedNodeRoots.has(packageKey)) {
+                skipped.push(entry.relativePath);
+                continue;
+            }
+            installedNodeRoots.add(packageKey);
+            const install = await runInstallFallback({ ...entry, packageRoot: installPackageRoot }, worktreePath, "Managed worktrees require isolated Node dependencies.", executor);
+            fallbacks.push(install);
+            continue;
+        }
+        if (entry.ecosystem === "dotnet") {
+            await removeLegacyDirectoryLink(targetPath, allowedRoot);
+            const packageRoot = path.resolve(worktreePath, entry.packageRoot === "." ? "" : entry.packageRoot);
+            const packageKey = process.platform === "win32" ? packageRoot.toLowerCase() : packageRoot;
+            if (restoredDotNetRoots.has(packageKey)) {
+                skipped.push(entry.relativePath);
+                continue;
+            }
+            restoredDotNetRoots.add(packageKey);
+            const install = await runInstallFallback(entry, worktreePath, "Managed worktrees require isolated .NET build outputs.", executor);
+            fallbacks.push(install);
+            continue;
+        }
         const sourceExists = await directoryExists(sourcePath);
         const fallbackReason = await resolveFallbackReason(entry, baseCheckoutPath, worktreePath, sourceExists);
         if (fallbackReason) {
@@ -67,6 +100,16 @@ export async function warmWorktreeDependencies(request, executor = defaultComman
     }
     return { linked, skipped, fallbacks };
 }
+async function removeLegacyDirectoryLink(targetPath, allowedRoot) {
+    const resolvedTarget = path.resolve(targetPath);
+    const resolvedRoot = path.resolve(allowedRoot);
+    assertWithinRoot(resolvedRoot, resolvedTarget, "Legacy warm target");
+    const stat = await fs.lstat(resolvedTarget).catch(() => null);
+    if (!stat?.isSymbolicLink()) {
+        return;
+    }
+    await fs.rm(resolvedTarget, { force: true });
+}
 export async function createDirectoryLink(sourcePath, targetPath, allowedRoot) {
     const resolvedSource = path.resolve(sourcePath);
     const resolvedTarget = path.resolve(targetPath);
@@ -78,7 +121,10 @@ export async function createDirectoryLink(sourcePath, targetPath, allowedRoot) {
     if (!stat?.isDirectory()) {
         throw new Error(`Link source must be an existing directory: ${resolvedSource}`);
     }
-    await fs.rm(resolvedTarget, { recursive: true, force: true });
+    const existingTarget = await fs.lstat(resolvedTarget).catch(() => null);
+    await fs.rm(resolvedTarget, existingTarget?.isSymbolicLink()
+        ? { force: true }
+        : { recursive: true, force: true });
     await fs.mkdir(path.dirname(resolvedTarget), { recursive: true });
     if (process.platform === "win32") {
         await fs.symlink(resolvedSource, resolvedTarget, "junction");
@@ -182,9 +228,17 @@ export async function lockfilesDiffer(baseCheckoutPath, worktreePath, packageRoo
 async function runInstallFallback(entry, worktreePath, reason, executor) {
     const cwd = path.join(worktreePath, entry.packageRoot === "." ? "" : entry.packageRoot);
     if (entry.ecosystem === "node") {
+        const pnpmLockPath = path.join(cwd, "pnpm-lock.yaml");
+        if (await pathExists(pnpmLockPath)) {
+            const args = ["install", "--frozen-lockfile"];
+            const launch = resolvePnpmLaunch(args);
+            await executor.run(cwd, launch.command, launch.args, { env: unattendedPackageManagerEnvironment() });
+            return { ecosystem: entry.ecosystem, packageRoot: entry.packageRoot, reason, command: `pnpm ${args.join(" ")}` };
+        }
         const lockPath = path.join(cwd, "package-lock.json");
         const args = (await pathExists(lockPath)) ? ["ci"] : ["install"];
-        await executor.run(cwd, "npm", args);
+        const launch = resolveNpmLaunch(args);
+        await executor.run(cwd, launch.command, launch.args, { env: unattendedPackageManagerEnvironment() });
         return { ecosystem: entry.ecosystem, packageRoot: entry.packageRoot, reason, command: `npm ${args.join(" ")}` };
     }
     if (entry.ecosystem === "python") {
@@ -215,6 +269,23 @@ async function runInstallFallback(entry, worktreePath, reason, executor) {
         command: "dotnet restore"
     };
 }
+async function resolveNodeInstallPackageRoot(worktreePath, packageRoot) {
+    const resolvedWorktree = path.resolve(worktreePath);
+    let current = path.resolve(resolvedWorktree, packageRoot === "." ? "" : packageRoot);
+    assertWithinRoot(resolvedWorktree, current, "Node package root");
+    while (isSubPath(resolvedWorktree, current)) {
+        if (await pathExists(path.join(current, "pnpm-lock.yaml"))
+            || await pathExists(path.join(current, "pnpm-workspace.yaml"))
+            || await pathExists(path.join(current, "package-lock.json"))) {
+            const relative = normalizeRelativePath(path.relative(resolvedWorktree, current));
+            return relative || ".";
+        }
+        if (current === resolvedWorktree)
+            break;
+        current = path.dirname(current);
+    }
+    return packageRoot;
+}
 export async function requiresInstallFallback(entry, baseCheckoutPath, worktreePath, sourceExists) {
     return resolveFallbackReason(entry, baseCheckoutPath, worktreePath, sourceExists);
 }
@@ -286,11 +357,73 @@ async function sha256File(filePath) {
     const content = await fs.readFile(filePath);
     return crypto.createHash("sha256").update(content).digest("hex");
 }
+export function resolveNpmLaunch(args, options = {}) {
+    const env = options.env ?? process.env;
+    const execPath = options.execPath ?? process.execPath;
+    const npmExecPath = env.npm_execpath;
+    if (npmExecPath) {
+        return { command: execPath, args: [npmExecPath, ...args] };
+    }
+    const platform = options.platform ?? process.platform;
+    if (platform === "win32") {
+        const comSpec = options.env ? env.ComSpec ?? "cmd.exe" : env.ComSpec;
+        return buildWindowsCmdLaunch("npm.cmd", args, comSpec);
+    }
+    for (const candidate of options.candidates ?? defaultNpmCliCandidates(execPath, options.homeDir ?? os.homedir())) {
+        const resolvedCandidate = tryResolveNpmCandidate(candidate);
+        if (resolvedCandidate) {
+            return { command: execPath, args: [resolvedCandidate, ...args] };
+        }
+    }
+    return { command: "npm", args };
+}
+export function resolvePnpmLaunch(args) {
+    if (process.platform === "win32") {
+        return buildWindowsCmdLaunch("pnpm.cmd", args, process.env.ComSpec);
+    }
+    return { command: "pnpm", args };
+}
+export function formatCommandFailureOutput(stdout, stderr) {
+    const sections = [
+        stderr.trim().length > 0 ? `stderr:\n${stderr.trim()}` : null,
+        stdout.trim().length > 0 ? `stdout:\n${stdout.trim()}` : null,
+    ].filter((section) => section !== null);
+    const output = sections.join("\n");
+    if (output.length <= MAX_COMMAND_FAILURE_OUTPUT_LENGTH) {
+        return output;
+    }
+    return `[last ${MAX_COMMAND_FAILURE_OUTPUT_LENGTH} characters]\n${output.slice(-MAX_COMMAND_FAILURE_OUTPUT_LENGTH)}`;
+}
+export function unattendedPackageManagerEnvironment(env = process.env) {
+    return { ...env, CI: "true" };
+}
+function tryResolveNpmCandidate(candidate) {
+    try {
+        if (!existsSync(candidate)) {
+            return null;
+        }
+        return realpathSync(candidate);
+    }
+    catch {
+        return null;
+    }
+}
+function defaultNpmCliCandidates(execPath, homeDir) {
+    const candidates = [];
+    const execDir = path.dirname(execPath);
+    if (path.isAbsolute(execDir)) {
+        candidates.push(path.join(execDir, "npm"), path.join(execDir, "npm-cli.js"), path.join(execDir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"));
+    }
+    candidates.push("/usr/bin/npm", "/usr/local/bin/npm", path.join(homeDir, ".npm-global", "bin", "npm"), path.join(homeDir, ".npm-global", "lib", "node_modules", "npm", "bin", "npm-cli.js"));
+    return candidates;
+}
 const defaultCommandExecutor = {
-    async run(cwd, command, args) {
-        const result = await defaultProcessRunner.run({ command, cwd, args });
+    async run(cwd, command, args, options) {
+        const result = await defaultProcessRunner.run({ command, cwd, args, env: options?.env });
         if (result.exitCode !== 0) {
-            throw new Error(`${command} ${args.join(" ")} failed (${result.exitCode}): ${result.stderr.trim()}`);
+            const output = formatCommandFailureOutput(result.stdout, result.stderr);
+            const details = output.length > 0 ? `\n${output}` : " no output was captured";
+            throw new Error(`${command} ${args.join(" ")} failed (${result.exitCode}) in ${cwd}:${details}`);
         }
     }
 };

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,17 +1,23 @@
 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 trackedForgePaths;
+    private repoCreationCoordinationPath;
     release(handle: WorktreeHandle): Promise<void>;
     private resolveRepoPath;
+    private managedRepoPath;
     private findExistingRepoPath;
     private resolveMatchingRepo;
-    private ensureBaseBranch;
+    private resolveBaseStartPoint;
+    private resetWorktreeToBase;
     private gitRefExists;
     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;