@agentbridge1/cli 0.0.5 → 0.0.6

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "builtAt": "2026-06-03T09:58:38.231Z",
-  "gitHead": "6fcc74c",
-  "sourceLatestMtime": "2026-06-03T05:08:44.109Z",
-  "sourceLatestFile": "src/commands/doctor.ts"
+  "builtAt": "2026-06-06T12:05:27.957Z",
+  "gitHead": "ec17ba8",
+  "sourceLatestMtime": "2026-06-06T11:59:41.649Z",
+  "sourceLatestFile": "src/commands/watch.ts"
 }

package/dist/commands/accept.js

@@ -10,6 +10,7 @@ const server_sync_1 = require("../server-sync");
 const operator_snapshot_1 = require("../operator-snapshot");
 const work_context_resolver_1 = require("../work-context-resolver");
 const error_catalog_1 = require("../error-catalog");
+const proof_obligations_1 = require("../proof-obligations");
 const acceptance_preflight_1 = require("../acceptance-preflight");
 const acceptance_block_1 = require("../acceptance-block");
 function resolveNetworkContext() {
@@ -36,10 +37,9 @@ function blockedErrorCode(report) {
     if ((report.out_of_scope_files ?? []).length > 0 || report.scope_status === "drift") {
         return "SCOPE_DRIFT_OUT_OF_SCOPE_FILE";
     }
-    if (report.decision === "needs_proof")
-        return "PROOF_MISSING";
-    if (report.decision === "stale_evidence")
-        return "PROOF_STALE_AFTER_CHANGE";
+    const proofCode = (0, proof_obligations_1.resolveProofBlockingErrorCode)(report);
+    if (proofCode)
+        return proofCode;
     return "ACCEPTANCE_BLOCKED";
 }
 function buildStructuredBlockedOutput(report) {

package/dist/commands/check.js

@@ -9,6 +9,7 @@ const acceptance_preflight_1 = require("../acceptance-preflight");
 const work_context_resolver_1 = require("../work-context-resolver");
 const operator_snapshot_1 = require("../operator-snapshot");
 const proof_guidance_1 = require("../proof-guidance");
+const proof_obligations_1 = require("../proof-obligations");
 const memory_context_render_1 = require("../memory-context-render");
 const acceptance_block_1 = require("../acceptance-block");
 function resolveNetworkContext() {
@@ -184,8 +185,16 @@ function renderAcceptanceReport(report) {
             }
         }
     }
+    const obligationSection = (0, proof_obligations_1.renderProofObligationSection)(report);
+    if (obligationSection.length > 0) {
+        lines.push(...obligationSection);
+    }
     lines.push(`Decision: ${report.decision}`);
-    if (report.decision === "needs_proof") {
+    const obligationErrorLines = (0, proof_obligations_1.renderProofObligationErrorLines)(report);
+    if (obligationErrorLines.length > 0) {
+        lines.push(...obligationErrorLines);
+    }
+    else if (report.decision === "needs_proof") {
         lines.push("✗ Error code: PROOF_MISSING");
         lines.push("  What happened: No verification proof exists for this work session.");
         lines.push("  Why it matters: Unverified work cannot be accepted — proof is required.");

package/dist/commands/connect.js

@@ -358,7 +358,7 @@ async function runConnect(options = {}) {
             "",
             "Next:",
             "  agentbridge doctor",
-            "  agentbridge start",
+            "  agentbridge watch",
             "",
         ].join("\n"));
     }
@@ -366,6 +366,6 @@ async function runConnect(options = {}) {
         process.stdout.write("✓ Connected.\n");
         process.stdout.write("Run `agentbridge use <agent-id>` and then:\n");
         process.stdout.write("  agentbridge doctor\n");
-        process.stdout.write("  agentbridge start\n");
+        process.stdout.write("  agentbridge watch\n");
     }
 }

package/dist/commands/doctor.js

@@ -10,6 +10,7 @@ const http_1 = require("../http");
 const dist_freshness_1 = require("./dist-freshness");
 const session_state_1 = require("../session-state");
 const server_sync_1 = require("../server-sync");
+const recovery_reconcile_1 = require("../recovery-reconcile");
 function cliRootFromCommandDir() {
     return (0, node_path_1.resolve)(__dirname, "..", "..");
 }
@@ -86,11 +87,27 @@ function extractHttpReason(error) {
     }
     return `http_${error.status}`;
 }
-function recoveryRequiredByPacket(packet) {
-    if (!packet || packet.project_mode !== "recovery")
-        return false;
-    const status = packet.recovery_status ?? null;
-    return status === "baseline_required" || status === "pending" || status === null;
+function detectGovernanceSignals(workspaceRoot) {
+    const rulesMdcPath = (0, node_path_1.resolve)(workspaceRoot, ".cursor", "rules", "agentbridge.mdc");
+    const rulesMarkdownPath = (0, node_path_1.resolve)(workspaceRoot, "AGENTBRIDGE.md");
+    const mcpConfigPath = (0, node_path_1.resolve)(workspaceRoot, ".cursor", "mcp.json");
+    const rulesInstalled = (0, node_fs_1.existsSync)(rulesMdcPath) && (0, node_fs_1.existsSync)(rulesMarkdownPath);
+    let mcpConfigured = false;
+    if ((0, node_fs_1.existsSync)(mcpConfigPath)) {
+        try {
+            const parsed = JSON.parse((0, node_fs_1.readFileSync)(mcpConfigPath, "utf8"));
+            mcpConfigured = Boolean(parsed?.mcpServers &&
+                (parsed.mcpServers["agentbridge"] || parsed.mcpServers["agentbridge-mcp"]));
+        }
+        catch {
+            mcpConfigured = false;
+        }
+    }
+    return {
+        rulesInstalled,
+        mcpConfigured,
+        governanceStatus: rulesInstalled && mcpConfigured ? "active" : "inactive",
+    };
 }
 async function checkProjectAccess(ctx) {
     if (!ctx.configComplete) {
@@ -219,6 +236,7 @@ async function checkIdentityAccess(ctx) {
 }
 async function runDoctor(cliRootOverride) {
     const cliRoot = cliRootOverride ?? cliRootFromCommandDir();
+    const workspaceRoot = process.cwd();
     const cfg = (0, config_1.readConfig)();
     const freshness = (0, dist_freshness_1.getDistFreshnessReport)(cliRoot);
     const configPath = cliRootOverride
@@ -238,6 +256,7 @@ async function runDoctor(cliRootOverride) {
     const projectConfigPresent = projectIdPresent && apiKeyPresent && baseUrlPresent;
     const activeSession = (0, session_state_1.readSessionState)();
     const hasActiveWork = Boolean(activeSession?.id || activeSession?.serverSessionId);
+    const governance = detectGovernanceSignals(workspaceRoot);
     const envContributed = Boolean(process.env.AGENTBRIDGE_PROJECT_ID) ||
         Boolean(process.env.AGENTBRIDGE_API_KEY) ||
         Boolean(process.env.AGENTBRIDGE_BASE_URL) ||
@@ -277,12 +296,9 @@ async function runDoctor(cliRootOverride) {
         apiBaseUrl: resolvedBaseUrl,
         configComplete: projectConfigPresent && projectAccess.status === "ok",
     });
-    lines.push(`Caller identity access: ${identityAccess.status}`);
-    if (identityAccess.reason) {
-        lines.push(`Caller identity reason: ${identityAccess.reason}`);
-    }
-    lines.push(`Caller identity model: ${identityAccess.identityModel}`);
-    lines.push(`Execution surface present: ${identityAccess.executionSurfaceId ? "yes" : "no"}`);
+    lines.push(`Rules installed: ${governance.rulesInstalled ? "yes" : "no"}`);
+    lines.push(`MCP configured: ${governance.mcpConfigured ? "yes" : "no"}`);
+    lines.push(`Agent governance: ${governance.governanceStatus}`);
     lines.push(`Start capable: ${identityAccess.startCapable ? "yes" : "no"}`);
     if (projectAccess.status === "failed" && projectAccess.reason) {
         const view = (0, error_catalog_1.catalogViewForDoctorReason)(projectAccess.reason, projectAccess.suggestedNextAction);
@@ -309,32 +325,77 @@ async function runDoctor(cliRootOverride) {
             productStatus = "active_work_found";
         }
         else {
-            productStatus = recoveryRequiredByPacket(projectAccess.packet)
-                ? "needs_recover"
-                : "ready";
+            if ((0, recovery_reconcile_1.recoveryBaselineRequired)(projectAccess.packet)) {
+                productStatus = "needs_recover";
+            }
+            else if ((0, recovery_reconcile_1.recoveryIsBasicPacket)(projectAccess.packet)) {
+                productStatus = "ready_basic_recovery";
+            }
+            else {
+                productStatus = "ready";
+            }
         }
     }
+    const localSupervisionReady = true;
+    const cloudSyncReady = projectAccess.status === "ok";
+    const strictTrackedReady = projectAccess.status === "ok" && identityAccess.status === "ok" && identityAccess.startCapable;
+    lines.push("");
+    lines.push("Capability levels:");
+    lines.push(`- Local supervision: ${localSupervisionReady ? "ready" : "unavailable"}`);
+    lines.push(`- Cloud sync: ${cloudSyncReady ? "ready" : "unavailable"}`);
+    lines.push(`- Strict tracked work: ${strictTrackedReady ? "ready" : "unavailable"}`);
+    if (!cloudSyncReady && projectAccess.reason) {
+        lines.push(`  Cloud sync note: ${projectAccess.reason}`);
+    }
+    if (!strictTrackedReady && identityAccess.reason) {
+        lines.push(`  Strict tracked note: ${identityAccess.reason}`);
+    }
     lines.push("");
     lines.push("Product status:");
     if (productStatus === "ready") {
         lines.push("- Connection: ready");
+        lines.push("- Governance: " + governance.governanceStatus);
         lines.push("- Recovery: ready");
-        lines.push("- Next: agentbridge start");
+        lines.push(`- Rules: ${governance.rulesInstalled ? "installed" : "missing"}`);
+        lines.push(`- MCP: ${governance.mcpConfigured ? "configured" : "missing"}`);
+        lines.push("- Next: run `agentbridge watch` beside Cursor for live supervision");
+    }
+    else if (productStatus === "ready_basic_recovery") {
+        lines.push("- Connection: ready");
+        lines.push("- Governance: " + governance.governanceStatus);
+        lines.push("- Recovery: basic");
+        lines.push(`- Rules: ${governance.rulesInstalled ? "installed" : "missing"}`);
+        lines.push(`- MCP: ${governance.mcpConfigured ? "configured" : "missing"}`);
+        lines.push("- Note: Project context exists, but domains are not fully mapped yet.");
+        lines.push("- Next: run `agent recover --force` for a full domain rebuild, or `agentbridge watch` for live supervision");
     }
     else if (productStatus === "active_work_found") {
+        const recoveryBasic = (0, recovery_reconcile_1.recoveryIsBasicPacket)(projectAccess.packet);
         lines.push("- Connection: ready");
-        lines.push("- Recovery: ready");
+        lines.push("- Governance: " + governance.governanceStatus);
+        lines.push("- Recovery: " + (recoveryBasic ? "basic" : "ready"));
+        lines.push(`- Rules: ${governance.rulesInstalled ? "installed" : "missing"}`);
+        lines.push(`- MCP: ${governance.mcpConfigured ? "configured" : "missing"}`);
+        if (recoveryBasic) {
+            lines.push("- Note: Project context exists, but domains are not fully mapped yet.");
+        }
         lines.push("- Active work: found");
-        lines.push("- Next: agentbridge start");
+        lines.push("- Next: run `agentbridge watch` beside Cursor for live supervision");
     }
     else if (productStatus === "needs_recover") {
         lines.push("- Connection: ready");
+        lines.push("- Governance: " + governance.governanceStatus);
         lines.push("- Recovery: required");
+        lines.push(`- Rules: ${governance.rulesInstalled ? "installed" : "missing"}`);
+        lines.push(`- MCP: ${governance.mcpConfigured ? "configured" : "missing"}`);
         lines.push("- Next: agentbridge recover");
     }
     else {
         lines.push("- Connection: incomplete");
+        lines.push("- Governance: " + governance.governanceStatus);
         lines.push("- Recovery: pending");
+        lines.push(`- Rules: ${governance.rulesInstalled ? "installed" : "missing"}`);
+        lines.push(`- MCP: ${governance.mcpConfigured ? "configured" : "missing"}`);
         if (!projectConfigPresent) {
             lines.push("- Note: Connection details are missing. Add credentials, then rerun agentbridge doctor.");
         }
@@ -342,9 +403,6 @@ async function runDoctor(cliRootOverride) {
             lines.push("- Reason: execution surface missing.");
             lines.push("- Next: agentbridge connect");
         }
-        else if (identityAccess.status !== "ok") {
-            lines.push("- Note: Caller identity is unresolved. Run agentbridge identity list and set a valid active agent.");
-        }
         else {
             lines.push("- Note: Connection check failed. Verify credentials/network, then rerun agentbridge doctor.");
         }
@@ -352,12 +410,30 @@ async function runDoctor(cliRootOverride) {
             lines.push("- Next: agentbridge doctor");
         }
     }
+    lines.push("");
+    lines.push("Advanced details:");
+    lines.push(`- Caller identity access: ${identityAccess.status}`);
+    if (identityAccess.reason) {
+        lines.push(`- Caller identity reason: ${identityAccess.reason}`);
+    }
+    lines.push(`- Caller identity model: ${identityAccess.identityModel}`);
+    lines.push(`- Execution surface present: ${identityAccess.executionSurfaceId ? "yes" : "no"}`);
+    lines.push(`- Start capable (strict/session modes): ${identityAccess.startCapable ? "yes" : "no"}`);
+    if (identityAccess.status !== "ok") {
+        lines.push("- Note: internal identity mismatch affects strict/resume flows, not room-level inferred watch startup.");
+    }
+    if (governance.governanceStatus === "inactive") {
+        lines.push("");
+        lines.push("Governance note: AgentBridge can review in terminal, but your AI agent may not stop automatically until rules and MCP are both configured.");
+    }
+    else {
+        lines.push("");
+        lines.push("Governance note: AgentBridge rules are installed and MCP is configured. The AI agent should stop when AgentBridge flags blocked work.");
+    }
     process.stdout.write(`${lines.join("\n")}\n`);
     if (freshness.state === "stale")
         return 1;
     if (projectAccess.status === "failed")
         return 1;
-    if (identityAccess.status === "failed")
-        return 1;
     return 0;
 }

package/dist/commands/proof-guidance.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProofGuidance = runProofGuidance;
+const config_1 = require("../config");
+const errors_1 = require("../errors");
+const server_sync_1 = require("../server-sync");
+function resolveNetworkContext() {
+    const cfg = (0, config_1.readConfig)();
+    const projectId = process.env.AGENTBRIDGE_PROJECT_ID ?? cfg.projectId;
+    const apiKey = process.env.AGENTBRIDGE_API_KEY ?? cfg.apiKey ?? "";
+    const apiBaseUrl = process.env.AGENTBRIDGE_BASE_URL ?? cfg.apiBaseUrl ?? "https://agentauth-api-production.up.railway.app";
+    if (!projectId) {
+        throw new errors_1.SafeCliError("Missing AGENTBRIDGE_PROJECT_ID. Set AGENTBRIDGE_PROJECT_ID (or run `agentbridge init --project ...`).");
+    }
+    if (!apiKey) {
+        throw new errors_1.SafeCliError("Missing AGENTBRIDGE_API_KEY. Provide --api-key, set AGENTBRIDGE_API_KEY, or save apiKey in .agentbridge/config.json.");
+    }
+    return { projectId, apiKey, apiBaseUrl };
+}
+async function runProofGuidance(options = {}) {
+    const ctx = resolveNetworkContext();
+    const guidance = await (0, server_sync_1.fetchAgentProofGuidance)(ctx, {
+        workSessionId: options.workSessionId,
+        changeRequestId: options.changeRequestId,
+        rolloutProofTooWeak: options.rolloutProofTooWeak,
+        rolloutProofNotRelevant: options.rolloutProofNotRelevant,
+        rolloutImpactCoverageGap: options.rolloutImpactCoverageGap,
+    });
+    process.stdout.write(`${JSON.stringify(guidance, null, 2)}\n`);
+}

package/dist/commands/recover.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runRecover = runRecover;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_process_1 = require("node:process");
 const config_1 = require("../config");
 const errors_1 = require("../errors");
-const server_sync_1 = require("../server-sync");
-const node_process_1 = require("node:process");
 const gates_1 = require("../gates");
-const init_1 = require("../init");
 const http_1 = require("../http");
+const init_1 = require("../init");
+const recovery_reconcile_1 = require("../recovery-reconcile");
+const server_sync_1 = require("../server-sync");
 function resolveNetworkContext() {
     const cfg = (0, config_1.readConfig)();
     const projectId = process.env.AGENTBRIDGE_PROJECT_ID ?? cfg.projectId ?? "";
@@ -20,9 +23,14 @@ function resolveNetworkContext() {
     }
     return { projectId, apiKey, apiBaseUrl };
 }
+function rulesInstalled(repoRoot) {
+    return ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(repoRoot, "AGENTBRIDGE.md")) &&
+        (0, node_fs_1.existsSync)((0, node_path_1.resolve)(repoRoot, ".cursor", "rules", "agentbridge.mdc")));
+}
 function renderRecoverOutput(packet) {
     const lines = [];
-    const domainCount = packet.domains_summary.length;
+    const activeDomains = (packet.domains_summary ?? []).filter((d) => d.state !== "retired");
+    const domainCount = activeDomains.length;
     const ruleCount = packet.global_rules?.length ?? 0;
     const hasCharterContext = Boolean(packet.charter_summary?.purpose);
     lines.push("Project recovered.");
@@ -36,7 +44,7 @@ function renderRecoverOutput(packet) {
     if (domainCount > 0) {
         lines.push("");
         lines.push("Domains found:");
-        for (const domain of packet.domains_summary) {
+        for (const domain of activeDomains) {
             const pathNote = domain.owned_path_count > 0 ? `${domain.owned_path_count} path(s)` : "paths pending";
             lines.push(`- ${domain.domain_name} — ${pathNote}`);
         }
@@ -55,18 +63,56 @@ function renderRecoverOutput(packet) {
     }
     lines.push("");
     lines.push("Next:");
-    lines.push("  agentbridge start");
+    lines.push("  agentbridge watch");
     lines.push("");
     return lines.join("\n");
 }
 function recoveryStatusLabel(packet) {
     return packet.recovery_status ?? "unknown";
 }
-function baselineRequired(packet) {
-    const status = packet.recovery_status ?? null;
-    if (packet.project_mode !== "recovery")
-        return false;
-    return status === "baseline_required" || status === "pending" || status === null;
+function formatDomainLines(refs) {
+    if (refs.length === 0)
+        return "  (none)";
+    return refs.map((d) => `- ${d.name}`).join("\n");
+}
+function renderReconcileReport(input) {
+    const { plan, applied, qualityAfter } = input;
+    const lines = [""];
+    if (applied) {
+        lines.push("AgentBridge checked recovery.");
+        lines.push(`Recovery quality: ${qualityAfter}`);
+        if (plan.toAdd.length > 0) {
+            lines.push("");
+            lines.push("Added:");
+            lines.push(formatDomainLines(plan.toAdd));
+        }
+        if (plan.toPreserve.length > 0) {
+            lines.push("");
+            lines.push("Existing domains preserved:");
+            lines.push(formatDomainLines(plan.toPreserve));
+        }
+        if (plan.toRetire.length > 0) {
+            lines.push("");
+            lines.push("Retired:");
+            lines.push(formatDomainLines(plan.toRetire));
+        }
+    }
+    else {
+        lines.push("AgentBridge checked recovery.");
+        lines.push("No changes needed.");
+        lines.push("Recovery is up to date.");
+        lines.push(`Recovery quality: ${qualityAfter}`);
+    }
+    return lines.join("\n") + "\n";
+}
+function renderBasicHint() {
+    return [
+        "",
+        "Recovery: basic",
+        "AgentBridge found only a generic project area.",
+        "Run `agent recover --force` to rebuild the domain map.",
+        "",
+    ].join("\n");
 }
 function renderRecoveryStatusBlock(input) {
     const lines = [];
@@ -175,15 +221,42 @@ async function runRecover(options = {}) {
         return;
     }
     const beforePacket = packet;
-    const needsRecovery = baselineRequired(beforePacket);
-    let actionTaken = "baseline already exists; no rebuild needed";
-    if (needsRecovery || options.force) {
-        actionTaken = needsRecovery
+    const cfg = (0, config_1.readConfig)();
+    const repoRoot = (0, node_process_1.cwd)();
+    const rulesOk = rulesInstalled(repoRoot);
+    let scan;
+    try {
+        process.stdout.write("Scanning repository layout...\n");
+        scan = await (0, init_1.scanRecoveryFromRepo)(ctx);
+    }
+    catch (error) {
+        process.stderr.write(`${(0, errors_1.renderCliError)(normalizeBootstrapError(error))}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const existingActive = (0, recovery_reconcile_1.packetDomainsToRefs)(beforePacket, cfg.domains ?? []);
+    const plan = (0, recovery_reconcile_1.buildReconcilePlan)({
+        existingActive,
+        candidates: scan.candidateRefs,
+        mode: options.force ? "force" : "safe",
+        packet: beforePacket,
+        rulesInstalled: rulesOk,
+    });
+    const needsBaseline = (0, recovery_reconcile_1.recoveryBaselineRequired)(beforePacket);
+    const shouldApply = needsBaseline || options.force || plan.hasChanges;
+    let actionTaken = "reconciliation check only; no changes needed";
+    if (shouldApply) {
+        actionTaken = needsBaseline
             ? "build recovery baseline from repository evidence"
-            : "force-refresh recovery baseline from repository evidence";
-        process.stdout.write("Building recovery baseline now...\n");
+            : options.force
+                ? "force-refresh recovery baseline from repository evidence"
+                : "reconcile recovery with repository evidence";
+        process.stdout.write("Applying recovery changes...\n");
         try {
-            await (0, init_1.runBootstrapRecovery)(ctx);
+            await (0, init_1.runBootstrapRecovery)(ctx, {
+                reconcilePlan: plan,
+                scan,
+            });
             packet = await (0, server_sync_1.fetchProjectPacket)(ctx);
         }
         catch (error) {
@@ -193,7 +266,19 @@ async function runRecover(options = {}) {
         }
     }
     const afterPacket = packet;
-    if (baselineRequired(afterPacket)) {
+    const qualityAfter = (0, recovery_reconcile_1.recoveryQualityLabel)((0, recovery_reconcile_1.buildReconcilePlan)({
+        existingActive: (0, recovery_reconcile_1.packetDomainsToRefs)(afterPacket, cfg.domains ?? []),
+        candidates: scan.candidateRefs,
+        mode: options.force ? "force" : "safe",
+        packet: afterPacket,
+        rulesInstalled: rulesOk,
+    }).quality);
+    process.stdout.write(renderReconcileReport({
+        plan,
+        applied: shouldApply,
+        qualityAfter,
+    }));
+    if ((0, recovery_reconcile_1.recoveryBaselineRequired)(afterPacket)) {
         process.stderr.write([
             "Recovery could not complete: baseline still required.",
             "",
@@ -208,7 +293,6 @@ async function runRecover(options = {}) {
         process.exitCode = 1;
         return;
     }
-    const repoRoot = (0, node_process_1.cwd)();
     (0, gates_1.ensureGitignoreSessionEntry)(repoRoot);
     (0, gates_1.ensureGatesFile)(repoRoot);
     process.stdout.write(renderRecoveryStatusBlock({
@@ -216,7 +300,10 @@ async function runRecover(options = {}) {
         before: beforePacket,
         after: afterPacket,
         action: actionTaken,
-        next: "agentbridge start",
+        next: "agentbridge watch",
     }));
-    process.stdout.write(renderRecoverOutput(packet));
+    process.stdout.write(renderRecoverOutput(afterPacket));
+    if ((0, recovery_reconcile_1.recoveryIsBasicPacket)(afterPacket)) {
+        process.stdout.write(renderBasicHint());
+    }
 }

package/dist/commands/setup-mcp.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSetupMcp = runSetupMcp;
+const node_path_1 = require("node:path");
 const config_1 = require("../config");
+const mcp_runtime_1 = require("../mcp-runtime");
 const MCP_SERVER_NAME = "agentbridge";
 function standardSnippet(projectId, apiKey, apiBaseUrl) {
     const serverConfig = {
@@ -47,8 +49,27 @@ async function runSetupMcp(options = {}) {
     else {
         process.stdout.write("\n✓ Credentials filled from .agentbridge/config.json\n");
     }
+    const cliDistDir = (0, node_path_1.resolve)(__dirname, "..");
+    if (!(0, mcp_runtime_1.isMcpRuntimeAvailable)(cliDistDir)) {
+        process.stdout.write([
+            "",
+            "⚠  MCP runtime is missing from this CLI install.",
+            "   `agentbridge mcp` will exit until you reinstall:",
+            "     npm install -g @agentbridge1/cli@latest",
+            "",
+            "   Or point mcp.json at a repo build:",
+            "     node /path/to/AuthAgent/cli/dist/mcp/agentbridge-mcp.js",
+            "",
+        ].join("\n"));
+    }
+    else {
+        process.stdout.write([
+            "",
+            "✓ MCP runtime is bundled with this CLI (`agentbridge mcp` is ready).",
+            "",
+        ].join("\n"));
+    }
     process.stdout.write([
-        "",
         "After saving the config, restart your editor to activate the MCP server.",
         "The MCP server lets your AI assistant call tools like agent_hello, check AgentBridge status, and trigger approvals.",
         "",