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

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

@@ -13,8 +13,21 @@ export interface HostProcessSupervisedLaunch {
     readonly supervisorId: string;
     readonly strategy: HostProcessSupervisorStrategy;
     readonly metadataPath: string;
+    readonly payloadPath?: string;
+    readonly readyPath?: string;
+    readonly startGrantPath?: string;
     readonly commandDigest: string;
 }
+export interface HostProcessProviderReady {
+    readonly schemaVersion: 1;
+    readonly supervisorId: string;
+    readonly rootPid?: number;
+    readonly rootIdentity?: string | null;
+    readonly providerPid: number;
+    readonly providerCreatedAt: string;
+    readonly providerIdentity?: string | null;
+    readonly startAttempt: number;
+}
 export interface HostProcessSupervisorMetadata {
     readonly schemaVersion: 1;
     readonly supervisorId: string;
@@ -28,9 +41,13 @@ export interface HostProcessSupervisorMetadata {
     readonly dispatchAttemptId: string;
     readonly fencingToken: string;
     readonly bridgePid: number;
+    readonly providerPid?: number;
+    readonly providerCreatedAt?: string;
+    readonly providerIdentity?: string | null;
+    readonly providerStartAttempt?: 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;
+export declare function persistHostProcessSupervisorMetadata(launch: HostProcessSupervisedLaunch, request: HostProcessSupervisionRequest, rootPid: number, rootCreatedAt: string, providerReady?: HostProcessProviderReady): HostProcessSupervisorMetadata;
 /**
  * Captures an OS-issued process birth marker. Recovery compares this marker
  * before signalling a persisted PID so PID reuse can never redirect cleanup

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

@@ -19,13 +19,22 @@ export function resolveHostProcessSupervisedLaunch(request, resolvedCommand, res
         if (!fs.existsSync(windowsJobSupervisorPath)) {
             throw new Error(`host_process_supervisor_missing: ${windowsJobSupervisorPath}`);
         }
-        const payload = Buffer.from(JSON.stringify({
+        const payloadPath = `${metadataPath}.launch.json`;
+        const readyPath = `${metadataPath}.provider-ready.json`;
+        const startGrantPath = `${metadataPath}.provider-start-granted`;
+        fs.writeFileSync(payloadPath, `${JSON.stringify({
             command: resolvedCommand,
             args: resolvedArgs,
             cwd: request.cwd,
             parentPid: process.pid,
             supervisorId,
-        }), "utf8").toString("base64");
+            readyPath,
+            startGrantPath,
+        })}\n`, {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o600,
+        });
         return {
             command: windowsPowerShellPath(),
             args: [
@@ -38,13 +47,16 @@ export function resolveHostProcessSupervisedLaunch(request, resolvedCommand, res
                 windowsJobSupervisorPath,
                 "-Mode",
                 "Outer",
-                "-Payload",
-                payload,
+                "-PayloadPath",
+                payloadPath,
             ],
             detached: false,
             supervisorId,
             strategy: "windows_job_object",
             metadataPath,
+            payloadPath,
+            readyPath,
+            startGrantPath,
             commandDigest,
         };
     }
@@ -58,7 +70,7 @@ export function resolveHostProcessSupervisedLaunch(request, resolvedCommand, res
         commandDigest,
     };
 }
-export function persistHostProcessSupervisorMetadata(launch, request, rootPid, rootCreatedAt) {
+export function persistHostProcessSupervisorMetadata(launch, request, rootPid, rootCreatedAt, providerReady) {
     if (!Number.isSafeInteger(rootPid) || rootPid <= 0) {
         throw new Error("host_process_supervisor_invalid: supervised root PID was not assigned.");
     }
@@ -69,13 +81,20 @@ export function persistHostProcessSupervisorMetadata(launch, request, rootPid, r
         strategy: launch.strategy,
         rootPid,
         rootCreatedAt,
-        rootIdentity: captureHostProcessIdentity(rootPid),
+        rootIdentity: providerReady?.rootPid === rootPid
+            ? providerReady.rootIdentity ?? null
+            : 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,
+        providerPid: providerReady?.providerPid,
+        providerCreatedAt: providerReady?.providerCreatedAt,
+        providerIdentity: providerReady?.providerIdentity
+            ?? (providerReady ? captureHostProcessIdentity(providerReady.providerPid) : undefined),
+        providerStartAttempt: providerReady?.startAttempt,
     };
     fs.writeFileSync(launch.metadataPath, `${JSON.stringify(metadata)}\n`, {
         encoding: "utf8",
@@ -113,7 +132,7 @@ export function captureHostProcessIdentity(pid, platform = process.platform) {
             ], {
                 encoding: "utf8",
                 windowsHide: true,
-                timeout: 2_000,
+                timeout: 10_000,
                 stdio: ["ignore", "pipe", "ignore"],
             }).trim();
             return /^\d+$/u.test(output) ? `win32:${output}` : null;
@@ -137,12 +156,34 @@ export async function terminateHostProcessTree(child, launch, graceMs = 2_000) {
         return;
     }
     if (launch.strategy === "windows_job_object") {
+        const rootPid = child.pid ?? 0;
+        const metadata = readSupervisorMetadata(launch.metadataPath);
+        const rootIdentity = metadata?.rootPid === rootPid
+            ? metadata.rootIdentity ?? null
+            : captureHostProcessIdentity(rootPid, "win32");
         try {
             child.kill("SIGTERM");
         }
         catch {
             // Closing the launcher is best effort when the Job Object already settled.
         }
+        await waitForExactProcessExit(rootPid, rootIdentity, graceMs, "win32");
+        if (exactProcessExists(rootPid, rootIdentity, "win32")) {
+            forceWindowsProcessTree(rootPid);
+            await waitForExactProcessExit(rootPid, rootIdentity, graceMs, "win32");
+        }
+        if (exactProcessExists(rootPid, rootIdentity, "win32")) {
+            throw new Error("host_process_supervisor_termination_failed: supervised Windows root did not stop.");
+        }
+        const providerPid = metadata?.providerPid ?? 0;
+        const providerIdentity = metadata?.providerIdentity ?? null;
+        if (exactProcessExists(providerPid, providerIdentity, "win32")) {
+            forceWindowsProcessTree(providerPid);
+            await waitForExactProcessExit(providerPid, providerIdentity, graceMs, "win32");
+        }
+        if (exactProcessExists(providerPid, providerIdentity, "win32")) {
+            throw new Error("host_process_supervisor_termination_failed: supervised Windows provider tree did not stop.");
+        }
         return;
     }
     const processGroupId = child.pid;
@@ -193,3 +234,49 @@ function unixProcessGroupExists(processGroupId) {
         throw error;
     }
 }
+function readSupervisorMetadata(metadataPath) {
+    try {
+        return JSON.parse(fs.readFileSync(metadataPath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function exactProcessExists(pid, identity, platform) {
+    if (!identity || !processExists(pid))
+        return false;
+    return captureHostProcessIdentity(pid, platform) === identity;
+}
+function processExists(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+async function waitForExactProcessExit(pid, identity, timeoutMs, platform) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline && exactProcessExists(pid, identity, platform)) {
+        await new Promise(resolve => setTimeout(resolve, 25));
+    }
+}
+function forceWindowsProcessTree(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return;
+    const systemRoot = process.env.SystemRoot?.trim() || "C:\\Windows";
+    const taskkill = path.win32.join(systemRoot, "System32", "taskkill.exe");
+    try {
+        execFileSync(taskkill, ["/PID", String(pid), "/T", "/F"], {
+            windowsHide: true,
+            timeout: 5_000,
+            stdio: "ignore",
+        });
+    }
+    catch {
+        // A racing process exit is verified by the caller before it returns.
+    }
+}

package/dist/shared/process/process.d.ts

@@ -2,6 +2,7 @@ export interface ProcessRunRequest {
     readonly command: string;
     readonly args: readonly string[];
     readonly cwd: string;
+    readonly env?: NodeJS.ProcessEnv;
 }
 export interface ProcessRunResult {
     readonly exitCode: number;

package/dist/shared/process/process.js

@@ -5,6 +5,7 @@ export class NodeProcessRunner {
         return await new Promise((resolve, reject) => {
             const child = spawn(request.command, request.args, {
                 cwd: request.cwd,
+                env: request.env,
                 stdio: ["ignore", "pipe", "pipe"]
             });
             let stdout = "";

package/dist/version.d.ts

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

package/dist/version.js

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

package/dist/worktree/artifact-injector.d.ts

@@ -1,9 +1,10 @@
 import type { DispatchResolvedArtifact } from "../session/session.types.js";
-export declare function injectWorktreeArtifacts(worktreePath: string, artifacts: readonly DispatchResolvedArtifact[]): Promise<void>;
+export declare function injectWorktreeArtifacts(worktreePath: string, artifacts: readonly DispatchResolvedArtifact[], protectedRelativePaths?: ReadonlySet<string>): Promise<void>;
 export declare function filterArtifactsForLane(artifacts: readonly DispatchResolvedArtifact[], lane: string, phase: string): readonly DispatchResolvedArtifact[];
-export declare function writeArtifact(worktreePath: string, artifact: DispatchResolvedArtifact): Promise<void>;
+export declare function writeArtifact(worktreePath: string, artifact: DispatchResolvedArtifact, protectedRelativePaths?: ReadonlySet<string>): Promise<void>;
 export declare function selectLaneCommand(artifacts: readonly DispatchResolvedArtifact[], lane: string, phase: string): DispatchResolvedArtifact | undefined;
 export declare function resolveCommandSlug(lane: string, phase: string): string;
+export declare function artifactExecutionBody(artifact: DispatchResolvedArtifact): string;
 export declare function buildSpecBody(laneCommand: DispatchResolvedArtifact, workItem: {
     readonly id: string;
     readonly title: string;

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"]);
@@ -59,9 +60,9 @@ const DRAFT_WORK_ITEM_OPERATIONAL_HOOKS = new Set([
 const DRAFT_WORK_ORDER_OPERATIONAL_HOOKS = new Set([
     "draft-work-order-plan"
 ]);
-export async function injectWorktreeArtifacts(worktreePath, artifacts) {
+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) {
@@ -78,7 +79,7 @@ export function filterArtifactsForLane(artifacts, lane, 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}).`);
@@ -93,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");
 }
@@ -120,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;
@@ -192,7 +231,7 @@ 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>;
@@ -41,3 +44,9 @@ export declare function resolveNpmLaunch(args: readonly string[], options?: NpmL
     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

@@ -23,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);
@@ -50,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) {
@@ -70,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);
@@ -81,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");
@@ -185,10 +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"];
         const launch = resolveNpmLaunch(args);
-        await executor.run(cwd, launch.command, launch.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") {
@@ -219,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);
 }
@@ -310,6 +377,26 @@ export function resolveNpmLaunch(args, options = {}) {
     }
     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)) {
@@ -331,10 +418,12 @@ function defaultNpmCliCandidates(execPath, homeDir) {
     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/worktree.service.d.ts

@@ -6,6 +6,7 @@ export declare class GitWorktreeService implements WorktreeService {
     private readonly coordinator;
     constructor(git?: GitClient, coordinator?: WorktreeLifecycleCoordinator);
     prepare(request: WorktreePrepareRequest): Promise<WorktreeHandle>;
+    private trackedForgePaths;
     private repoCreationCoordinationPath;
     release(handle: WorktreeHandle): Promise<void>;
     private resolveRepoPath;

package/dist/worktree/worktree.service.js

@@ -59,7 +59,7 @@ export class GitWorktreeService {
         const qaReworkPacketPath = await materializeQaReworkPacket(resolvedWorktreePath, request);
         const artifacts = filterArtifactsForLane(request.artifacts, request.lane, request.phase);
         if (artifacts.length > 0) {
-            await injectWorktreeArtifacts(resolvedWorktreePath, artifacts);
+            await injectWorktreeArtifacts(resolvedWorktreePath, artifacts, await this.trackedForgePaths(resolvedWorktreePath));
         }
         const dependencyWarm = await warmWorktreeDependencies({
             baseCheckoutPath: repoPath,
@@ -78,6 +78,10 @@ export class GitWorktreeService {
             hydratedPriorPhaseArtifactCount
         };
     }
+    async trackedForgePaths(worktreePath) {
+        const output = await this.git.run(worktreePath, ["ls-files", "-z", "--", ".forge"]);
+        return new Set(output.split("\0").filter(Boolean).map(value => value.replaceAll("\\", "/")));
+    }
     repoCreationCoordinationPath(repo, allowedRoot) {
         if (repo.serverLocalPath && repo.serverLocalPath.trim().length > 0) {
             return path.resolve(repo.serverLocalPath);
@@ -191,6 +195,13 @@ export class GitWorktreeService {
         return isSubPath(allowedRoot, resolved) ? resolved : null;
     }
     async resolveBaseStartPoint(repoPath, baseBranch) {
+        if (baseBranch === "HEAD") {
+            const head = (await this.git.run(repoPath, ["rev-parse", "--verify", "HEAD^{commit}"])).trim();
+            if (!/^[0-9a-f]{40,64}$/iu.test(head)) {
+                throw new Error("The repository checkout does not have a valid committed HEAD revision.");
+            }
+            return head;
+        }
         const localRef = `refs/heads/${baseBranch}`;
         const remoteRef = `refs/remotes/origin/${baseBranch}`;
         const origin = await this.git.run(repoPath, ["remote", "get-url", "origin"]).catch(() => "");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loucompanion/forge-bridge",
-  "version": "0.1.3-dev.ba7d36726eda",
+  "version": "0.1.3-dev.bca7d0ccee53",
   "description": "Forge runner bridge CLI for connecting local developer machines to Forge dispatch.",
   "license": "UNLICENSED",
   "type": "module",