@bridge_gpt/mcp-server 0.2.60 → 0.2.65

package/build/conductor/epic-implementer-cli.js

@@ -20,16 +20,19 @@
  * unchanged until S5.
  */
 import { readFileSync, unlinkSync } from "node:fs";
+import { createRequire } from "node:module";
 import { ConductorValidationError, ConductorEpicTickV1FrozenError, toConductorErrorEnvelope, } from "./errors.js";
 import { emitConductorEvent, purgeConductorLedger, sendWorkerMessage, checkWorkerMessages, } from "./store.js";
 import { isDuplicateConstraintError } from "./producer-ledger.js";
 import { SEMANTIC_EVENT_TYPES } from "./taxonomy.js";
 import { DRIVER_CONTEXT_MAX_BYTES, POLICY_PATCH_MAX_BYTES } from "./repair-contract.js";
-import { installConductorGitHooks, resolveConductorHookBin } from "./git-hooks.js";
+import { CONDUCTOR_BIN_UNRESOLVED_ERROR, installConductorGitHooks, resolveConductorHookBin, } from "./git-hooks.js";
+import { HOOK_RUNTIME_PROBE_ACTION, HOOK_RUNTIME_PROBE_MARKER } from "./hook-runtime-qualification.js";
 import { runFileScopeGuardCli } from "./file-scope-guard.js";
 import { runPostCommitHookProducer, runReferenceTransactionHookProducer } from "./git-producer.js";
 import { buildConductorDoctorReport, formatConductorDoctorReport } from "./doctor.js";
 import { resolveSupervisorConfig } from "./supervisor-config.js";
+import { VERSION } from "../version.generated.js";
 // `runSupervisor` is imported LAZILY inside runSuperviseCommand: it transitively
 // pulls in the SQLite store, and a static import here would force every
 // epic-implementer CLI invocation (and every test that mocks ./store.js for the
@@ -103,6 +106,12 @@ export function getConductorUsage() {
         "  resume-run --epic-run-id <id> [--clear-quarantine] [--json]",
         "                       Resume a paused run (a quarantined one only with --clear-quarantine);",
         "                       activation is re-checked server-side. Active/no-control is a no-op.",
+        "  continue-child --epic-run-id <id> --ticket-key <key> [--reason <text>] [--json]",
+        "                       Continue a parked child's CURRENT episode WITHOUT a reset: same attempt,",
+        "                       retained work, only the allowance left. At most one dispatch per episode.",
+        "  continuation-receipt --epic-run-id <id> --ticket-key <key> [--request-id <id>] [--json]",
+        "                       Read-only: the child's current episode and whether a continuation",
+        "                       request's receipt proves it committed (use after a lost response).",
         "",
         "supervise options:",
         "  --run-id <id>             Run/session identifier to supervise (required)",
@@ -241,6 +250,10 @@ export function getConductorUsage() {
         "  epic-implementer unpark --epic-run-id 3f9c2b7e-... --ticket-key BAPI-852",
         "  # A human pushed directly to the PR and the ticket parked on head drift:",
         "  epic-implementer adopt-current-head-and-unpark --epic-run-id 3f9c2b7e-... --ticket-key BAPI-852",
+        "  # A child stopped mid-attempt and should carry on WITHOUT resetting its budget:",
+        "  epic-implementer continue-child --epic-run-id 3f9c2b7e-... --ticket-key BAPI-852",
+        "  # The continue-child response was lost — did it commit?",
+        "  epic-implementer continuation-receipt --epic-run-id 3f9c2b7e-... --ticket-key BAPI-852",
     ].join("\n");
 }
 /**
@@ -253,6 +266,13 @@ export function getConductorUsage() {
  * output name is now a fixed migration stub and must never be selected here.
  */
 export const CONDUCTOR_HOOK_BIN_ACTION = "__hook-bin";
+/**
+ * Private runtime probe (BAPI-1290): the bounded subprocess hook qualification
+ * runs as `node <entry> __hook-runtime-probe`. It reports the Node line, the
+ * native ABI, and whether `better-sqlite3` loads — never a path, never error
+ * text — and it never opens, creates, or migrates a ledger. Absent from usage.
+ */
+export { HOOK_RUNTIME_PROBE_ACTION } from "./hook-runtime-qualification.js";
 const VALID_COMMANDS = new Set([
     "emit-event",
     "supervise",
@@ -282,10 +302,16 @@ const VALID_COMMANDS = new Set([
     "scope-catch-up",
     "patch-policy",
     "resume-run",
+    // BAPI-1300: CLI-only parked-child continuation pair — never registered as MCP tools.
+    "continue-child",
+    "continuation-receipt",
     // Private, and deliberately ABSENT from the usage text: `__hook-bin` exists as
     // the bundled-artifact regression guard for BAPI-772 (mirroring `plane
     // __entrypoint`), not as a supported operator workflow.
     CONDUCTOR_HOOK_BIN_ACTION,
+    // Private, like `__hook-bin`: the bounded runtime probe hook qualification
+    // spawns (BAPI-1290). Never advertised as an operator workflow.
+    HOOK_RUNTIME_PROBE_ACTION,
 ]);
 /**
  * Parse the top-level conductor argv into a subcommand (without a CLI
@@ -694,13 +720,17 @@ export async function runDoctorCommand(argv, deps = {}) {
 }
 /**
  * Run `install-git-hooks`: install/update the local managed `post-commit` and
- * `reference-transaction` hooks. Returns 0 even when the directory is not a git
- * worktree (degraded optional capability) — never a fatal failure.
+ * `reference-transaction` hooks. Returns 0 when the directory is not a git
+ * worktree (degraded optional capability) without claiming anything was
+ * provisioned.
  *
- * BAPI-772: an unresolvable `conductor-bin.js` IS fatal (exit 1). Writing a hook
- * that points at a nonexistent binary produced a hook that silently did nothing
- * on every commit, so the installer now refuses and this command reports the
- * refusal with the resolver's searched-layout remediation.
+ * BAPI-772: an unresolvable hook binary IS fatal (exit 1). BAPI-1290: so is an
+ * UNQUALIFIED runtime (an `npx` cache entry, an unsupported layout, a Node or
+ * native binding that does not load) — the refusal prints a fixed classification
+ * and action, never a probed path — and so is a planning refusal or a two-hook
+ * update that did not complete. A partial update prints each hook's outcome; it is
+ * never collapsed into success. None of these is an engine-admission failure:
+ * the hooks are optional local observability.
  */
 export function runInstallGitHooksCommand(argv) {
     const { bools } = tokenizeFlags(argv, new Set(), DIAGNOSTIC_BOOL_FLAGS);
@@ -711,14 +741,30 @@ export function runInstallGitHooksCommand(argv) {
     const result = installConductorGitHooks();
     if (!result.ok) {
         if (bools.has("--json")) {
-            console.error(JSON.stringify({ error: result.error, reason: result.reason }));
+            console.error(JSON.stringify(result.error === CONDUCTOR_BIN_UNRESOLVED_ERROR
+                ? { error: result.error, classification: result.classification, reason: result.reason }
+                : {
+                    error: result.error,
+                    reason: result.reason,
+                    refused: result.refused.map((r) => ({ name: r.name, warning: r.warning })),
+                }));
             return 1;
         }
-        console.error(`Error: conductor git hooks were NOT installed (${result.error}): ${result.reason}`);
+        console.error(result.error === CONDUCTOR_BIN_UNRESOLVED_ERROR
+            ? `Error: conductor git hooks were NOT installed (${result.error}, ${result.classification}): ${result.reason}`
+            : `Error: conductor git hooks were NOT installed (${result.error}): ${result.reason}`);
+        console.error("Existing hooks were left unchanged. Hooks are optional local observability; " +
+            "engine admission is unaffected.");
         return 1;
     }
+    const incomplete = result.is_worktree && !result.complete;
     if (bools.has("--json")) {
-        console.log(JSON.stringify(result));
+        const payload = JSON.stringify(result);
+        if (incomplete) {
+            console.error(payload);
+            return 1;
+        }
+        console.log(payload);
         return 0;
     }
     const lines = [
@@ -726,34 +772,101 @@ export function runInstallGitHooksCommand(argv) {
         "───────────────────────────",
         `is git worktree:  ${result.is_worktree}`,
         `hooks dir:        ${result.hooks_dir ?? "n/a"}`,
-        `conductor bin:    ${result.conductor_bin}`,
+        `hook runtime:     ${result.conductor_bin}`,
+        `runtime evidence: ${result.runtime.package_name}@${result.runtime.package_version}, ` +
+            `node ${result.runtime.node_version} (ABI ${result.runtime.node_modules_abi}), ` +
+            `${result.runtime.native_module} ${result.runtime.native_module_version ?? "unknown"}, ${result.runtime.platform}`,
     ];
     for (const hook of result.installed) {
-        lines.push(`  ${hook.name}: ${hook.action}${hook.warning ? ` (${hook.warning})` : ""}`);
+        lines.push(`  ${hook.name}: ${hook.outcome} (${hook.action}), usable=${hook.usable}` +
+            (hook.warning ? ` — ${hook.warning}` : ""));
+    }
+    if (result.is_worktree) {
+        lines.push(result.complete
+            ? "status:           complete — both managed hooks are published and usable"
+            : result.partial
+                ? "status:           PARTIAL — re-run `epic-implementer install-git-hooks` to converge"
+                : "status:           NOT installed — no managed hook was changed");
+    }
+    else {
+        lines.push("status:           not provisioned — not a git worktree");
     }
     if (result.warnings.length > 0) {
         lines.push("warnings:");
         for (const w of result.warnings)
             lines.push(`  - ${w}`);
     }
+    if (incomplete) {
+        console.error(lines.join("\n"));
+        return 1;
+    }
     console.log(lines.join("\n"));
     return 0;
 }
 /**
- * Run the private `__hook-bin` diagnostic: resolve the hook binary from the
- * executing artifact and print ONLY that canonical path to stdout, so artifact-
- * level automation can consume it directly. A failed resolution prints the
- * sanitized resolver reason to stderr and returns 1 — never a stack trace.
+ * Run the private `__hook-bin` diagnostic: resolve and QUALIFY the hook entry
+ * for the executing artifact and print ONLY the stable launch path to stdout, so
+ * artifact-level automation can consume it directly. BAPI-1290: an existing but
+ * ephemeral or unqualified entry is NOT printed — the sanitized classification and
+ * action go to stderr and the command returns 1, never a stack trace or a path.
  */
 export function runHookBinDiagnosticCommand() {
     const resolution = resolveConductorHookBin();
     if (!resolution.ok) {
-        console.error(`conductor hook bin UNRESOLVED: ${resolution.reason}`);
+        console.error(`conductor hook bin UNRESOLVED (${resolution.classification}): ${resolution.reason}`);
         return 1;
     }
     console.log(resolution.path);
     return 0;
 }
+/**
+ * Run the private `__hook-runtime-probe` (BAPI-1290): print ONE JSON line with the
+ * Node version, the native ABI, and whether `better-sqlite3` loads for this Node.
+ * It reuses the ledger's own read-only native-load classification, so the hook
+ * qualification and `epic-implementer doctor` cannot disagree about the binding.
+ * It never opens, creates, or migrates the ledger, never writes a file, and never
+ * prints a path or error text. Exit 0 whenever it could answer.
+ */
+export async function runHookRuntimeProbeCommand() {
+    let loads = false;
+    let failureKind = "unknown";
+    let abi = process.versions.modules ?? "unknown";
+    let moduleName = "better-sqlite3";
+    try {
+        const { inspectConductorLedgerNativeModuleLoad } = await import("./store.js");
+        const status = await inspectConductorLedgerNativeModuleLoad();
+        loads = status.loads;
+        failureKind = status.failure_kind;
+        abi = status.node_modules_abi;
+        moduleName = status.module;
+    }
+    catch {
+        loads = false;
+        failureKind = "unknown";
+    }
+    let nativeVersion = null;
+    if (loads) {
+        try {
+            const require = createRequire(import.meta.url);
+            const pkg = require(`${moduleName}/package.json`);
+            nativeVersion = typeof pkg.version === "string" ? pkg.version : null;
+        }
+        catch {
+            nativeVersion = null;
+        }
+    }
+    console.log(JSON.stringify({
+        probe: HOOK_RUNTIME_PROBE_MARKER,
+        node_version: process.version,
+        node_modules_abi: abi,
+        native_module: moduleName,
+        native_module_version: nativeVersion,
+        native_loads: loads,
+        failure_kind: failureKind,
+        package_version: VERSION,
+    }));
+    return 0;
+}
 const GIT_HOOK_VALUE_FLAGS = new Set(["--phase", "--stdin-file"]);
 const GIT_HOOK_BOOL_FLAGS = new Set(["--help"]);
 /**
@@ -1265,6 +1378,10 @@ export async function runEpicImplementerCli(argv) {
                 // Dispatched before any MCP server construction or store access: the
                 // guard must be able to run against a bundle whose ledger is absent.
                 return runHookBinDiagnosticCommand();
+            case HOOK_RUNTIME_PROBE_ACTION:
+                // Also dispatched before any MCP construction or store open: it only
+                // imports the native binding, so it can answer on a host with no ledger.
+                return await runHookRuntimeProbeCommand();
             case "file-scope-guard":
                 // BAPI-507 (N-2): warn-only worker file-scope guard. Always exits 0.
                 return runFileScopeGuardCli();
@@ -1314,6 +1431,14 @@ export async function runEpicImplementerCli(argv) {
                 const { runResumeRunCommand } = await import("./recovery-cli.js");
                 return await runResumeRunCommand(parsed.argv);
             }
+            case "continue-child": {
+                const { runContinueChildCommand } = await import("./recovery-cli.js");
+                return await runContinueChildCommand(parsed.argv);
+            }
+            case "continuation-receipt": {
+                const { runContinuationReceiptCommand } = await import("./recovery-cli.js");
+                return await runContinuationReceiptCommand(parsed.argv);
+            }
             default:
                 console.error('Error: Unknown command. Run "epic-implementer --help" for usage.');
                 return 1;