@bridge_gpt/mcp-server 0.2.18 → 0.2.19

package/build/conductor/doctor.js

@@ -8,8 +8,110 @@
  * migration, no event emission, and no scheduler unit creation.
  */
 import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
 import { doctorConductorLedger } from "./store.js";
 import { inspectConductorGitHooks } from "./git-hooks.js";
+import { resolveMcpShimInvocationForRuntime, resolvePackageRootFromModuleUrl, } from "../mcp-server-invocation.js";
+/**
+ * Explicit not-run state for the `deny_enforcement` section when the probe is
+ * skipped via `--no-deny-probe`. Enforcement is UNVERIFIED, so the state is
+ * fail-safe: `enforced: false` with `status: "skip"` distinguishing a deliberate
+ * skip from a probed FATAL failure.
+ */
+export function skippedDenyEnforcementResult() {
+    return {
+        enforced: false,
+        layer: "none",
+        degraded: true,
+        status: "skip",
+        detail: "deny-enforcement preflight skipped via --no-deny-probe (no agent spawned)",
+        warnings: [
+            "Deny-enforcement preflight was SKIPPED (--no-deny-probe): enforcement is UNVERIFIED " +
+                "on this host. Do not treat this report as evidence the deny layer works.",
+        ],
+    };
+}
+/**
+ * Default reader for the package.json text (BAPI-526). Resolves the package root
+ * from this module's URL and reads `<packageRoot>/package.json`. Throws internally
+ * when the root cannot be resolved so the caller degrades to `engines_node: null`.
+ */
+export async function defaultReadPackageJson() {
+    const packageRoot = resolvePackageRootFromModuleUrl(import.meta.url);
+    if (!packageRoot) {
+        throw new Error("unable to resolve package root for package.json");
+    }
+    return readFileSync(`${packageRoot}/package.json`, "utf8");
+}
+/**
+ * Parse package.json text and return `engines.node` when it is a string; `null`
+ * otherwise. Never throws on malformed JSON — returns `null`.
+ */
+export function readExpectedNodeEngine(packageJsonText) {
+    try {
+        const pkg = JSON.parse(packageJsonText);
+        const node = pkg.engines?.node;
+        return typeof node === "string" ? node : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Build the read-only native-ledger inspection (BAPI-526). Composes the ledger
+ * doctor's native-load result with the expected Node engine and the resolved MCP
+ * shim invocation. Never opens the ledger, never throws to callers, and never
+ * includes raw package paths, stack traces, or the absolute server entry path.
+ */
+export async function inspectNativeLedger(nativeLoad, deps = {}) {
+    const warnings = [];
+    // Expected Node engine (fail-soft to null on any read/parse failure).
+    let engines_node = null;
+    try {
+        const readPkg = deps.readPackageJson ?? defaultReadPackageJson;
+        engines_node = readExpectedNodeEngine(await readPkg());
+    }
+    catch {
+        engines_node = null;
+    }
+    // MCP shim invocation (resolvable absolute-build-path vs npm-channel fallback).
+    const invocation = deps.resolveMcpInvocation
+        ? deps.resolveMcpInvocation()
+        : resolveMcpShimInvocationForRuntime({
+            moduleUrl: import.meta.url,
+            nodeExecutable: "node",
+            argv1: process.argv[1],
+            fileExists: existsSync,
+        });
+    // Path-safe: expose only the node executable for the absolute form (never the
+    // server entry path), and null for the npm-channel fallback.
+    const mcp_shim_node = invocation.form === "absolute-build-path" ? invocation.nodeExecutable : null;
+    const binding_loads = nativeLoad.loads;
+    const failure_kind = nativeLoad.failure_kind;
+    if (nativeLoad.degraded && nativeLoad.warning) {
+        warnings.push(nativeLoad.warning);
+    }
+    if (invocation.form !== "absolute-build-path") {
+        warnings.push("Worker MCP registration would use the npm-channel fallback (no resolvable on-disk build entry); " +
+            "registration reliability depends on the package being published.");
+    }
+    if (engines_node === null) {
+        warnings.push("Could not read package.json engines.node; expected Node version is unknown.");
+    }
+    const degraded = nativeLoad.degraded || invocation.form !== "absolute-build-path" || engines_node === null;
+    return {
+        cli_node_version: process.version,
+        engines_node,
+        mcp_shim_node,
+        mcp_registration_form: invocation.form,
+        module: nativeLoad.module,
+        node_modules_abi: nativeLoad.node_modules_abi,
+        binding_loads,
+        failure_kind,
+        degraded,
+        warnings,
+    };
+}
 /**
  * Inspect the local schedule metadata store for a registered epic-tick schedule.
  * Strictly read-only: composes orchestrateScheduleList (read-only list path) and
@@ -175,21 +277,58 @@ export async function buildConductorDoctorReport(deps = {}) {
     const inspectHooks = deps.inspectHooks ?? inspectConductorGitHooks;
     const epicTick = await inspectEpicTickSchedule(deps.scheduleDeps, deps.orchestrateList);
     const mcp_profile = inspectMcpProfile(deps.env ?? process.env, epicTick);
+    // Resolve the ledger once so the native-load probe reflects the same report.
+    const ledger = await doctorLedger();
+    const native_ledger = await inspectNativeLedger(ledger.native_load, deps);
+    const deny_enforcement = deps.skipDenyProbe
+        ? skippedDenyEnforcementResult()
+        : await inspectDenyEnforcementSafe(deps.inspectDenyEnforcement);
     return {
-        ledger: await doctorLedger(),
+        ledger,
         git_hooks: inspectHooks(deps.hooksDeps),
         epic_tick: epicTick,
         mcp_profile,
         local_merge: inspectLocalMerge(deps.runCommand),
+        native_ledger,
+        deny_enforcement,
     };
 }
+/**
+ * Run the deny-enforcement inspector and convert any thrown exception into degraded
+ * report data — a deny-probe failure must never throw out of doctor. The underlying
+ * predicate is already exception-safe; this is defense-in-depth for an injected fake.
+ */
+async function inspectDenyEnforcementSafe(inspect) {
+    try {
+        let run = inspect;
+        if (!run) {
+            // Lazy import keeps the agent-capabilities graph out of doctor.ts's static
+            // module graph (see the import-site comment above).
+            const mod = await import("./deny-enforcement-preflight.js");
+            run = mod.runDenyEnforcementPreflight;
+        }
+        return await run();
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            enforced: false,
+            layer: "none",
+            degraded: true,
+            warnings: [
+                `Deny-layer enforcement inspection failed: ${msg}`,
+                "The executor claim loop MUST refuse to claim jobs until the deny layer is enforced.",
+            ],
+        };
+    }
+}
 /**
  * Render the combined doctor report as human-readable text: ledger health,
  * git hooks section, and an Epic Supervisor Schedule section using semantic
  * status tags consistent with the git hooks section's visual hierarchy.
  */
 export function formatConductorDoctorReport(report) {
-    const { ledger, git_hooks, epic_tick, mcp_profile, local_merge } = report;
+    const { ledger, git_hooks, epic_tick, mcp_profile, local_merge, native_ledger, deny_enforcement } = report;
     const lines = [
         "Conductor ledger doctor",
         "───────────────────────",
@@ -270,5 +409,47 @@ export function formatConductorDoctorReport(report) {
         for (const w of local_merge.warnings)
             lines.push(`  - ${w}`);
     }
+    lines.push("");
+    lines.push("Native ledger module (required for conductor coordination)");
+    lines.push("─────────────────────────────────────────────────────────");
+    const nativeTag = native_ledger.binding_loads && !native_ledger.degraded ? "[OK]" : "[WARNING] degraded";
+    // Strictly diagnostic — reports the skew but never suggests an automatic
+    // install/rebuild/migration (BAPI-526 is detection only).
+    lines.push(`binding loads:         ${native_ledger.binding_loads} ${nativeTag}`);
+    lines.push(`module:                ${native_ledger.module}`);
+    lines.push(`CLI Node:              ${native_ledger.cli_node_version}`);
+    lines.push(`engines.node:          ${native_ledger.engines_node ?? "n/a"}`);
+    lines.push(`MCP shim Node:         ${native_ledger.mcp_shim_node ?? "n/a"}`);
+    lines.push(`NODE_MODULE_VERSION:   ${native_ledger.node_modules_abi}`);
+    lines.push(`registration form:     ${native_ledger.mcp_registration_form}`);
+    lines.push(`failure kind:          ${native_ledger.failure_kind}`);
+    lines.push(`degraded:              ${native_ledger.degraded}`);
+    if (native_ledger.warnings.length > 0) {
+        lines.push("native ledger warnings:");
+        for (const w of native_ledger.warnings)
+            lines.push(`  - ${w}`);
+    }
+    lines.push("");
+    lines.push("Deny-layer enforcement preflight (required for executor claim)");
+    lines.push("─────────────────────────────────────────────────────────────");
+    // OK when enforced by settings-deny (non-degraded); WARNING when relying on the
+    // PreToolUse fallback; SKIPPED when the probe was deliberately not run
+    // (--no-deny-probe, enforcement unverified); FATAL when nothing enforces — the
+    // executor must refuse to claim.
+    const denyTag = deny_enforcement.status === "skip"
+        ? "[SKIPPED] probe not run (--no-deny-probe) — enforcement unverified"
+        : !deny_enforcement.enforced
+            ? "[FATAL] deny not enforced — executor must refuse to claim jobs"
+            : deny_enforcement.degraded
+                ? "[WARNING] degraded — relying on PreToolUse fallback"
+                : "[OK]";
+    lines.push(`enforced:              ${deny_enforcement.enforced} ${denyTag}`);
+    lines.push(`layer:                 ${deny_enforcement.layer}`);
+    lines.push(`degraded:              ${deny_enforcement.degraded}`);
+    if (deny_enforcement.warnings.length > 0) {
+        lines.push("deny enforcement warnings:");
+        for (const w of deny_enforcement.warnings)
+            lines.push(`  - ${w}`);
+    }
     return lines.join("\n");
 }

package/build/conductor/epic-reconcile.js

@@ -78,7 +78,15 @@ export async function reconcileEpic(access, observed, plan, deps, supervisorConf
             deps.log(`[epic-reconcile] folded ${signal.signal_type} for ${signal.ticket_key} → ${signal.next_status}`);
             // BAPI-442: fire teardown + Jira transition strictly after merge.succeeded
             // CAS → done. Both are fail-open: errors are logged and never abort the pass.
-            if (signal.signal_type === "merge.succeeded") {
+            // BAPI-527: additionally require next_status === "done". Post-merge parse
+            // (parse-after-merge) folds a merge.succeeded signal to `parse_pending` while
+            // the repository re-index runs, and to `blocked` on permanent parse failure —
+            // teardown/Jira transition must NOT fire in either of those non-done folds, or
+            // the merged branch/worktree would be torn down (and Jira transitioned) before
+            // the ticket is truly done. They fire only once the ticket actually reaches
+            // `done` (either an immediate merge.succeeded fold when parse-after-merge is
+            // off, or the later parse-success fold that re-tags next_status back to "done").
+            if (signal.signal_type === "merge.succeeded" && signal.next_status === "done") {
                 if (supervisorConfig?.teardown_enabled && deps.teardownSeam) {
                     await deps.teardownSeam(observed.epic_key, signal.ticket_key).catch((e) => {
                         const safeMsg = e instanceof Error ? e.constructor.name : "teardown error";