@bridge_gpt/mcp-server 0.2.50 → 0.2.52

package/build/env-file-link.js

@@ -0,0 +1,164 @@
+/**
+ * Interactive worktree environment-file LINKING (BAPI-1019, Slice A / A.2).
+ *
+ * Architecture Miss 28 was a conductor worker that truncated the operator's real
+ * operational database. It could reach that database because Worktrunk's
+ * `copy-ignored` step had placed a COPY of the operator's `.env` inside the
+ * worker's worktree. BAPI-1019 removes `.env*` from that copy step at source
+ * (`.config/wt.toml`), which fixes the executor case outright — an executor
+ * worktree must hold neither a copy nor a link — but it also takes `.env` away
+ * from the INTERACTIVE worktrees a human actually works in, which legitimately
+ * need it.
+ *
+ * This module gives that file back by REFERENCE rather than by value. For each
+ * supported name present in the main checkout it creates
+ * `<worktree>/<name>` as a SYMLINK to the main checkout's file, so an operator's
+ * secrets exist exactly once at rest no matter how many worktrees are open, and
+ * editing the operator's `.env` is immediately visible everywhere instead of
+ * drifting per worktree.
+ *
+ * CONTAINMENT RULES, all load-bearing:
+ *
+ *  - This module is for the INTERACTIVE path only. `createWorktrees()` in
+ *    `start-tickets.ts` is its sole production caller; `ensureExecutorWorktree()`
+ *    must never call it. An executor worktree that held a link would resolve to
+ *    the operator's real `.env` exactly as a copy did.
+ *  - It NEVER reads or logs file CONTENTS. Its whole dependency surface is
+ *    metadata (`stat`/`lstat`), link creation, unlinking, and — only on a
+ *    platform that cannot make links — a copy. There is deliberately no
+ *    `readFile` seam to misuse.
+ *  - Its returned warnings are FIXED text plus a closed category. No absolute
+ *    path, username, resolved link target, file content, or exception text
+ *    reaches the caller, because these strings surface in `start-tickets`'
+ *    operator-facing summary.
+ *  - A destination that already exists as a REGULAR FILE (a copy left behind by
+ *    an earlier run, before this ticket) is replaced with a link. That is the
+ *    migration path off the old behavior: leaving the copy in place would leave
+ *    the second at-rest copy this ticket exists to remove.
+ *
+ * ACCEPTED WINDOWS GAP. Creating a symlink on Windows requires Developer Mode or
+ * an elevated process, so `symlink` there commonly fails with `EPERM`. On that
+ * recognized failure this module falls back to a COPY and returns a warning
+ * rather than throwing: an interactive Windows worktree with a copied `.env` is
+ * the behavior operators already had, whereas a hard failure would break worktree
+ * creation outright. The residual second-copy-at-rest gap on Windows is recorded
+ * as accepted in the ticket's exploration ("Criteria Coverage"), not as a defect
+ * to solve here. It does NOT weaken the executor guarantee, which is enforced by
+ * `executor/env-file-guard.ts` on every platform.
+ */
+import { pathApiForPlatform } from "./worktree-core.js";
+/**
+ * The operator environment files an interactive worktree may receive by link.
+ *
+ * A CLOSED list, not a glob. `.env` and `.env.test` are the two files this
+ * repository's own tooling reads; matching `.env.*` here would start linking
+ * whatever an operator happens to have lying around (`.env.production`,
+ * `.env.backup`) into every worktree, which is a wider blast radius than the
+ * problem needs. The executor's strip, by contrast, is deliberately a WIDE
+ * pattern — removing too much from a worker is safe, linking too much is not.
+ */
+export const LINKED_OPERATOR_ENV_FILES = [".env", ".env.test"];
+/**
+ * The FIXED warning texts. Basenames are the only variable part, and a basename
+ * is a constant from {@link LINKED_OPERATOR_ENV_FILES} rather than anything
+ * discovered on disk — so no path, username, or secret can enter these strings.
+ */
+function symlinkUnsupportedWarning(name) {
+    return {
+        category: "symlink_unsupported",
+        message: `worktree ${name}: this platform could not create a symbolic link, so the file was ` +
+            "copied instead. The worktree now holds a second copy of that environment file at " +
+            "rest. On Windows, enable Developer Mode (or run elevated) to get links instead.",
+    };
+}
+function linkFailedWarning(name) {
+    return {
+        category: "link_failed",
+        message: `worktree ${name}: could not be provided from the main checkout, so this worktree has ` +
+            "no copy of it. Commands that need it will fail until it is linked by hand.",
+    };
+}
+/**
+ * Error codes that mean "this platform/filesystem cannot make a symlink here",
+ * as opposed to an ordinary failure. `EPERM` is the Windows non-Developer-Mode
+ * signature; the rest cover filesystems and runtimes without link support.
+ */
+const SYMLINK_UNSUPPORTED_CODES = new Set([
+    "EPERM",
+    "ENOSYS",
+    "EOPNOTSUPP",
+    "ENOTSUP",
+    "UNKNOWN",
+]);
+function errorCode(err) {
+    if (!err || typeof err !== "object")
+        return undefined;
+    const code = err.code;
+    return typeof code === "string" ? code : undefined;
+}
+/** True when two metadata records describe the same underlying file. */
+function sameFile(a, b) {
+    if (!a || !b)
+        return false;
+    return a.dev === b.dev && a.ino === b.ino;
+}
+/**
+ * Provide the main checkout's operator environment files to an interactive
+ * worktree as symlinks.
+ *
+ * Never throws: every per-name failure becomes a fixed warning, because a
+ * worktree that was created successfully must not be reported as failed just
+ * because a convenience link could not be made. A name whose SOURCE is absent in
+ * the main checkout is an ordinary no-op with no warning at all — most checkouts
+ * have `.env` and no `.env.test`, and warning about that would train operators to
+ * ignore this channel.
+ */
+export async function linkOperatorEnvFiles(mainCheckout, worktreePath, deps) {
+    const pathApi = pathApiForPlatform(deps.platform ?? process.platform);
+    const result = { linked: [], copied: [], unchanged: [], warnings: [] };
+    for (const name of LINKED_OPERATOR_ENV_FILES) {
+        const source = pathApi.join(mainCheckout, name);
+        const destination = pathApi.join(worktreePath, name);
+        try {
+            // The main checkout is the authority on whether this name exists at all.
+            // Checked FIRST so a missing source touches the destination in no way.
+            const sourceStats = await deps.stat(source);
+            if (!sourceStats || !sourceStats.isFile())
+                continue;
+            const existing = await deps.lstat(destination);
+            if (existing) {
+                if (existing.isSymbolicLink() && sameFile(await deps.stat(destination), sourceStats)) {
+                    // Already pointing at this exact file. Re-creating it would be churn,
+                    // and every unlink of a correct entry is a window in which the worktree
+                    // has no `.env` at all.
+                    result.unchanged.push(name);
+                    continue;
+                }
+                // A stale link, or a regular-file copy from before this ticket. Remove
+                // the ENTRY — `unlink` never follows, so the main checkout's real file is
+                // untouched even when the entry is a link pointing straight at it.
+                await deps.unlink(destination);
+            }
+            try {
+                await deps.symlink(source, destination);
+                result.linked.push(name);
+            }
+            catch (err) {
+                if (!SYMLINK_UNSUPPORTED_CODES.has(errorCode(err) ?? ""))
+                    throw err;
+                // The accepted platform gap. Fall back to the old behavior rather than
+                // leaving the worktree without a file it needs.
+                await deps.copyFile(source, destination);
+                result.copied.push(name);
+                result.warnings.push(symlinkUnsupportedWarning(name));
+            }
+        }
+        catch {
+            // Bounded on purpose: the caught error is never inspected for text, only
+            // discarded. A filesystem error message can carry an absolute path (which
+            // contains a username) and this string is printed to an operator summary.
+            result.warnings.push(linkFailedWarning(name));
+        }
+    }
+    return result;
+}

package/build/epic-integration-pr.js

@@ -0,0 +1,290 @@
+/**
+ * Shared, non-throwing helper that ensures a draft epic-integration PR exists
+ * (BAPI-951).
+ *
+ * Local `gh` is used deliberately here: the Bridge/server pull-request seam has
+ * no `draft` parameter and cannot distinguish GitHub's "no commits between
+ * branches" 422 from a credential or provider failure — both of which this
+ * helper must classify without throwing.
+ *
+ * A draft PR still receives the `conductor-ci / gate` required check (BAPI-949's
+ * trigger has no draft exclusion), while `claude-review.yml` excludes drafts
+ * until the PR is marked ready. So opening the integration PR as a draft earns
+ * the epic branch its required CI immediately, without paying for a paid review
+ * nobody can act on until a human decides the epic is ready.
+ */
+import { execFile as nodeExecFile } from "node:child_process";
+/** Bounded read timeout — matches the existing 5s GitHub probe limit (pr-discovery.ts). */
+export const EPIC_INTEGRATION_PR_READ_TIMEOUT_MS = 5_000;
+/** Separate, larger bounded timeout for the two write operations (`pr create`, `pr ready`). */
+export const EPIC_INTEGRATION_PR_WRITE_TIMEOUT_MS = 20_000;
+/** Bounded result count for the existence probe. */
+const LIST_LIMIT = 20;
+const PR_LIST_JSON_FIELDS = "number,headRefName,baseRefName,isDraft";
+/**
+ * `epic/<KEY>` prefix a child PR's base branch carries under BAPI-949/BAPI-950.
+ * Exported (BAPI-1010) so every call site that derives an epic key from a base
+ * branch shares one definition instead of re-declaring a private literal.
+ */
+export const EPIC_BRANCH_PREFIX = "epic/";
+/** The production call sites this helper is invoked from. */
+export const EPIC_INTEGRATION_PR_COMMANDS = [
+    "setup-epic",
+    "conduct-epic init",
+    "conduct-epic catch-up",
+    "conduct-epic finish",
+    "executor merge",
+    // BAPI-1010: the executor's one-shot wind-down observer, distinct from
+    // "executor merge" so the generated PR body and diagnostics never mislabel
+    // a done-state readiness request as a ticket merge enrichment.
+    "executor wind-down",
+];
+/** Only the sanctioned safe fields. Never raw command output. */
+export function formatEpicIntegrationPullRequestOutcome(outcome) {
+    if (outcome.kind === "already_open" || outcome.kind === "created") {
+        return {
+            kind: outcome.kind,
+            reason: outcome.reason,
+            pr_number: outcome.prNumber,
+            readiness: outcome.readiness,
+        };
+    }
+    return { kind: outcome.kind, reason: outcome.reason };
+}
+/** A concise, epic-specific PR title. Does not depend on `gh`. */
+export function buildEpicIntegrationPullRequestTitle(epicKey) {
+    return `${epicKey}: epic integration branch`;
+}
+/** A non-empty, epic-specific PR body. Does not depend on `gh`. */
+export function buildEpicIntegrationPullRequestBody(epicKey, command) {
+    return [
+        `\`${command}\` opened this pull request automatically.`,
+        "",
+        `It exists so the \`conductor-ci / gate\` required check runs for the ${epicKey} ` +
+            "epic integration branch (BAPI-949). Draft status postpones the paid Claude " +
+            "review until a human marks this pull request ready for review.",
+        "",
+        "Only a human merges an epic integration branch — the conductor never merges it.",
+    ].join("\n");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Bounded diagnostics to distinguish "no local gh", "not authenticated", and "inconclusive". */
+async function classifyGhUnavailable(gh, cwd) {
+    let version;
+    try {
+        version = await gh(["--version"], { cwd, timeoutMs: EPIC_INTEGRATION_PR_READ_TIMEOUT_MS });
+    }
+    catch {
+        return "gh_unavailable";
+    }
+    if (version.exitCode !== 0)
+        return "gh_unavailable";
+    let auth;
+    try {
+        auth = await gh(["auth", "status"], { cwd, timeoutMs: EPIC_INTEGRATION_PR_READ_TIMEOUT_MS });
+    }
+    catch {
+        return "probe_inconclusive";
+    }
+    if (auth.exitCode !== 0)
+        return "gh_unauthenticated";
+    return "probe_inconclusive";
+}
+/**
+ * Existence probe: `gh pr list` constrained by BOTH head and base. Only a
+ * successful, valid, empty JSON array is confirmed absence — anything else
+ * (non-zero exit, unparseable output, a non-array shape, an item with an
+ * invalid number, or a record whose head/base do not match) is `unavailable`,
+ * never treated as absence.
+ */
+async function probeMatchingOpenPr(gh, epicBranch, baseBranch, cwd) {
+    const args = [
+        "pr",
+        "list",
+        "--state",
+        "open",
+        "--head",
+        epicBranch,
+        "--base",
+        baseBranch,
+        "--json",
+        PR_LIST_JSON_FIELDS,
+        "--limit",
+        String(LIST_LIMIT),
+    ];
+    let result;
+    try {
+        result = await gh(args, { cwd, timeoutMs: EPIC_INTEGRATION_PR_READ_TIMEOUT_MS });
+    }
+    catch {
+        return { kind: "unavailable", reason: await classifyGhUnavailable(gh, cwd) };
+    }
+    if (result.exitCode !== 0) {
+        return { kind: "unavailable", reason: await classifyGhUnavailable(gh, cwd) };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(result.stdout);
+    }
+    catch {
+        return { kind: "unavailable", reason: "probe_malformed" };
+    }
+    if (!Array.isArray(parsed)) {
+        return { kind: "unavailable", reason: "probe_malformed" };
+    }
+    if (parsed.length === 0) {
+        return { kind: "absent" };
+    }
+    for (const item of parsed) {
+        if (!isRecord(item))
+            continue;
+        const number = item.number;
+        const head = item.headRefName;
+        const base = item.baseRefName;
+        const isDraft = item.isDraft;
+        if (typeof number === "number" &&
+            Number.isInteger(number) &&
+            number > 0 &&
+            head === epicBranch &&
+            base === baseBranch &&
+            typeof isDraft === "boolean") {
+            return { kind: "found", number, isDraft };
+        }
+    }
+    // Records exist but none matches both head and base exactly, or the shape is
+    // unexpected — never treated as absence.
+    return { kind: "unavailable", reason: "probe_malformed" };
+}
+const NO_COMMITS_BETWEEN_PATTERN = /no commits between/i;
+/** Strict positive numeric suffix of a normal `https://…/pull/<n>` URL, else `null`. */
+function extractPrNumberFromCreateOutput(stdout) {
+    const match = stdout.trim().match(/\/pull\/(\d+)\s*$/);
+    if (!match)
+        return null;
+    const n = Number(match[1]);
+    return Number.isInteger(n) && n > 0 ? n : null;
+}
+async function createDraftPr(gh, epicKey, epicBranch, baseBranch, command, cwd) {
+    const title = buildEpicIntegrationPullRequestTitle(epicKey);
+    const body = buildEpicIntegrationPullRequestBody(epicKey, command);
+    const args = [
+        "pr",
+        "create",
+        "--draft",
+        "--base",
+        baseBranch,
+        "--head",
+        epicBranch,
+        "--title",
+        title,
+        "--body",
+        body,
+    ];
+    let result;
+    try {
+        result = await gh(args, { cwd, timeoutMs: EPIC_INTEGRATION_PR_WRITE_TIMEOUT_MS });
+    }
+    catch {
+        return { kind: "create_failed" };
+    }
+    if (result.exitCode === 0) {
+        return { kind: "created", numberHint: extractPrNumberFromCreateOutput(result.stdout) };
+    }
+    const combined = `${result.stdout}\n${result.stderr}`;
+    if (NO_COMMITS_BETWEEN_PATTERN.test(combined)) {
+        return { kind: "no_commits" };
+    }
+    return { kind: "create_failed" };
+}
+async function maybeMakeReady(gh, prNumber, isDraft, requestReady, cwd) {
+    if (!requestReady)
+        return "not_requested";
+    if (prNumber === null)
+        return "ready_failed";
+    if (!isDraft)
+        return "already_ready";
+    try {
+        const result = await gh(["pr", "ready", String(prNumber)], {
+            cwd,
+            timeoutMs: EPIC_INTEGRATION_PR_WRITE_TIMEOUT_MS,
+        });
+        return result.exitCode === 0 ? "made_ready" : "ready_failed";
+    }
+    catch {
+        return "ready_failed";
+    }
+}
+async function ensureEpicIntegrationPullRequestInner(options) {
+    const { epicKey, epicBranch, baseBranch, command, gh, cwd, requestReady } = options;
+    const probe = await probeMatchingOpenPr(gh, epicBranch, baseBranch, cwd);
+    if (probe.kind === "unavailable") {
+        return { kind: "unavailable", reason: probe.reason };
+    }
+    if (probe.kind === "found") {
+        const readiness = await maybeMakeReady(gh, probe.number, probe.isDraft, requestReady, cwd);
+        return { kind: "already_open", reason: "already_open", prNumber: probe.number, readiness };
+    }
+    // Confirmed absent: create.
+    const created = await createDraftPr(gh, epicKey, epicBranch, baseBranch, command, cwd);
+    if (created.kind === "no_commits") {
+        return { kind: "deferred", reason: "no_commits_between_branches" };
+    }
+    if (created.kind === "created") {
+        // Resolve the number through a fresh matching probe first; fall back to the
+        // strict URL-derived hint only when the probe cannot confirm it.
+        const reprobe = await probeMatchingOpenPr(gh, epicBranch, baseBranch, cwd);
+        const prNumber = reprobe.kind === "found" ? reprobe.number : created.numberHint;
+        const isDraft = reprobe.kind === "found" ? reprobe.isDraft : true;
+        const readiness = await maybeMakeReady(gh, prNumber, isDraft, requestReady, cwd);
+        return { kind: "created", reason: "created", prNumber, readiness };
+    }
+    // Generic create failure: resolve a possible concurrent creator once, never more.
+    const race = await probeMatchingOpenPr(gh, epicBranch, baseBranch, cwd);
+    if (race.kind === "found") {
+        const readiness = await maybeMakeReady(gh, race.number, race.isDraft, requestReady, cwd);
+        return { kind: "already_open", reason: "already_open", prNumber: race.number, readiness };
+    }
+    return { kind: "unavailable", reason: "create_unavailable" };
+}
+/**
+ * Ensure a matching draft epic-integration pull request exists. Idempotent and
+ * never throws or rejects — every internal failure, including an injected
+ * runner throwing, resolves to `{ kind: "unavailable", ... }`.
+ */
+export async function ensureEpicIntegrationPullRequest(options) {
+    try {
+        return await ensureEpicIntegrationPullRequestInner(options);
+    }
+    catch {
+        return { kind: "unavailable", reason: "probe_inconclusive" };
+    }
+}
+/**
+ * Build the production `gh` runner. Uses `execFile` (never a shell, never
+ * interpolated argv), ignores stdin, captures stdout/stderr, and bounds both
+ * the timeout and the output buffer. Every process-level failure (missing
+ * binary, timeout, spawn error) resolves a non-zero/timed-out result rather
+ * than rejecting.
+ */
+export function createProductionEpicIntegrationGhRunner(execFileImpl = nodeExecFile) {
+    return (args, options) => new Promise((resolve) => {
+        execFileImpl("gh", args, {
+            cwd: options.cwd,
+            timeout: options.timeoutMs,
+            maxBuffer: 4 * 1024 * 1024,
+            encoding: "utf-8",
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+        }, (error, stdout, stderr) => {
+            if (error) {
+                const timedOut = error.killed === true;
+                const code = typeof error.code === "number" ? error.code : null;
+                resolve({ exitCode: code, stdout: stdout ?? "", stderr: stderr ?? "", timedOut });
+                return;
+            }
+            resolve({ exitCode: 0, stdout: stdout ?? "", stderr: stderr ?? "", timedOut: false });
+        });
+    });
+}

package/build/executor/cli.js

@@ -40,7 +40,11 @@ export function getExecutorUsage() {
         "  --repo <name>                 Repo to serve (repeatable).",
         "  --repos=<a,b>                 Comma-separated repos.",
         "  --epic-run-id <id>            Dedicate this executor to an epic run (repeatable).",
-        "                                Omit for the default repository-wide behavior.",
+        "  --repo-wide                   Explicit compatibility opt-out: claim from every",
+        "                                authorized repo, oldest-first, unscoped by run.",
+        "                                Exactly one of --epic-run-id or --repo-wide is",
+        "                                REQUIRED; omitting both is a startup error, not",
+        "                                repository-wide claiming (BAPI-1026 / R54).",
         "  --base-url <url>              Bridge API endpoint (overrides BAPI_BASE_URL).",
         "  --executor-id <id>            Stable executor id (default: <hostname>-<pid>).",
         "  --max-concurrent <n>          Max concurrent jobs (>= 1, default 1).",
@@ -83,6 +87,7 @@ function isValidEpicRunId(value) {
 export function parseExecutorArgs(argv, context) {
     const repos = [];
     const epicRunIds = [];
+    let repoWide = false;
     let executorId;
     let maxConcurrent = DEFAULT_MAX_CONCURRENT;
     let once = false;
@@ -122,6 +127,9 @@ export function parseExecutorArgs(argv, context) {
             if (!epicRunIds.includes(trimmed))
                 epicRunIds.push(trimmed);
         }
+        else if (arg === "--repo-wide") {
+            repoWide = true;
+        }
         else if (arg === "--executor-id") {
             executorId = argv[++i];
             if (!executorId)
@@ -182,6 +190,29 @@ export function parseExecutorArgs(argv, context) {
     const executorIdFinal = executorId && executorId.trim().length > 0
         ? executorId.trim()
         : `${context.hostname}-${context.pid}`;
+    // BAPI-1026 (R54) — the claim scope is now MANDATORY and explicit.
+    //
+    // Before this ticket, omitting `--epic-run-id` silently meant "claim the
+    // oldest queued row of ANY run in every authorized repo", which is how an
+    // executor could take a job belonging to an abandoned run (BAPI-993 B2). The
+    // server no longer treats an omitted scope as repository-wide once its
+    // deprecation window closes, so an executor started with no scope would poll
+    // forever and claim nothing. Refusing to START is the loud failure that
+    // replaces that silent idle: a misconfiguration is a startup error, visible
+    // immediately, rather than an executor that looks healthy and does no work.
+    if (repoWide && epicRunIds.length > 0) {
+        return {
+            kind: "error",
+            message: "--repo-wide cannot be combined with --epic-run-id: pass one claim scope, not both",
+        };
+    }
+    if (!repoWide && epicRunIds.length === 0) {
+        return {
+            kind: "error",
+            message: "a claim scope is required: pass --epic-run-id <id> (repeatable) to serve " +
+                "specific epic runs, or --repo-wide to deliberately claim repository-wide",
+        };
+    }
     const options = {
         executorId: executorIdFinal,
         repos,
@@ -208,6 +239,9 @@ export function parseExecutorArgs(argv, context) {
         // was supplied, so downstream `epicRunIds !== undefined` checks (the claim
         // manifest builder, startup diagnostics) see an unambiguous "unscoped".
         ...(epicRunIds.length > 0 ? { epicRunIds } : {}),
+        // BAPI-1026 (R54) — same "truly absent, never a falsy placeholder"
+        // discipline: `repoWide` is either `true` or the key is missing.
+        ...(repoWide ? { repoWide: true } : {}),
     };
     return { kind: "ok", options };
 }
@@ -267,14 +301,15 @@ export async function runExecutorCli(argv, overrides = {}) {
         return 1;
     }
     const options = parsed.options;
-    // BAPI-794 — startup diagnostics: only non-secret run identifiers, never
-    // credentials, job payloads, or command arguments beyond the run IDs
-    // themselves (which are not secrets — see EPIC_RUN_ID_PATTERN's docstring).
+    // BAPI-794/BAPI-1026 — startup diagnostics: a bounded MODE label and, when
+    // scoped, only the COUNT of runs. Never credentials, job payloads, command
+    // arguments — and, since BAPI-1026, never the run IDs either, matching the
+    // per-claim logging policy the server side already enforces.
     if (options.epicRunIds !== undefined) {
-        errorLog(`executor scoped to epic run(s): ${options.epicRunIds.join(", ")}`);
+        errorLog(`executor claim scope: scoped (epic_run_count=${options.epicRunIds.length})`);
     }
     else {
-        errorLog("executor running repository-wide (no --epic-run-id configured)");
+        errorLog("executor claim scope: repo_wide (explicit --repo-wide)");
     }
     // The mutating executor requires an EXPLICIT base URL (BAPI-676): `--base-url`
     // then `BAPI_BASE_URL`, never an implicit production default. Fail here —

package/build/executor/deps.js

@@ -9,7 +9,7 @@
  */
 import { execFile, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { open, readFile, writeFile, appendFile, mkdir, mkdtemp, chmod, rm, readdir, lstat, stat, statfs, } from "node:fs/promises";
+import { open, readFile, writeFile, appendFile, mkdir, mkdtemp, chmod, rm, rename, readdir, lstat, stat, statfs, } from "node:fs/promises";
 import os from "node:os";
 import { promisify } from "node:util";
 import { resolveMcpShimInvocationForRuntime } from "../mcp-server-invocation.js";
@@ -92,6 +92,10 @@ export function createDefaultExecutorDeps() {
             }
         },
         removeFile: (filePath) => rm(filePath, { force: true }),
+        // BAPI-1021 (AC-6): worker-log archival's rename seam. Real `fs.promises.rename`
+        // rejects with `code: "EXDEV"` across filesystems/devices, which worker-log.ts
+        // treats as an ordinary best-effort archive failure like any other.
+        rename: (oldPath, newPath) => rename(oldPath, newPath),
         stat: (filePath) => stat(filePath).then((s) => ({ mode: s.mode })),
         statMtimeMs: (filePath) => stat(filePath)
             .then((s) => s.mtimeMs)