@bridge_gpt/mcp-server 0.2.66 → 0.2.68

package/build/executor/likely-tests.js

@@ -0,0 +1,290 @@
+/**
+ * Local, read-only discovery. Optional .bridge/verification-hints.json is
+ * {version:1,pins:[{paths:["exact/file", "directory/"],tests:["reference"]}]}.
+ * Exact paths match exactly; directory prefixes match at directory boundaries.
+ * Optional .conductor/recently-failed-tests.json is
+ * {version:1,tests:["most-recent-first reference"],truncated:false}.
+ * Child 3 writes recent failures under the worker worktree before each spawn.
+ * References are data only, never commands. Priority: recent failures, ordered
+ * pins, sorted inferred tracked tests; exact deduplication precedes the limit.
+ * Missing/malformed/unreadable/truncated sources degrade advisory coverage.
+ */
+import path from "node:path";
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import { execFile } from "node:child_process";
+export const RECENTLY_FAILED_TESTS_PATH = ".conductor/recently-failed-tests.json";
+export const RECENTLY_FAILED_TESTS_MAX_COUNT = 20;
+export const TEST_REFERENCE_MAX_LENGTH = 512;
+export const MAX_OUTPUT_REFERENCES = 100;
+export const MAX_SCAN_FILE_BYTES = 256 * 1024;
+export const MAX_SCAN_TOTAL_BYTES = 16 * 1024 * 1024;
+export const MAX_CANDIDATE_FILES = 10_000;
+export const MAX_OPTIONAL_JSON_BYTES = 256 * 1024;
+export const GIT_TIMEOUT_MS = 10_000;
+export const GIT_MAX_STDOUT_BYTES = 4 * 1024 * 1024;
+export const DISCOVERY_NOTES = {
+    invalid_arguments: "Likely-tests discovery unavailable: expected only --base and a full commit SHA.",
+    git_unavailable: "Likely-tests git discovery unavailable; retain available targeted verification.",
+    hints_missing: "Optional verification hints are absent.",
+    data_unavailable: "Optional discovery data is malformed or unreadable.",
+    skipped_entries: "Invalid discovery entries were skipped.",
+    scan_unavailable: "Some test candidates could not be read safely.",
+    truncated: "Likely-tests coverage is truncated by a resource bound.",
+    empty: "No likely tests discovered; retain targeted verification.",
+};
+export function isFullCommitSha(value) { return /^[a-fA-F0-9]{40}$/.test(value); }
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value : undefined;
+}
+export function validTestReference(value) {
+    return typeof value === "string" && value.trim().length > 0 &&
+        value.length <= TEST_REFERENCE_MAX_LENGTH && !/[\x00-\x1f\x7f-\x9f\u2028\u2029]/.test(value);
+}
+function validRepoPath(value, directory = false) {
+    const candidate = directory && value.endsWith("/") ? value.slice(0, -1) : value;
+    return !!candidate && !path.isAbsolute(candidate) && !/[:\\\x00-\x1f\x7f-\x9f\u2028\u2029]/.test(candidate) &&
+        candidate.split("/").every(p => p !== "" && p !== "." && p !== "..");
+}
+function validReference(value) {
+    if (!validTestReference(value))
+        return false;
+    const file = value.split("::")[0];
+    const fileShaped = value.includes("/") || /\.(?:py|[cm]?[jt]sx?)(?:::|$)/.test(value) || value.includes("::");
+    return !fileShaped || validRepoPath(file);
+}
+export function parseRecentlyFailedTests(value) {
+    const doc = object(value);
+    if (!doc || doc.version !== 1 || !Array.isArray(doc.tests) || typeof doc.truncated !== "boolean")
+        return { available: false };
+    const tests = [];
+    let skipped = false;
+    for (const test of doc.tests) {
+        if (!validReference(test)) {
+            skipped = true;
+            continue;
+        }
+        if (tests.length < RECENTLY_FAILED_TESTS_MAX_COUNT)
+            tests.push(test);
+    }
+    return { available: true, value: { version: 1, tests,
+            truncated: doc.truncated || doc.tests.length > RECENTLY_FAILED_TESTS_MAX_COUNT }, skipped };
+}
+function parseHints(value) {
+    const doc = object(value);
+    if (!doc || doc.version !== 1 || !Array.isArray(doc.pins))
+        return undefined;
+    const pins = [];
+    let skipped = false;
+    for (const entry of doc.pins) {
+        const pin = object(entry);
+        if (!pin || !Array.isArray(pin.paths) || !Array.isArray(pin.tests)) {
+            skipped = true;
+            continue;
+        }
+        const paths = pin.paths.filter((p) => typeof p === "string" && validRepoPath(p, true));
+        const tests = pin.tests.filter(validReference);
+        if (paths.length !== pin.paths.length || tests.length !== pin.tests.length)
+            skipped = true;
+        if (paths.length && tests.length)
+            pins.push({ paths, tests });
+        else
+            skipped = true;
+    }
+    return { pins, skipped };
+}
+/** No-follow and fstat protect the final component; lstat every ancestor first.
+ * Reads at most limit+1 bytes even if a file grows between stat and read.
+ */
+async function containedText(root, relative, limit) {
+    if (!validRepoPath(relative))
+        throw new Error("invalid_path");
+    let current = root;
+    for (const part of relative.split("/")) {
+        current = path.join(current, part);
+        const info = await lstat(current);
+        if (info.isSymbolicLink())
+            throw new Error("symlink");
+        if (current !== path.join(root, relative) && !info.isDirectory())
+            throw new Error("ancestor");
+    }
+    const handle = await open(current, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    try {
+        const info = await handle.stat();
+        if (!info.isFile())
+            throw new Error("not_regular");
+        if (info.size > limit)
+            throw new Error("bound");
+        const buffer = Buffer.alloc(limit + 1);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        if (bytesRead > limit)
+            throw new Error("bound");
+        return buffer.subarray(0, bytesRead).toString("utf8");
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function boundedGit(cwd, argv) {
+    return new Promise((resolve, reject) => {
+        execFile("git", argv, { cwd, shell: false, timeout: GIT_TIMEOUT_MS,
+            maxBuffer: GIT_MAX_STDOUT_BYTES, encoding: "utf8" }, (error, stdout) => {
+            if (error)
+                reject(new Error("git_unavailable"));
+            else
+                resolve(stdout);
+        });
+    });
+}
+function nulPaths(output) {
+    if (output && !output.endsWith("\0"))
+        throw new Error("git_unavailable");
+    return output.split("\0").filter(Boolean);
+}
+const ordinal = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function testCandidate(file) {
+    const base = path.posix.basename(file);
+    return /^test_.*\.py$|^.*_test\.py$|\.(?:test|spec)\.[cm]?[jt]sx?$/.test(base);
+}
+/** Discover declared Python source roots without importing any project code. */
+async function pythonRoots(root, read) {
+    const roots = [""];
+    for (const file of ["pyproject.toml", "pytest.ini", "setup.cfg"]) {
+        try {
+            const text = await read(root, file, MAX_SCAN_FILE_BYTES);
+            for (const match of text.matchAll(/(?:pythonpath|package-dir|package_dir)\s*=\s*([^\n]+)/g)) {
+                for (const token of match[1].matchAll(/["']([^"']+)["']|\b([a-zA-Z][\w/-]*)\b/g)) {
+                    const value = token[1] ?? token[2];
+                    if (validRepoPath(value))
+                        roots.push(value + "/");
+                }
+            }
+        }
+        catch { /* absent runner declarations are normal */ }
+    }
+    return [...new Set(roots)];
+}
+export async function resolveLikelyTests(options) {
+    const references = [];
+    const diagnostics = new Set();
+    const add = (items) => {
+        for (const item of items)
+            if (!references.includes(item))
+                references.push(item);
+    };
+    const finish = () => {
+        if (references.length > MAX_OUTPUT_REFERENCES)
+            diagnostics.add("truncated");
+        if (!references.length)
+            diagnostics.add("empty");
+        return { references: references.slice(0, MAX_OUTPUT_REFERENCES), diagnostics: [...diagnostics] };
+    };
+    if (!isFullCommitSha(options.comparisonSha)) {
+        diagnostics.add("invalid_arguments");
+        return finish();
+    }
+    const git = options.git ?? boundedGit;
+    const read = options.readText ?? containedText;
+    let root;
+    try {
+        root = (await git(options.cwd, ["rev-parse", "--show-toplevel"])).trim();
+        if (!path.isAbsolute(root))
+            throw new Error("root");
+    }
+    catch {
+        diagnostics.add("git_unavailable");
+        return finish();
+    }
+    try {
+        const raw = await read(root, RECENTLY_FAILED_TESTS_PATH, MAX_OPTIONAL_JSON_BYTES);
+        const recent = parseRecentlyFailedTests(JSON.parse(raw));
+        if (!recent.available)
+            diagnostics.add("data_unavailable");
+        else {
+            add(recent.value.tests);
+            if (recent.skipped)
+                diagnostics.add("skipped_entries");
+            if (recent.value.truncated)
+                diagnostics.add("truncated");
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            diagnostics.add("data_unavailable");
+    }
+    let hints;
+    try {
+        hints = parseHints(JSON.parse(await read(root, ".bridge/verification-hints.json", MAX_OPTIONAL_JSON_BYTES)));
+        if (!hints)
+            diagnostics.add("data_unavailable");
+        else if (hints.skipped)
+            diagnostics.add("skipped_entries");
+    }
+    catch (error) {
+        diagnostics.add(error.code === "ENOENT" ? "hints_missing" : "data_unavailable");
+    }
+    let changed;
+    try {
+        const verified = (await git(root, ["rev-parse", "--verify", `${options.comparisonSha}^{commit}`])).trim();
+        if (!isFullCommitSha(verified))
+            throw new Error("commit");
+        const paths = nulPaths(await git(root, ["diff", "--name-only", "-z", `${options.comparisonSha}..HEAD`]));
+        changed = paths.filter(p => validRepoPath(p));
+        if (changed.length !== paths.length)
+            diagnostics.add("skipped_entries");
+    }
+    catch {
+        diagnostics.add("git_unavailable");
+        return finish();
+    }
+    for (const pin of hints?.pins ?? []) {
+        if (pin.paths.some(p => changed.some(c => p.endsWith("/") ? c.startsWith(p) : c === p)))
+            add(pin.tests);
+    }
+    let tracked;
+    try {
+        const paths = nulPaths(await git(root, ["ls-files", "-z"]));
+        tracked = paths.filter(p => validRepoPath(p));
+        if (tracked.length !== paths.length)
+            diagnostics.add("skipped_entries");
+    }
+    catch {
+        diagnostics.add("git_unavailable");
+        return finish();
+    }
+    const candidates = tracked.filter(testCandidate).sort(ordinal);
+    if (candidates.length > MAX_CANDIDATE_FILES)
+        diagnostics.add("truncated");
+    const roots = await pythonRoots(root, read);
+    const literals = new Set(changed);
+    for (const file of changed) {
+        if (/\.[cm]?[jt]sx?$/.test(file)) {
+            literals.add(path.posix.basename(file));
+            literals.add(path.posix.basename(file).replace(/\.[cm]?[jt]sx?$/, ".js"));
+        }
+        if (file.endsWith(".py"))
+            for (const source of roots) {
+                if (file.startsWith(source))
+                    literals.add(file.slice(source.length, -3).replaceAll("/", ".").replace(/\.__init__$/, ""));
+            }
+    }
+    let scanned = 0;
+    for (const candidate of candidates.slice(0, MAX_CANDIDATE_FILES)) {
+        try {
+            const text = await read(root, candidate, MAX_SCAN_FILE_BYTES);
+            const size = Buffer.byteLength(text);
+            if (scanned + size > MAX_SCAN_TOTAL_BYTES) {
+                diagnostics.add("truncated");
+                break;
+            }
+            scanned += size;
+            if ([...literals].some(literal => literal && text.includes(literal)))
+                add([candidate]);
+        }
+        catch (error) {
+            diagnostics.add(error.message === "bound" ? "truncated" : "scan_unavailable");
+        }
+    }
+    return finish();
+}

package/build/executor/live-worker-registry.js

@@ -43,7 +43,7 @@ export function createLiveWorkerRegistry() {
             return;
         alreadyRequested.add(controller);
         try {
-            controller.requestTermination();
+            controller.requestTermination("executor_shutdown");
         }
         catch {
             // Fail-open, and deliberately silent. A controller that throws is a defect

package/build/executor/observation.js

@@ -1,3 +1,4 @@
+import { createWorkerDiagnosticsState } from "./worker-diagnostics.js";
 /**
  * Collect load-bearing git telemetry from a worktree. Individual git failures
  * degrade the telemetry (fields omitted) rather than throwing — a degraded
@@ -34,9 +35,14 @@ export async function collectGitTelemetry(deps, worktreePath, baseBranch) {
         /* degraded: omit last_commit_sha */
     }
     try {
+        // `--no-optional-locks`: a plain `git status` refreshes the index and takes
+        // `.git/index.lock`. This runs on every heartbeat against the LIVE worker's
+        // worktree, so without it a worker's own `git add`/`commit` can fail with
+        // "index.lock: File exists".
         const status = await deps.runCommand("git", [
             "-C",
             worktreePath,
+            "--no-optional-locks",
             "status",
             "--porcelain",
         ]);
@@ -293,7 +299,7 @@ const RATE_LIMIT_CONSEQUENCE_TEXT = "This warning is advisory only and triggers
     "rejection and the server advertised capacity recovery for this job; otherwise " +
     "the failure follows ordinary failure handling.";
 /** Fixed runbook reference appended to every rate-limit diagnostic (BAPI-898). */
-const RATE_LIMIT_RUNBOOK_REFERENCE = "See docs/claude/epic-implementer-v2-operator-runbook.md §8.";
+const RATE_LIMIT_RUNBOOK_REFERENCE = "See docs/epic-implementer/operator-runbook.md §8.";
 /**
  * Render the operator-facing rate-limit line (BAPI-828, BAPI-898).
  *
@@ -598,7 +604,10 @@ export const MAX_BUFFERED_ADVISORY_LINE_CHARS = 1_048_576;
  * on bad input, so ordinary success never depends on it either.
  */
 export function createObservationState(deps, options) {
+    const diagnostics = createWorkerDiagnosticsState();
     let git = {};
+    let publication;
+    let publicationInvalid = false;
     const advisory = {};
     let exitCode;
     let attemptStartSha;
@@ -676,6 +685,7 @@ export function createObservationState(deps, options) {
         }
     };
     const consumeLine = (line) => {
+        diagnostics.observeLine(line);
         if (options.advisoryParserEnabled)
             consumeAdvisoryLine(line);
         if (terminalCapacityParserEnabled)
@@ -684,8 +694,6 @@ export function createObservationState(deps, options) {
     return {
         recordStdout(chunk) {
             advisory.last_stdout_at = new Date(deps.now()).toISOString();
-            if (!options.advisoryParserEnabled && !terminalCapacityParserEnabled)
-                return;
             if (typeof chunk !== "string" || chunk.length === 0)
                 return;
             // BAPI-828: line assembly replaces the previous per-chunk `split("\n")`.
@@ -748,8 +756,34 @@ export function createObservationState(deps, options) {
         git() {
             return git;
         },
+        allocateAttemptLog(identity, allocated) {
+            diagnostics.allocateLog(identity, allocated);
+        },
+        workerDiagnostics() { return diagnostics.snapshot(); },
+        recordPublication(fact) {
+            if (publicationInvalid)
+                return;
+            const valid = (sha) => /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i.test(sha);
+            if (!valid(fact.from_sha) || !valid(fact.to_sha) || fact.from_sha === fact.to_sha)
+                return;
+            if (!publication) {
+                publication = { ...fact };
+                return;
+            }
+            if (publication.jobId !== fact.jobId || publication.branch !== fact.branch ||
+                publication.to_sha !== fact.from_sha) {
+                publication = undefined;
+                publicationInvalid = true;
+                return;
+            }
+            publication = { ...publication, to_sha: fact.to_sha };
+        },
         snapshot() {
             const residue = { ...git };
+            if (publication) {
+                const observed = { from_sha: publication.from_sha, to_sha: publication.to_sha };
+                residue.published_head = observed;
+            }
             if (advisory.phase_hint)
                 residue.phase_hint = advisory.phase_hint;
             if (advisory.last_stdout_at)

package/build/executor/packaged-recipe.js

@@ -0,0 +1,106 @@
+/**
+ * Packaged-recipe delivery for executor workers (BAPI-1392).
+ *
+ * Command provisioning is fill-only (BAPI-664): a command file the customer
+ * already committed under `.claude/commands/` is a customer asset and is never
+ * refreshed, so a worker that resolves `/implement-ticket` itself would run a
+ * stale committed copy. This module supplies the CURRENT packaged recipe instead,
+ * by expanding it into the worker prompt before the adapter builds the launch.
+ *
+ * DELIVERY PATH: prompt expansion. Both prompt transports (`-p <prompt>` argv and
+ * the held-stdin stream-json first message) carry exactly the prompt the runner
+ * hands the adapter, so one expansion reaches both with no launcher-option
+ * dependence. Nothing is written under the worker worktree and no Git index flag
+ * is touched; the worktree's command files keep the bytes provisioning left.
+ *
+ * WHAT IS RECOGNIZED (and nothing else):
+ *   1. A LEADING invocation — the prompt's first token is `/<name>` — which is how
+ *      the synthesized `/implement-ticket <KEY> --auto` arrives. Its arguments are
+ *      everything after the name, exactly as the slash command would receive them
+ *      (so an appended PR-base instruction stays part of `$ARGUMENTS`). A BAPI-1367
+ *      continuation notice may precede it; the notice's own mention of the command
+ *      is never an invocation.
+ *   2. A NESTED invocation written as ``Run `/<name> <args>` `` — the shape the
+ *      server-built `spec_review` prompt uses for `/review-ticket`. The span is
+ *      replaced by a pointer and the recipe is appended once, below the prompt.
+ * Quoted ticket text, arbitrary slash-prefixed prose and a bare mention are left
+ * alone. A name is recognized only when `<name>.md` is a key of the packaged
+ * catalog, and never when the command is in the job's customized list (those keep
+ * the customer's committed copy). A prompt with no recognized invocation is
+ * returned byte-identical. Delivered recipes are NOT expanded recursively.
+ */
+import { COMMANDS } from "../commands.generated.js";
+/** Marker pair of the BAPI-1367 continuation notice (see `job-runner.ts`). */
+const CONTINUATION_NOTICE_START = "CONTINUATION: this is a retry.";
+const CONTINUATION_NOTICE_END = "The original instructions follow unchanged.\n\n";
+const NAME = "[a-z][a-z0-9-]*";
+const LEADING_RE = new RegExp(`^/(${NAME})(?=\\s|$)`);
+const NESTED_RE = new RegExp("\\bRun `/(" + NAME + ")(?: ([^`\\n]*))?`", "g");
+function isPackaged(name, catalog) {
+    return Object.prototype.hasOwnProperty.call(catalog, `${name}.md`);
+}
+/** Drop a leading `---` frontmatter block, as the slash-command loader does. */
+function stripFrontmatter(text) {
+    const match = /^---\r?\n[\s\S]*?\r?\n---\r?\n?/.exec(text);
+    return match ? text.slice(match[0].length) : text;
+}
+/** `$ARGUMENTS` substitution with a function replacer so `$&`-style bytes survive. */
+function renderRecipe(recipe, args) {
+    return stripFrontmatter(recipe).replace(/\$ARGUMENTS/g, () => args);
+}
+function undeliverable(reason, command) {
+    return {
+        ok: false,
+        reason,
+        command,
+        error: `packaged recipe for /${command} could not be delivered (reason=${reason})`,
+    };
+}
+export function resolvePackagedRecipes(prompt, customizedCommands, catalog = COMMANDS) {
+    const customized = new Set(customizedCommands);
+    const deliverable = (name) => isPackaged(name, catalog) && !customized.has(name);
+    // Offset of the "original instructions" after an optional continuation notice.
+    let offset = 0;
+    if (prompt.startsWith(CONTINUATION_NOTICE_START)) {
+        const end = prompt.indexOf(CONTINUATION_NOTICE_END);
+        if (end >= 0)
+            offset = end + CONTINUATION_NOTICE_END.length;
+    }
+    const head = prompt.slice(0, offset);
+    const body = prompt.slice(offset);
+    // 1. Leading invocation: the whole body becomes the recipe.
+    const leading = LEADING_RE.exec(body);
+    if (leading && deliverable(leading[1])) {
+        const name = leading[1];
+        const args = body.slice(leading[0].length).replace(/^\s+/, "");
+        const recipe = renderRecipe(catalog[`${name}.md`], args);
+        if (recipe.trim().length === 0)
+            return undeliverable("empty_recipe", name);
+        return { ok: true, prompt: `${head}${recipe}`, delivered: [name] };
+    }
+    // 2. Nested invocations: one appended block per command name.
+    const blocks = new Map(); // name -> args
+    for (const m of body.matchAll(NESTED_RE)) {
+        const name = m[1];
+        if (!deliverable(name))
+            continue;
+        const args = m[2] ?? "";
+        const seen = blocks.get(name);
+        if (seen !== undefined && seen !== args)
+            return undeliverable("conflicting_arguments", name);
+        blocks.set(name, args);
+    }
+    if (blocks.size === 0)
+        return { ok: true, prompt, delivered: [] };
+    const rewritten = body.replace(NESTED_RE, (whole, name, args) => blocks.has(name)
+        ? `Run the packaged /${name} recipe given below with arguments \`${args ?? ""}\``
+        : whole);
+    const appended = [];
+    for (const [name, args] of blocks) {
+        const recipe = renderRecipe(catalog[`${name}.md`], args);
+        if (recipe.trim().length === 0)
+            return undeliverable("empty_recipe", name);
+        appended.push(`\n\n=== PACKAGED RECIPE /${name} (arguments: ${args}) ===\n${recipe}\n=== END PACKAGED RECIPE /${name} ===`);
+    }
+    return { ok: true, prompt: `${head}${rewritten}${appended.join("")}`, delivered: [...blocks.keys()] };
+}