@bridge_gpt/mcp-server 0.1.16 → 0.2.0

package/build/mcp-registration-doctor.js

@@ -0,0 +1,96 @@
+/**
+ * Read-only worktree MCP registration inspection (doctor-only).
+ *
+ * Confirms that a worktree's generated `.mcp.json` / `.cursor/mcp.json` contains
+ * a valid Bridge API `mcp-invoke` shim entry pointing at THAT worktree — without
+ * launching `mcp-invoke`, `npx`, Node, or the MCP server. Pure read/parse only;
+ * the sole injected dependency is `readFile`.
+ */
+import path from "path";
+/**
+ * Read and parse a JSON file. A read failure (e.g. ENOENT) is `missing`; invalid
+ * JSON is `malformed` (carrying only the path, never the raw content); otherwise
+ * `present` with the parsed value.
+ */
+export async function readJsonIfPresent(filePath, deps) {
+    let raw;
+    try {
+        raw = await deps.readFile(filePath);
+    }
+    catch {
+        return { state: "missing" };
+    }
+    try {
+        return { state: "present", value: JSON.parse(raw) };
+    }
+    catch {
+        return { state: "malformed", path: filePath };
+    }
+}
+/** Return the token immediately following `flag` in `args`, or undefined. */
+function flagValue(args, flag) {
+    const index = args.indexOf(flag);
+    if (index >= 0 && index + 1 < args.length)
+        return args[index + 1];
+    return undefined;
+}
+/**
+ * True when `entry` is a secret-free Bridge API shim registration that launches
+ * `npx -y @bridge_gpt/mcp-server@<version> mcp-invoke --target bapi
+ * --project-root <worktreeRoot>`. The `--target` must be `bapi` and the
+ * `--project-root` must match the given worktree exactly.
+ */
+export function isBridgeApiShimEntry(entry, worktreeRoot) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+        return false;
+    const candidate = entry;
+    if (candidate.command !== "npx")
+        return false;
+    if (!Array.isArray(candidate.args))
+        return false;
+    const args = candidate.args.filter((a) => typeof a === "string");
+    if (!args.some((a) => a.startsWith("@bridge_gpt/mcp-server")))
+        return false;
+    if (!args.includes("mcp-invoke"))
+        return false;
+    if (flagValue(args, "--target") !== "bapi")
+        return false;
+    if (flagValue(args, "--project-root") !== worktreeRoot)
+        return false;
+    return true;
+}
+/**
+ * Inspect both `<worktreeRoot>/.mcp.json` and `<worktreeRoot>/.cursor/mcp.json`.
+ * Reports `found` when at least one registration file contains a valid
+ * `bridge-api` shim entry pointing at this worktree; otherwise `found: false`
+ * with an actionable, secret-free hint. Never spawns anything.
+ */
+export async function probeWorktreeMcpRegistration(worktreeRoot, deps) {
+    const targets = [
+        path.join(worktreeRoot, ".mcp.json"),
+        path.join(worktreeRoot, ".cursor", "mcp.json"),
+    ];
+    for (const filePath of targets) {
+        const read = await readJsonIfPresent(filePath, deps);
+        if (read.state !== "present")
+            continue;
+        const doc = read.value;
+        if (!doc || typeof doc !== "object" || Array.isArray(doc))
+            continue;
+        const servers = doc.mcpServers;
+        if (!servers || typeof servers !== "object" || Array.isArray(servers))
+            continue;
+        const entry = servers["bridge-api"];
+        if (isBridgeApiShimEntry(entry, worktreeRoot)) {
+            return {
+                found: true,
+                detail: `bridge-api shim registered in ${path.basename(path.dirname(filePath)) === ".cursor" ? ".cursor/mcp.json" : ".mcp.json"}`,
+            };
+        }
+    }
+    return {
+        found: false,
+        detail: "No worktree .mcp.json or .cursor/mcp.json points at the bridge-api mcp-invoke shim. " +
+            "Re-run start-tickets to provision the worktree MCP registration.",
+    };
+}

package/build/pipeline-orchestrator.js

@@ -16,7 +16,21 @@
  *     are inlined into the instruction string so the agent can review and
  *     confirm before resuming. (BAPI-275 decisions E-4 / E-36.)
  */
+import { createHash } from "node:crypto";
 import { resolveRecipe } from "./pipeline-utils.js";
+/**
+ * Derive a STABLE, content-addressed hash of an idea — the basis for the
+ * cross-run idempotency label ``bapi-idea-hash-{idea_hash}``. Normalizes
+ * (trim + lowercase + collapse internal whitespace) so cosmetic edits don't
+ * change the hash, then takes the first 12 hex chars of the SHA-256. Unlike the
+ * per-run ``run_id`` label, this is identical every time the same idea is run,
+ * so a re-run of the same idea is reliably caught by label (not just fuzzy
+ * keyword search). Auto-injected as the ``idea_hash`` pipeline variable.
+ */
+export function deriveIdeaHash(idea) {
+    const normalized = String(idea ?? "").trim().toLowerCase().replace(/\s+/g, " ");
+    return createHash("sha256").update(normalized).digest("hex").slice(0, 12);
+}
 class PipelinePersistenceError extends Error {
     code;
     constructor(code, message) {
@@ -175,6 +189,10 @@ const ORCHESTRATION_TOOLS = new Set([
     "resume_pipeline",
     "list_pipeline_runs",
     "delete_pipeline_run",
+    // BAPI-326: chain orchestration tools must never be invoked from within a
+    // declarative pipeline step (avoids accidental orchestration recursion).
+    "run_full_automation",
+    "resume_full_automation",
 ]);
 // ---------------------------------------------------------------------------
 // runPipeline
@@ -196,6 +214,12 @@ export async function runPipeline(deps, input) {
         auto_approve: autoApprove ? "true" : "",
         ...(input.variables ?? {}),
     };
+    // Auto-inject the stable idea-hash (like docs_dir) whenever the pipeline was
+    // given an `idea`, so both the chain and standalone callers get the cross-run
+    // idempotency label without computing it themselves.
+    if ("idea" in mergedVariables) {
+        mergedVariables.idea_hash = deriveIdeaHash(mergedVariables.idea);
+    }
     let recipe;
     try {
         recipe = resolveRecipe(pipelineDef, deps.instructions, mergedVariables, undefined, autoApprove);
@@ -227,6 +251,39 @@ export async function runPipeline(deps, input) {
     }
     return continuePipelineExecution(deps, persistence, row, recipe, autoApprove);
 }
+/**
+ * Read-only snapshot of a pipeline run's current persisted state — performs no
+ * execution and no state transition. Used by the chain orchestrator to decide,
+ * at a stage boundary, whether the inner pipeline still needs resuming
+ * (``paused``), has already reached a terminal state (``completed`` / ``failed``)
+ * so the stage can be advanced/failed idempotently, or is in an indeterminate
+ * state that cannot be safely resumed or recovered.
+ */
+export async function peekPipelineRun(deps, pipeline_run_id) {
+    const persistence = createPipelinePersistenceClient({
+        baseUrl: deps.baseUrl,
+        apiKey: deps.apiKey,
+        repoName: deps.repoName,
+    });
+    let row;
+    try {
+        row = await persistence.getRun(pipeline_run_id);
+    }
+    catch (err) {
+        if (err instanceof PipelinePersistenceError) {
+            return failedEnvelope(err.code, err.message, { pipeline_run_id });
+        }
+        return failedEnvelope("TOOL_ERROR", err instanceof Error ? err.message : String(err), { pipeline_run_id });
+    }
+    return {
+        status: row.status,
+        pipeline_run_id: row.pipeline_run_id,
+        pipeline: row.pipeline_name,
+        total_steps: row.resolved_recipe.total_steps,
+        current_step_index: row.current_step_index,
+        results: row.results,
+    };
+}
 // ---------------------------------------------------------------------------
 // resumePipeline
 // ---------------------------------------------------------------------------
@@ -291,7 +348,13 @@ export async function resumePipeline(deps, input) {
         updated = await persistence.patchRun(row.pipeline_run_id, {
             current_step_index: nextIndex,
             results: accumulatedResults,
-            status: "running",
+            // Derive the persisted status from the resumed position. When the resumed
+            // step is the final ``agent_task``, ``nextIndex`` already equals
+            // ``recipe.total_steps``, so ``continuePipelineExecution``'s loop body never
+            // runs and it falls through to the completed envelope without issuing
+            // another patch. We must persist ``completed`` on THIS transition or the run
+            // is orphaned in ``running`` forever. Non-final resumes stay ``running``.
+            status: nextIndex >= recipe.total_steps ? "completed" : "running",
             expected_status: "paused",
             expected_current_step_index: stepIndex,
         });
@@ -583,6 +646,8 @@ async function executeMcpCallStep(deps, step) {
             error: err instanceof Error ? err.message : String(err),
         };
     }
+    // Non-text tool output (e.g. image content) intentionally degrades to "" for
+    // pipeline dispatch in v1 — pipeline steps only act on text envelopes.
     const text = toolResult?.content?.[0]?.type === "text"
         ? toolResult.content[0].text
         : "";

package/build/pipeline-utils.js

@@ -6,6 +6,35 @@
 import { readdir, readFile } from "fs/promises";
 import path from "path";
 // ---------------------------------------------------------------------------
+// Tiered section-graph contract metadata (BAPI-345, Ticket 1)
+// ---------------------------------------------------------------------------
+//
+// Static, server-owned metadata advertised on every resolved recipe envelope so
+// MCP consumers can detect that the section-graph contract exists. Ticket 1 is
+// contract-only: every execution-related capability is disabled, and the
+// section graph itself is NEVER embedded in the recipe envelope (it lives on the
+// plan-generation response, not here). This descriptor is NOT derived from the
+// repo's `tiered_execution` config value.
+export const PIPELINE_CONTRACT_VERSION = "2";
+export const TIERED_SECTION_CAPABILITY_DESCRIPTOR = {
+    section_graph: {
+        supported: true,
+        execution_enabled: false,
+        payload_location: "plan_generation_response.sections",
+    },
+    tiers: ["cheap", "basic", "premium"],
+    risk_levels: ["low", "medium", "high"],
+    activities: ["implement", "test", "docs", "debug", "config"],
+    tiered_execution_modes: ["off", "claude_code_only", "all_capable"],
+    capabilities: {
+        // All Ticket 2 execution features are disabled / not implemented in Ticket 1.
+        escalation: false,
+        checkpoint: false,
+        rollback: false,
+        subagent_dispatch: false,
+    },
+};
+// ---------------------------------------------------------------------------
 // Schema Validation
 // ---------------------------------------------------------------------------
 export function validatePipelineSchema(json) {
@@ -212,6 +241,10 @@ export function resolveRecipe(pipeline, instructions, variables, skipSteps, auto
         agent_instructions: baseInstructions + autoApproveSuffix,
         auto_approve: !!autoApprove,
         steps: resolvedSteps,
+        // BAPI-345 (Ticket 1): additive static contract metadata. The section graph
+        // is NEVER embedded here — it is delivered on the plan-generation response.
+        contract_version: PIPELINE_CONTRACT_VERSION,
+        capability_descriptor: TIERED_SECTION_CAPABILITY_DESCRIPTOR,
     };
 }
 // ---------------------------------------------------------------------------