@loucompanion/forge-bridge 0.1.3-dev.fbe15023cdfe → 0.1.4-dev.1ff37038366e

package/dist/session/unreferenced-exports.d.ts

@@ -0,0 +1,12 @@
+export type GitRunner = (args: readonly string[]) => Promise<{
+    exitCode: number;
+    stdout?: string;
+}>;
+export type UnreferencedExport = {
+    readonly name: string;
+    readonly path: string;
+    readonly testOnly: boolean;
+};
+export declare function isTestPath(file: string): boolean;
+export declare function addedExports(diff: string): Map<string, string>;
+export declare function findUnreferencedNewExports(git: GitRunner, worktreePath: string, baselineRevision: string | undefined): Promise<UnreferencedExport[]>;

package/dist/session/unreferenced-exports.js

@@ -0,0 +1,59 @@
+// Finds exports added by this change that no production code uses. An export reached only from
+// tests is code the current Story does not actually deliver: reviewers flag it and the Story
+// cannot fix it without changing scope, so publication stops before the PR is opened.
+import fs from "node:fs/promises";
+import path from "node:path";
+const SourceFile = /\.(?:[cm]?[jt]sx?)$/u;
+const TestFile = /(?:^|\/)(?:test|tests|__tests__|e2e)\/|\.(?:test|spec)\.[cm]?[jt]sx?$/u;
+const ExportDeclaration = /^\+\s*export\s+(?:default\s+)?(?:declare\s+)?(?:abstract\s+)?(?:async\s+)?(?:function\*?|const|let|var|class|interface|type|enum)\s+([A-Za-z_$][\w$]*)/u;
+const Lines = /\r?\n/u;
+const MaximumNames = 200;
+export function isTestPath(file) {
+    return TestFile.test(file);
+}
+export function addedExports(diff) {
+    const added = new Map();
+    let file = null;
+    for (const line of diff.split(Lines)) {
+        if (line.startsWith("+++ ")) {
+            const target = line.slice(4).trim();
+            file = target === "/dev/null" ? null : target.replace(/^b\//u, "");
+            continue;
+        }
+        if (!file || !SourceFile.test(file) || isTestPath(file) || file.endsWith(".d.ts"))
+            continue;
+        const match = ExportDeclaration.exec(line);
+        if (match && added.size < MaximumNames)
+            added.set(match[1], file);
+    }
+    return added;
+}
+export async function findUnreferencedNewExports(git, worktreePath, baselineRevision) {
+    const diff = await git(["diff", "--no-color", "--no-ext-diff", "-U0", baselineRevision?.trim() || "HEAD", "--"]);
+    if (diff.exitCode !== 0)
+        return [];
+    // New files are untracked until Bridge commits them, so git diff alone would miss their exports.
+    const untracked = await git(["ls-files", "--others", "--exclude-standard"]);
+    const sections = [diff.stdout ?? ""];
+    for (const file of (untracked.exitCode === 0 ? untracked.stdout ?? "" : "").split(Lines).filter(row => SourceFile.test(row) && !isTestPath(row))) {
+        const content = await fs.readFile(path.join(worktreePath, file), "utf8").catch(() => "");
+        sections.push(`+++ b/${file}`, ...content.split(Lines).map(line => `+${line}`));
+    }
+    const found = [];
+    for (const [name, file] of addedExports(sections.join("\n"))) {
+        const grep = await git(["grep", "--untracked", "-I", "-c", "-w", "-F", "-e", name, "--"]);
+        // git grep exits 1 for no match; any other failure skips the name rather than guessing.
+        if (grep.exitCode !== 0 && grep.exitCode !== 1)
+            continue;
+        const counts = (grep.stdout ?? "").split(Lines).filter(Boolean).map(row => {
+            const separator = row.lastIndexOf(":");
+            return { file: row.slice(0, separator).replaceAll("\\", "/"), count: Number(row.slice(separator + 1)) };
+        });
+        const ownUses = counts.find(row => row.file === file)?.count ?? 0;
+        const elsewhere = counts.filter(row => row.file !== file);
+        if (ownUses > 1 || elsewhere.some(row => !isTestPath(row.file)))
+            continue;
+        found.push({ name, path: file, testOnly: elsewhere.length > 0 });
+    }
+    return found;
+}

package/dist/shared/format/format-bytes.d.ts

@@ -0,0 +1 @@
+export declare function formatBytes(bytes: number): string;

package/dist/shared/format/format-bytes.js

@@ -0,0 +1,9 @@
+export function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes <= 0)
+        return "0 B";
+    const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+    const power = Math.max(0, Math.min(units.length - 1, Math.floor(Math.log(bytes) / Math.log(1024))));
+    const value = bytes / 1024 ** power;
+    const precision = power === 0 || value >= 100 ? 0 : 1;
+    return `${value.toFixed(precision)} ${units[power]}`;
+}

package/dist/shared/git/git.js

@@ -8,7 +8,8 @@ export class GitClient {
         const result = await this.processRunner.run({
             command: "git",
             args,
-            cwd
+            cwd,
+            ...(args.includes("-z") ? { rawOutput: true } : {}),
         });
         if (result.exitCode !== 0) {
             throw new Error(`git ${args.join(" ")} failed: ${result.stderr.trim() || result.stdout.trim()}`);

package/dist/shared/path/path.d.ts

@@ -1,4 +1,5 @@
 export declare function isSubPath(root: string, candidate: string): boolean;
 export declare function resolveExistingDirectoryPath(inputPath: string): Promise<string>;
+export declare function resolvePathIdentity(inputPath: string): Promise<string>;
 export declare function ensureDirectory(inputPath: string): Promise<string>;
 export declare function safeSegment(value: string, fallback: string): string;

package/dist/shared/path/path.js

@@ -15,6 +15,24 @@ export async function resolveExistingDirectoryPath(inputPath) {
     }
     return await fs.realpath(inputPath);
 }
+export async function resolvePathIdentity(inputPath) {
+    let existingAncestor = path.resolve(inputPath);
+    const missingSegments = [];
+    while (true) {
+        try {
+            return path.join(await fs.realpath(existingAncestor), ...missingSegments);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            const parent = path.dirname(existingAncestor);
+            if (parent === existingAncestor)
+                throw error;
+            missingSegments.unshift(path.basename(existingAncestor));
+            existingAncestor = parent;
+        }
+    }
+}
 export async function ensureDirectory(inputPath) {
     await fs.mkdir(inputPath, { recursive: true });
     return await resolveExistingDirectoryPath(inputPath);

package/dist/shared/process/dotnet-toolchain.d.ts

@@ -0,0 +1,17 @@
+export interface DotNetToolchainSelection {
+    readonly executablePath: string;
+    readonly rootPath: string;
+    readonly sdkVersion: string;
+    readonly requiredMajor: number;
+}
+export interface DotNetToolchainOptions {
+    readonly environment?: NodeJS.ProcessEnv;
+    readonly platform?: NodeJS.Platform;
+    readonly homeDirectory?: string;
+    readonly fileExists?: (candidate: string) => Promise<boolean>;
+    readonly listSdks?: (candidate: string) => Promise<string>;
+    readonly resolveSdk?: (candidate: string, repositoryRoot: string) => Promise<string>;
+    /** Supplied roots that hold many repositories, such as the bridge clone folder. */
+    readonly cloneFolders?: readonly string[];
+}
+export declare function configureDotNetToolchain(repoRoots: readonly string[], options?: DotNetToolchainOptions): Promise<DotNetToolchainSelection | null>;

package/dist/shared/process/dotnet-toolchain.js

@@ -0,0 +1,307 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const skippedDirectories = new Set([".git", "bin", "node_modules", "obj"]);
+const maximumDiscoveryDepth = 32;
+const maximumDiscoveryEntries = 20_000;
+const maximumProjectFiles = 256;
+const maximumInvocationContexts = 256;
+export async function configureDotNetToolchain(repoRoots, options = {}) {
+    const environment = options.environment ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const requirements = await discoverSdkRequirements(repoRoots, options.cloneFolders ?? []);
+    if (requirements.length === 0)
+        return null;
+    const requiredMajor = Math.max(...requirements.map((requirement) => requirement.minimumMajor));
+    const policyGroups = groupPolicyRequirements(requirements, platform);
+    const explicit = environmentValue(environment, "FORGE_DOTNET_PATH");
+    if (explicit && !path.isAbsolute(explicit)) {
+        throw new Error("dotnet_toolchain_invalid: FORGE_DOTNET_PATH must be an absolute executable path.");
+    }
+    const candidates = dotNetCandidates(environment, platform, options.homeDirectory ?? os.homedir(), requiredMajor);
+    const fileExists = options.fileExists ?? isFile;
+    const listSdks = options.listSdks ?? probeSdks;
+    const resolveSdk = options.resolveSdk ?? probeSelectedSdk;
+    const probed = [];
+    for (const candidate of candidates) {
+        if (!await fileExists(candidate))
+            continue;
+        try {
+            const output = await listSdks(candidate);
+            probed.push(`${candidate} (${sdkVersions(output).join(", ") || "no SDKs"})`);
+            // Project, solution, and repository-root commands can resolve different
+            // SDKs. Preserve all invocation contexts as well as nested project policies;
+            // only identical policy identities may share a probe.
+            const resolvedVersions = [];
+            for (const requirement of policyGroups) {
+                const resolved = (await resolveSdk(candidate, requirement.directory)).trim();
+                if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/u.test(resolved)) {
+                    throw new Error(`No valid SDK selected for ${requirement.directory}`);
+                }
+                if ((majorVersion(resolved) ?? 0) < requirement.minimumMajor) {
+                    throw new Error(`SDK ${resolved} cannot satisfy .NET ${requirement.minimumMajor} in ${requirement.directory}`);
+                }
+                resolvedVersions.push(resolved);
+            }
+            // Detect a policy added, removed, or changed during discovery/probing.
+            // In particular, do not reuse a parent's probe after a nested override appears.
+            for (const requirement of requirements) {
+                const policy = await nearestSdkPolicy(requirement.directory);
+                if (policy?.path !== requirement.policy?.path || policy?.contents !== requirement.policy?.contents) {
+                    throw new Error(`SDK policy changed during resolution for ${requirement.directory}; retry after repository changes finish`);
+                }
+            }
+            const selectedVersion = resolvedVersions.sort((a, b) => a.localeCompare(b, "en", { numeric: true })).at(-1);
+            const rootPath = path.dirname(candidate);
+            prependPath(environment, rootPath, platform);
+            setEnvironmentValue(environment, "DOTNET_ROOT", rootPath);
+            if (platform === "win32")
+                setEnvironmentValue(environment, "DOTNET_ROOT_X64", rootPath);
+            setEnvironmentValue(environment, "FORGE_DOTNET_PATH", candidate);
+            return { executablePath: candidate, rootPath, sdkVersion: selectedVersion, requiredMajor: requiredMajor || majorVersion(selectedVersion) };
+        }
+        catch (error) {
+            probed.push(`${candidate} (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    const detail = probed.length > 0 ? ` Probed: ${probed.join("; ")}.` : "";
+    throw new Error(`dotnet_toolchain_unavailable: repositories require ${requiredMajor ? `.NET SDK ${requiredMajor}.x` : "a .NET SDK"}, but no compatible dotnet executable was found.`
+        + ` Set FORGE_DOTNET_PATH to the absolute executable path.${detail}`);
+}
+async function discoverSdkRequirements(repoRoots, cloneFolders) {
+    const { projects, invocationDirectories } = await findDotNetInputs(repoRoots, cloneFolders);
+    const requirements = [];
+    for (const project of projects) {
+        const source = await fs.readFile(project, "utf8");
+        const directory = path.dirname(project);
+        const policy = await nearestSdkPolicy(directory);
+        const majors = [policy?.major ?? 0];
+        for (const match of source.matchAll(/<TargetFrameworks?>\s*([^<]+)\s*<\/TargetFrameworks?>/giu)) {
+            for (const framework of match[1]?.split(";") ?? []) {
+                const target = /^net(\d+)\./iu.exec(framework.trim());
+                if (target?.[1])
+                    majors.push(Number.parseInt(target[1], 10));
+            }
+        }
+        requirements.push({ directory, policy, minimumMajor: Math.max(...majors) });
+    }
+    for (const directory of invocationDirectories) {
+        const policy = await nearestSdkPolicy(directory);
+        requirements.push({ directory, policy, minimumMajor: policy?.major ?? 0 });
+    }
+    return requirements;
+}
+async function nearestSdkPolicy(projectDirectory) {
+    for (let directory = projectDirectory;; directory = path.dirname(directory)) {
+        const policyPath = path.join(directory, "global.json");
+        try {
+            const contents = await fs.readFile(policyPath, "utf8");
+            let major = null;
+            try {
+                const parsed = JSON.parse(contents);
+                major = typeof parsed.sdk?.version === "string" ? majorVersion(parsed.sdk.version) : null;
+            }
+            catch {
+                // The actual SDK resolver diagnoses malformed policies; never bypass one.
+            }
+            return { path: policyPath, contents, major };
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (path.dirname(directory) === directory)
+            return null;
+    }
+}
+function groupPolicyRequirements(requirements, platform) {
+    const groups = new Map();
+    for (const requirement of requirements) {
+        const key = requirement.policy ? canonicalPath(requirement.policy.path, platform) : "no-global-json";
+        const previous = groups.get(key);
+        if (previous && previous.policy?.contents !== requirement.policy?.contents) {
+            throw new Error(`dotnet_toolchain_changed: SDK policy changed during discovery: ${requirement.policy?.path}`);
+        }
+        groups.set(key, previous
+            ? { ...previous, minimumMajor: Math.max(previous.minimumMajor, requirement.minimumMajor) }
+            : requirement);
+    }
+    return [...groups.values()];
+}
+async function findDotNetInputs(repoRoots, cloneFolders) {
+    const projects = [];
+    const invocationDirectories = new Map();
+    const visitedDirectories = new Set();
+    const roots = [...new Set(repoRoots.map((candidate) => path.resolve(candidate)))];
+    const explicitRoots = new Set(roots.map((root) => canonicalPath(root, process.platform)));
+    const cloneFolderRoots = new Set(cloneFolders.map((folder) => canonicalPath(path.resolve(folder), process.platform)));
+    // The entry bound applies per repository. A clone folder is not one: each of
+    // its child directories is bounded as its own repository root.
+    let entryCount = 0;
+    async function visitRoot(root) {
+        entryCount = 0;
+        await visit(root, 0, root, new Set());
+    }
+    function addInvocationDirectory(directory, root) {
+        const identity = canonicalPath(directory, process.platform);
+        if (invocationDirectories.has(identity))
+            return;
+        if (invocationDirectories.size >= maximumInvocationContexts)
+            throw discoveryLimit("invocation contexts", maximumInvocationContexts, root);
+        invocationDirectories.set(identity, directory);
+    }
+    async function visit(directory, depth, root, ancestors) {
+        const directoryIdentity = canonicalPath(directory, process.platform);
+        if (visitedDirectories.has(directoryIdentity))
+            return;
+        if (depth > maximumDiscoveryDepth)
+            throw discoveryLimit("depth", maximumDiscoveryDepth, root);
+        const physicalDirectory = await fs.realpath(directory);
+        if (ancestors.has(physicalDirectory))
+            throw new Error(`dotnet_toolchain_discovery: directory cycle at ${directory}`);
+        const nextAncestors = new Set([...ancestors, physicalDirectory]);
+        const cloneFolder = depth === 0 && cloneFolderRoots.has(directoryIdentity);
+        visitedDirectories.add(directoryIdentity);
+        const entries = [];
+        for await (const entry of await fs.opendir(directory)) {
+            if (++entryCount > maximumDiscoveryEntries)
+                throw discoveryLimit("entries", maximumDiscoveryEntries, root);
+            entries.push(entry);
+        }
+        // Stable traversal also makes the representative policy probe deterministic.
+        entries.sort((a, b) => a.name.localeCompare(b.name, "en"));
+        for (const entry of entries) {
+            // Hidden folders (.git, .vs, .forge-worktrees, ...) are tool state, never
+            // repository sources; an explicitly supplied hidden root is still visited.
+            if (skippedDirectories.has(entry.name) || entry.name.startsWith(".") && !entry.isFile())
+                continue;
+            const entryPath = path.join(directory, entry.name);
+            const linked = entry.isSymbolicLink() ? await fs.stat(entryPath) : null;
+            if (linked?.isDirectory()) {
+                if (cloneFolder || explicitRoots.has(canonicalPath(entryPath, process.platform))) {
+                    await visitRoot(entryPath);
+                    continue;
+                }
+                throw new Error(`dotnet_toolchain_discovery: symbolic/reparse directory ${entryPath} must be supplied as an explicit repository root, not traversed from ${root}`);
+            }
+            if (entry.isDirectory()) {
+                if (cloneFolder)
+                    await visitRoot(entryPath);
+                else
+                    await visit(entryPath, depth + 1, root, nextAncestors);
+            }
+            else if (entry.isFile() || linked?.isFile()) {
+                const extension = path.extname(entry.name).toLowerCase();
+                if (extension === ".csproj") {
+                    if (projects.length >= maximumProjectFiles)
+                        throw discoveryLimit("projects", maximumProjectFiles, root);
+                    projects.push(entryPath);
+                }
+                // A solution's SDK resolver starts at its directory. A global.json also
+                // defines a CLI invocation context even when every child project overrides
+                // it (or the repository contains only SDK-based tools).
+                if ([".sln", ".slnx", ".slnf"].includes(extension)
+                    || canonicalPath(entry.name, process.platform) === "global.json") {
+                    addInvocationDirectory(directory, root);
+                }
+            }
+        }
+    }
+    for (const root of roots) {
+        await visitRoot(root);
+    }
+    // Supplied roots are also supported command working directories. A parent's
+    // policy cannot be dropped merely because every project/solution below it has
+    // its own override. Ignore unrelated roots without any discovered .NET inputs.
+    const inputDirectories = [...projects.map((project) => path.dirname(project)), ...invocationDirectories.values()];
+    for (const root of roots) {
+        if (inputDirectories.some((directory) => isWithinDirectory(root, directory))) {
+            addInvocationDirectory(root, root);
+        }
+    }
+    return { projects, invocationDirectories: [...invocationDirectories.values()] };
+}
+function isWithinDirectory(root, directory) {
+    const relative = path.relative(root, directory);
+    return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function discoveryLimit(bound, maximum, root) {
+    return new Error(`dotnet_toolchain_discovery: ${bound} limit ${maximum} exceeded under ${root}; configure narrower explicit repository roots`);
+}
+function dotNetCandidates(environment, platform, homeDirectory, requiredMajor) {
+    const executable = platform === "win32" ? "dotnet.exe" : "dotnet";
+    const explicit = environmentValue(environment, "FORGE_DOTNET_PATH");
+    if (explicit)
+        return [explicit];
+    const dotNetRoot = environmentValue(environment, "DOTNET_ROOT");
+    const pathValue = environmentValue(environment, "PATH") ?? "";
+    const programFiles = environmentValue(environment, "ProgramFiles");
+    const candidates = [
+        dotNetRoot ? path.join(dotNetRoot, executable) : null,
+        path.join(homeDirectory, ".dotnet", executable),
+        requiredMajor > 0 ? path.join(homeDirectory, `.dotnet${requiredMajor}`, executable) : null,
+        ...(platform === "win32" && programFiles ? [path.join(programFiles, "dotnet", executable)] : []),
+        ...pathValue.split(path.delimiter).filter(Boolean).map((directory) => path.join(directory, executable)),
+    ].filter((candidate) => Boolean(candidate));
+    return [...new Map(candidates.map((candidate) => [canonicalPath(candidate, platform), path.resolve(candidate)])).values()];
+}
+async function probeSdks(candidate) {
+    const { stdout } = await execFileAsync(candidate, ["--list-sdks"], {
+        encoding: "utf8",
+        timeout: 10_000,
+        windowsHide: true,
+    });
+    return stdout;
+}
+async function probeSelectedSdk(candidate, repositoryRoot) {
+    const { stdout } = await execFileAsync(candidate, ["--version"], {
+        cwd: repositoryRoot,
+        encoding: "utf8",
+        timeout: 10_000,
+        windowsHide: true,
+    });
+    return stdout;
+}
+function sdkVersions(output) {
+    return output.split(/\r?\n/gu)
+        .map((line) => /^(\d+\.\d+\.\d+(?:[-+][^\s]+)?)/u.exec(line.trim())?.[1] ?? null)
+        .filter((version) => version !== null);
+}
+function majorVersion(version) {
+    const match = /^(\d+)\./u.exec(version.trim());
+    return match?.[1] ? Number.parseInt(match[1], 10) : null;
+}
+async function isFile(candidate) {
+    try {
+        return (await fs.stat(candidate)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function prependPath(environment, directory, platform) {
+    const current = environmentValue(environment, "PATH") ?? "";
+    const normalizedDirectory = canonicalPath(directory, platform);
+    const remaining = current.split(path.delimiter)
+        .filter(Boolean)
+        .filter((entry) => canonicalPath(entry, platform) !== normalizedDirectory);
+    setEnvironmentValue(environment, "PATH", [directory, ...remaining].join(path.delimiter));
+}
+function environmentValue(environment, name) {
+    const key = Object.keys(environment).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+    return key ? environment[key] : undefined;
+}
+function setEnvironmentValue(environment, name, value) {
+    const keys = Object.keys(environment).filter((candidate) => candidate.toLowerCase() === name.toLowerCase());
+    const target = keys[0] ?? name;
+    for (const duplicate of keys.slice(1))
+        delete environment[duplicate];
+    environment[target] = value;
+}
+function canonicalPath(candidate, platform) {
+    const normalized = path.normalize(candidate);
+    return platform === "win32" ? normalized.toLowerCase() : normalized;
+}

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

@@ -13,7 +13,9 @@ export interface HostProcessSupervisedLaunch {
     readonly supervisorId: string;
     readonly strategy: HostProcessSupervisorStrategy;
     readonly metadataPath: string;
+    readonly memoryTelemetryPath?: string;
     readonly payloadPath?: string;
+    readonly payloadSha256?: string;
     readonly readyPath?: string;
     readonly startGrantPath?: string;
     readonly commandDigest: string;

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

@@ -22,7 +22,8 @@ export function resolveHostProcessSupervisedLaunch(request, resolvedCommand, res
         const payloadPath = `${metadataPath}.launch.json`;
         const readyPath = `${metadataPath}.provider-ready.json`;
         const startGrantPath = `${metadataPath}.provider-start-granted`;
-        fs.writeFileSync(payloadPath, `${JSON.stringify({
+        const memoryTelemetryPath = `${metadataPath}.memory.json`;
+        const serializedPayload = `${JSON.stringify({
             command: resolvedCommand,
             args: resolvedArgs,
             cwd: request.cwd,
@@ -30,7 +31,10 @@ export function resolveHostProcessSupervisedLaunch(request, resolvedCommand, res
             supervisorId,
             readyPath,
             startGrantPath,
-        })}\n`, {
+            memoryTelemetryPath,
+        })}\n`;
+        const payloadSha256 = createHash("sha256").update(serializedPayload).digest("hex");
+        fs.writeFileSync(payloadPath, serializedPayload, {
             encoding: "utf8",
             flag: "wx",
             mode: 0o600,
@@ -49,12 +53,16 @@ export function resolveHostProcessSupervisedLaunch(request, resolvedCommand, res
                 "Outer",
                 "-PayloadPath",
                 payloadPath,
+                "-PayloadSha256",
+                payloadSha256,
             ],
             detached: false,
             supervisorId,
             strategy: "windows_job_object",
             metadataPath,
+            memoryTelemetryPath,
             payloadPath,
+            payloadSha256,
             readyPath,
             startGrantPath,
             commandDigest,
@@ -147,12 +155,7 @@ export function captureHostProcessIdentity(pid, platform = process.platform) {
 }
 export async function terminateHostProcessTree(child, launch, graceMs = 2_000) {
     if (!launch) {
-        try {
-            child.kill("SIGTERM");
-        }
-        catch {
-            // The process already settled.
-        }
+        await terminateUnsupervisedProcessTree(child, graceMs);
         return;
     }
     if (launch.strategy === "windows_job_object") {
@@ -189,9 +192,48 @@ export async function terminateHostProcessTree(child, launch, graceMs = 2_000) {
     const processGroupId = child.pid;
     if (!processGroupId || !signalUnixProcessGroup(processGroupId, "SIGTERM"))
         return;
-    await new Promise(resolve => setTimeout(resolve, graceMs));
+    await waitForUnixProcessGroupExit(processGroupId, graceMs);
     if (unixProcessGroupExists(processGroupId)) {
         signalUnixProcessGroup(processGroupId, "SIGKILL");
+        await waitForUnixProcessGroupExit(processGroupId, graceMs);
+    }
+    if (unixProcessGroupExists(processGroupId)) {
+        throw new Error("host_process_supervisor_termination_failed: supervised Unix process group did not stop.");
+    }
+}
+async function terminateUnsupervisedProcessTree(child, graceMs) {
+    const rootPid = child.pid ?? 0;
+    if (!Number.isSafeInteger(rootPid) || rootPid <= 0) {
+        try {
+            child.kill("SIGTERM");
+        }
+        catch {
+            // The process already settled before a PID was assigned.
+        }
+        return;
+    }
+    if (process.platform === "win32") {
+        // Without a Job Object there is no trustworthy ancestry record after the
+        // root has already exited. Never target a potentially reused Windows PID.
+        if (child.exitCode !== null || child.signalCode !== null)
+            return;
+        const rootIdentity = captureHostProcessIdentity(rootPid, "win32");
+        forceWindowsProcessTree(rootPid);
+        await waitForExactProcessExit(rootPid, rootIdentity, graceMs, "win32");
+        if (exactProcessExists(rootPid, rootIdentity, "win32")) {
+            throw new Error("host_process_supervisor_termination_failed: unsupervised Windows provider tree did not stop.");
+        }
+        return;
+    }
+    if (!signalUnixProcessGroup(rootPid, "SIGTERM"))
+        return;
+    await waitForUnixProcessGroupExit(rootPid, graceMs);
+    if (unixProcessGroupExists(rootPid)) {
+        signalUnixProcessGroup(rootPid, "SIGKILL");
+        await waitForUnixProcessGroupExit(rootPid, graceMs);
+    }
+    if (unixProcessGroupExists(rootPid)) {
+        throw new Error("host_process_supervisor_termination_failed: unsupervised Unix provider tree did not stop.");
     }
 }
 function requiredEnvironment(env, name) {
@@ -234,6 +276,12 @@ function unixProcessGroupExists(processGroupId) {
         throw error;
     }
 }
+async function waitForUnixProcessGroupExit(processGroupId, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline && unixProcessGroupExists(processGroupId)) {
+        await new Promise(resolve => setTimeout(resolve, 25));
+    }
+}
 function readSupervisorMetadata(metadataPath) {
     try {
         return JSON.parse(fs.readFileSync(metadataPath, "utf8"));

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

@@ -3,6 +3,8 @@ export interface ProcessRunRequest {
     readonly args: readonly string[];
     readonly cwd: string;
     readonly env?: NodeJS.ProcessEnv;
+    readonly rawOutput?: boolean;
+    readonly windowsVerbatimArguments?: boolean;
 }
 export interface ProcessRunResult {
     readonly exitCode: number;

package/dist/shared/process/process.js

@@ -6,22 +6,27 @@ export class NodeProcessRunner {
             const child = spawn(request.command, request.args, {
                 cwd: request.cwd,
                 env: request.env,
-                stdio: ["ignore", "pipe", "pipe"]
+                stdio: ["ignore", "pipe", "pipe"],
+                windowsVerbatimArguments: request.windowsVerbatimArguments,
             });
             let stdout = "";
             let stderr = "";
             child.on("error", reject);
-            const stdoutReader = readline.createInterface({ input: child.stdout });
-            const stderrReader = readline.createInterface({ input: child.stderr });
-            stdoutReader.on("line", (line) => {
+            const stdoutReader = request.rawOutput ? undefined : readline.createInterface({ input: child.stdout });
+            const stderrReader = request.rawOutput ? undefined : readline.createInterface({ input: child.stderr });
+            if (request.rawOutput) {
+                child.stdout.setEncoding("utf8").on("data", chunk => { stdout += chunk; });
+                child.stderr.setEncoding("utf8").on("data", chunk => { stderr += chunk; });
+            }
+            stdoutReader?.on("line", (line) => {
                 stdout += `${line}\n`;
             });
-            stderrReader.on("line", (line) => {
+            stderrReader?.on("line", (line) => {
                 stderr += `${line}\n`;
             });
             child.on("close", (code) => {
-                stdoutReader.close();
-                stderrReader.close();
+                stdoutReader?.close();
+                stderrReader?.close();
                 resolve({
                     exitCode: code ?? 1,
                     stdout,

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

@@ -1 +1,4 @@
+import { type BridgeChatCapability } from "../bridge/bridge-chat.types.js";
+import type { BridgeProviderStatus } from "../bridge/bridge.types.js";
 export declare function supportsDraftImageAttachmentsFor(cliProviders: readonly string[]): boolean;
+export declare function bridgeChatCapabilityFor(cliProviders: readonly string[], providerStatuses: Readonly<Record<string, BridgeProviderStatus>>, baseCapability?: BridgeChatCapability | null): BridgeChatCapability;