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

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

@@ -0,0 +1,330 @@
+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 payloadPath = `${metadataPath}.launch.json`;
+        const readyPath = `${metadataPath}.provider-ready.json`;
+        const startGrantPath = `${metadataPath}.provider-start-granted`;
+        const memoryTelemetryPath = `${metadataPath}.memory.json`;
+        const serializedPayload = `${JSON.stringify({
+            command: resolvedCommand,
+            args: resolvedArgs,
+            cwd: request.cwd,
+            parentPid: process.pid,
+            supervisorId,
+            readyPath,
+            startGrantPath,
+            memoryTelemetryPath,
+        })}\n`;
+        const payloadSha256 = createHash("sha256").update(serializedPayload).digest("hex");
+        fs.writeFileSync(payloadPath, serializedPayload, {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o600,
+        });
+        return {
+            command: windowsPowerShellPath(),
+            args: [
+                "-NoLogo",
+                "-NoProfile",
+                "-NonInteractive",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-File",
+                windowsJobSupervisorPath,
+                "-Mode",
+                "Outer",
+                "-PayloadPath",
+                payloadPath,
+                "-PayloadSha256",
+                payloadSha256,
+            ],
+            detached: false,
+            supervisorId,
+            strategy: "windows_job_object",
+            metadataPath,
+            memoryTelemetryPath,
+            payloadPath,
+            payloadSha256,
+            readyPath,
+            startGrantPath,
+            commandDigest,
+        };
+    }
+    return {
+        command: resolvedCommand,
+        args: resolvedArgs,
+        detached: true,
+        supervisorId,
+        strategy: "unix_process_group",
+        metadataPath,
+        commandDigest,
+    };
+}
+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.");
+    }
+    const env = request.env ?? {};
+    const metadata = {
+        schemaVersion: 1,
+        supervisorId: launch.supervisorId,
+        strategy: launch.strategy,
+        rootPid,
+        rootCreatedAt,
+        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",
+        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: 10_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) {
+        await terminateUnsupervisedProcessTree(child, graceMs);
+        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;
+    if (!processGroupId || !signalUnixProcessGroup(processGroupId, "SIGTERM"))
+        return;
+    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) {
+    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;
+    }
+}
+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"));
+    }
+    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,9 @@ export interface ProcessRunRequest {
     readonly command: string;
     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

@@ -5,22 +5,28 @@ export class NodeProcessRunner {
         return await new Promise((resolve, reject) => {
             const child = spawn(request.command, request.args, {
                 cwd: request.cwd,
-                stdio: ["ignore", "pipe", "pipe"]
+                env: request.env,
+                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/process/windows-launch.d.ts

@@ -0,0 +1,8 @@
+export interface LaunchCommand {
+    readonly command: string;
+    readonly args: readonly string[];
+}
+export declare function buildWindowsCmdLaunch(command: string, args: readonly string[], comSpec?: string | undefined): LaunchCommand;
+export declare function buildWindowsLaunchCommand(commandPath: string, args: readonly string[]): LaunchCommand;
+export declare function windowsCommandLine(command: string, args: readonly string[]): string;
+export declare function quoteWindowsCommandLineArg(value: string): string;

package/dist/shared/process/windows-launch.js

@@ -0,0 +1,41 @@
+import path from "node:path";
+export function buildWindowsCmdLaunch(command, args, comSpec = process.env.ComSpec) {
+    const resolvedComSpec = comSpec?.trim();
+    const commandLine = windowsCommandLine(command, args);
+    const cmdPayload = commandLine.startsWith('"') ? `"${commandLine}"` : commandLine;
+    return {
+        command: resolvedComSpec || "cmd.exe",
+        args: ["/d", "/s", "/v:off", "/c", cmdPayload]
+    };
+}
+export function buildWindowsLaunchCommand(commandPath, args) {
+    const extension = path.extname(commandPath).toLowerCase();
+    if (extension === ".ps1") {
+        return {
+            command: powershellExecutable(),
+            args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", commandPath, ...args]
+        };
+    }
+    if (extension === ".cmd" || extension === ".bat") {
+        return buildWindowsCmdLaunch(commandPath, args);
+    }
+    return { command: commandPath, args };
+}
+export function windowsCommandLine(command, args) {
+    return [command, ...args].map(quoteWindowsCommandLineArg).join(" ");
+}
+export function quoteWindowsCommandLineArg(value) {
+    const escaped = value
+        .replace(/\^/g, "^^")
+        .replace(/%/g, "^%");
+    if (escaped.length > 0 && !/[\s"&|<>()^%!]/.test(escaped)) {
+        return escaped;
+    }
+    return `"${escaped.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/g, "$1$1")}"`;
+}
+function powershellExecutable() {
+    const systemRoot = process.env.SystemRoot;
+    return systemRoot
+        ? path.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+        : "powershell.exe";
+}

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

@@ -0,0 +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;

package/dist/shared/provider-capabilities.js

@@ -0,0 +1,88 @@
+import { bridgeChatProtocolVersion, normalizeBridgeChatCapability, unavailableBridgeChatCapability, } from "../bridge/bridge-chat.types.js";
+const defaultBridgeChatMaxMessageBytes = 128 * 1024;
+const defaultBridgeChatMaxContextRefs = 8;
+export function supportsDraftImageAttachmentsFor(cliProviders) {
+    return cliProviders.some((provider) => provider.trim().toLowerCase() === "codex");
+}
+export function bridgeChatCapabilityFor(cliProviders, providerStatuses, baseCapability) {
+    const base = normalizeBridgeChatCapability(baseCapability ?? unavailableBridgeChatCapability());
+    if (base.protocolVersion !== bridgeChatProtocolVersion) {
+        return base;
+    }
+    const providers = chatProviderEntries(cliProviders, providerStatuses);
+    const usableProviders = providers.filter((provider) => provider.status?.signedIn !== false);
+    if (usableProviders.length === 0) {
+        return unavailableBridgeChatCapability(bridgeChatProtocolVersion, providers.length === 0 ? "no_cli_providers" : "no_signed_in_cli_providers", providers.length === 0
+            ? "No CLI providers are configured for Bridge Chat."
+            : "No signed-in CLI providers are available for Bridge Chat.");
+    }
+    return normalizeBridgeChatCapability({
+        ...base,
+        availability: usableProviders.length === providers.length ? "available" : "degraded",
+        protocolVersion: bridgeChatProtocolVersion,
+        supportedProviders: usableProviders.map((provider) => provider.providerKind),
+        supportedModels: sortedUniqueStrings(usableProviders.flatMap((provider) => provider.status?.models ?? []), false),
+        supportsTextStreaming: true,
+        supportsCancel: true,
+        supportsResume: true,
+        supportsProviderThreadContinuity: true,
+        supportsAttachments: true,
+        supportsActionBrokerGrants: true,
+        maxMessageBytes: base.maxMessageBytes || defaultBridgeChatMaxMessageBytes,
+        maxContextRefs: base.maxContextRefs || defaultBridgeChatMaxContextRefs,
+        unavailableCode: null,
+        unavailableReason: null,
+    });
+}
+function chatProviderEntries(cliProviders, providerStatuses) {
+    const statuses = new Map();
+    for (const [provider, status] of Object.entries(providerStatuses)) {
+        const providerKind = provider.trim().toLowerCase();
+        if (providerKind.length === 0)
+            continue;
+        statuses.set(providerKind, { providerKind, status });
+    }
+    const providers = new Map();
+    for (const provider of cliProviders) {
+        const providerKind = provider.trim().toLowerCase();
+        if (providerKind.length === 0)
+            continue;
+        providers.set(providerKind, {
+            providerKind,
+            status: statuses.get(providerKind)?.status,
+        });
+    }
+    for (const [providerKind, entry] of statuses) {
+        if (!providers.has(providerKind)) {
+            providers.set(providerKind, entry);
+        }
+    }
+    return [...providers.values()].sort((left, right) => compareStable(left.providerKind, right.providerKind));
+}
+function sortedUniqueStrings(values, lower) {
+    const byKey = new Map();
+    for (const value of values) {
+        const clean = value.trim();
+        if (clean.length === 0)
+            continue;
+        const normalized = lower ? clean.toLowerCase() : clean;
+        const key = normalized.toLowerCase();
+        if (!byKey.has(key)) {
+            byKey.set(key, normalized);
+        }
+    }
+    return [...byKey.values()].sort(compareStable);
+}
+function compareStable(left, right) {
+    const leftKey = left.toLowerCase();
+    const rightKey = right.toLowerCase();
+    if (leftKey < rightKey)
+        return -1;
+    if (leftKey > rightKey)
+        return 1;
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}

package/dist/shared/redaction/redaction.d.ts

@@ -1,2 +1,3 @@
 export declare function redactSecrets<T>(value: T, exactSecrets?: readonly string[]): T;
+export declare function shouldRedactJsonProperty(key: string): boolean;
 export declare function redactText(value: string, exactSecrets?: readonly string[]): string;

package/dist/shared/redaction/redaction.js

@@ -1,17 +1,51 @@
 const secretKeyPattern = /(api[_-]?key|authorization|bearer|client[_-]?secret|password|secret|token)/i;
+// Serialized artifact keys follow the existing assignment policy, not the broad
+// object redactor: tokenCount/maxTokens are evidence, not credential values.
+const jsonCredentialKeyPattern = /(api[_-]?key|client[_-]?secret|password|secret|token)$/i;
+const attachmentContentKeyPattern = /^(textContent|contentBase64)$/i;
+const bridgeChatHandoffGrantKeyPattern = /^(tempFileToken|grantNonce|nonce|handle|grantId|handoffId|attachmentId)$/i;
+const sensitiveFilenameKeyPattern = /^(fileName|filename)$/i;
+const serializedAttachmentContentPattern = /("(?:textContent|contentBase64)"\s*:\s*")(?:(?:\\.)|[^"\\])*(")/gi;
+const serializedBridgeChatHandoffGrantPattern = /("(?:tempFileToken|grantNonce|nonce|handle|grantId|handoffId|attachmentId)"\s*:\s*")(?:(?:\\.)|[^"\\])*(")/gi;
+const serializedSensitiveFilenamePattern = /("(?:fileName|filename)"\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;
+// Keep this boundary in parity with Forge.Api's SecretRedactor. Without it, the
+// `sk-` substring in a structural identifier such as `task-skill-contract`
+// is mistaken for a provider credential and corrupts the artifact after it has
+// already passed schema validation.
+const providerKeyPattern = /(?<![a-zA-Z0-9])sk-[a-zA-Z0-9_-]{12,}/g;
 export function redactSecrets(value, exactSecrets = []) {
     return redactValue(value, exactSecrets);
 }
+export function shouldRedactJsonProperty(key) {
+    // Assignment redaction already permits whitespace before the delimiter. Match
+    // that policy without normalizing the actual JSON property name on the wire.
+    const policyKey = key.trim();
+    return jsonCredentialKeyPattern.test(policyKey)
+        || /^(authorization|bearer)$/i.test(policyKey)
+        || attachmentContentKeyPattern.test(policyKey)
+        || bridgeChatHandoffGrantKeyPattern.test(policyKey)
+        || (redactSensitiveFilenames() && sensitiveFilenameKeyPattern.test(policyKey));
+}
 export function redactText(value, exactSecrets = []) {
-    let redacted = value;
+    let redacted = value
+        .replace(serializedAttachmentContentPattern, "$1[REDACTED]$2")
+        .replace(serializedBridgeChatHandoffGrantPattern, "$1[REDACTED]$2");
+    if (redactSensitiveFilenames()) {
+        redacted = redacted.replace(serializedSensitiveFilenamePattern, "$1[REDACTED]$2");
+    }
     for (const secret of exactSecrets) {
         if (secret.length > 0) {
             redacted = redacted.split(secret).join("[REDACTED]");
         }
     }
     return redacted
-        .replace(/(api[_-]?key|authorization|bearer|client[_-]?secret|password|secret|token)(["':=\s]+)([^"',\s]+)/gi, "$1$2[REDACTED]")
-        .replace(/(sk-[a-zA-Z0-9_-]{12,})/g, "[REDACTED]");
+        .replace(authorizationCredentialPattern, "$1[REDACTED]")
+        .replace(bearerCredentialPattern, "$1[REDACTED]")
+        .replace(secretAssignmentPattern, "$1$2[REDACTED]")
+        .replace(providerKeyPattern, "[REDACTED]");
 }
 function redactValue(value, exactSecrets) {
     if (typeof value === "string") {
@@ -25,6 +59,15 @@ function redactValue(value, exactSecrets) {
     }
     return Object.fromEntries(Object.entries(value).map(([key, item]) => [
         key,
-        secretKeyPattern.test(key) ? "[REDACTED]" : redactValue(item, exactSecrets)
+        secretKeyPattern.test(key)
+            || attachmentContentKeyPattern.test(key)
+            || bridgeChatHandoffGrantKeyPattern.test(key)
+            || (redactSensitiveFilenames() && sensitiveFilenameKeyPattern.test(key))
+            ? "[REDACTED]"
+            : redactValue(item, exactSecrets)
     ]));
 }
+function redactSensitiveFilenames() {
+    const value = process.env.FORGE_REDACT_FILENAMES?.trim().toLowerCase();
+    return value === "1" || value === "true" || value === "yes";
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const forgeBridgeVersion = "0.1.3-dev.f66395c3ac21";
+export declare const forgeBridgeVersion = "0.1.4-dev.1ff37038366e";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.3-dev.f66395c3ac21";
+export const forgeBridgeVersion = "0.1.4-dev.1ff37038366e";

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;