@agentbridge1/cli 0.0.7 → 0.0.9

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "builtAt": "2026-06-07T04:20:05.843Z",
-  "gitHead": "aa4b2fb",
-  "sourceLatestMtime": "2026-06-07T04:16:53.273Z",
-  "sourceLatestFile": "src/commands/room.ts"
+  "builtAt": "2026-06-20T12:33:18.940Z",
+  "gitHead": "b4d6915",
+  "sourceLatestMtime": "2026-06-20T12:02:16.784Z",
+  "sourceLatestFile": "src/commands/start.ts"
 }

package/dist/commands/connect.js

@@ -4,6 +4,8 @@ exports.runConnect = runConnect;
 const config_1 = require("../config");
 const errors_1 = require("../errors");
 const http_1 = require("../http");
+const install_rules_1 = require("./install-rules");
+const mcp_config_1 = require("../mcp-config");
 function resolveBaseUrl(override) {
     return (override ??
         process.env.AGENTBRIDGE_BASE_URL ??
@@ -132,64 +134,12 @@ async function resolveExecutionSurfaceFromHello(projectId, apiKey, apiBaseUrl) {
         };
     }
 }
-async function bootstrapDefaultConnection(projectId, apiKey, apiBaseUrl) {
-    const url = `${apiBaseUrl}/v1/dev/projects/${projectId}/connections/bootstrap-default`;
-    try {
-        const res = await fetch(url, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({}),
-        });
-        if (!res.ok)
-            return { ok: false, status: res.status, reason: `http_${res.status}` };
-        const body = (await res.json());
-        const nextApiKey = body.api_key?.trim();
-        const executionSurfaceId = body.execution_surface_id?.trim();
-        if (!nextApiKey || !executionSurfaceId) {
-            return { ok: false, status: 200, reason: "invalid_payload" };
-        }
-        return { ok: true, apiKey: nextApiKey, executionSurfaceId };
-    }
-    catch {
-        return { ok: false, status: 0, reason: "network_error" };
-    }
-}
-async function rotateActiveConnectionKey(projectId, apiKey, apiBaseUrl) {
-    const listUrl = `${apiBaseUrl}/v1/dev/projects/${projectId}/connections`;
-    try {
-        const listRes = await fetch(listUrl, {
-            headers: { Authorization: `Bearer ${apiKey}` },
-        });
-        if (!listRes.ok)
-            return { ok: false, reason: `list_http_${listRes.status}` };
-        const listBody = (await listRes.json());
-        const activeConnection = (listBody.connections ?? []).find((connection) => connection?.id && connection?.status === "active");
-        if (!activeConnection?.id)
-            return { ok: false, reason: "no_active_connection" };
-        const rotateUrl = `${apiBaseUrl}/v1/dev/projects/${projectId}/connections/${activeConnection.id}/rotate-key`;
-        const rotateRes = await fetch(rotateUrl, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({}),
-        });
-        if (!rotateRes.ok)
-            return { ok: false, reason: `rotate_http_${rotateRes.status}` };
-        const rotateBody = (await rotateRes.json());
-        const rotatedApiKey = rotateBody.api_key?.trim();
-        const executionSurfaceId = rotateBody.connection?.execution_surface?.id?.trim();
-        if (!rotatedApiKey || !executionSurfaceId)
-            return { ok: false, reason: "invalid_payload" };
-        return { ok: true, apiKey: rotatedApiKey, executionSurfaceId };
-    }
-    catch {
-        return { ok: false, reason: "network_error" };
-    }
+/**
+ * Merge the AgentBridge MCP server entry into .cursor/mcp.json (project-level).
+ * Preserves any other MCP servers already configured.
+ */
+function writeMcpConfig(projectId, apiKey, apiBaseUrl) {
+    return (0, mcp_config_1.writeServerMcpConfig)(projectId, apiKey, apiBaseUrl);
 }
 async function runConnect(options = {}) {
     process.stdout.write("AgentBridge connect\n");
@@ -249,89 +199,67 @@ async function runConnect(options = {}) {
         throw err;
     }
     process.stdout.write("OK\n");
-    let effectiveApiKey = apiKey;
     const diagnostics = {
         helloIdentityModel: "unknown",
         helloStatus: "not_attempted",
-        bootstrapStatus: "not_attempted",
-        rotateStatus: "not_attempted",
     };
-    const helloResolution = await resolveExecutionSurfaceFromHello(projectId, effectiveApiKey, apiBaseUrl);
+    const helloResolution = await resolveExecutionSurfaceFromHello(projectId, apiKey, apiBaseUrl);
     diagnostics.helloIdentityModel = helloResolution.identityModel;
     diagnostics.helloStatus = helloResolution.status;
-    let executionSurfaceId = helloResolution.executionSurfaceId;
-    let connectionUpgraded = false;
-    if (!executionSurfaceId) {
-        diagnostics.bootstrapStatus = "attempted";
-        const bootstrapAttempt = await bootstrapDefaultConnection(projectId, effectiveApiKey, apiBaseUrl);
-        if (bootstrapAttempt.ok) {
-            effectiveApiKey = bootstrapAttempt.apiKey;
-            executionSurfaceId = bootstrapAttempt.executionSurfaceId;
-            diagnostics.bootstrapStatus = "ok";
-            diagnostics.rotateStatus = "skipped";
-            connectionUpgraded = true;
-        }
-        else if (bootstrapAttempt.status === 409) {
-            diagnostics.bootstrapStatus = "http_409_existing_connection";
-            const rotated = await rotateActiveConnectionKey(projectId, effectiveApiKey, apiBaseUrl);
-            if (rotated.ok) {
-                diagnostics.rotateStatus = "ok";
-                effectiveApiKey = rotated.apiKey;
-                executionSurfaceId = rotated.executionSurfaceId;
-                connectionUpgraded = true;
-            }
-            else {
-                diagnostics.rotateStatus = rotated.reason;
-            }
-        }
-        else {
-            diagnostics.bootstrapStatus = bootstrapAttempt.reason;
-            diagnostics.rotateStatus = "skipped";
-        }
-    }
-    else {
-        diagnostics.bootstrapStatus = "skipped";
-        diagnostics.rotateStatus = "skipped";
-    }
-    if (connectionUpgraded) {
-        await verifyCredentials(projectId, effectiveApiKey, apiBaseUrl);
-    }
+    const executionSurfaceId = helloResolution.executionSurfaceId;
     if (!executionSurfaceId) {
         (0, config_1.updateConfig)({
             projectId,
-            apiKey: effectiveApiKey,
+            apiKey,
             apiBaseUrl,
         });
-        throw new errors_1.SafeCliError([
-            "Connection incomplete.",
-            "Project access was verified, but AgentBridge could not create or resolve an execution surface.",
-            "Tracked work cannot start yet.",
-            "",
-            `hello identity model: ${diagnostics.helloIdentityModel}`,
-            `hello status: ${diagnostics.helloStatus}`,
-            `bootstrap-default status: ${diagnostics.bootstrapStatus}`,
-            `rotate-key status: ${diagnostics.rotateStatus}`,
-            `backend URL: ${apiBaseUrl}`,
-        ].join("\n"));
+        const helloWhy = helloResolution.identityModel === "legacy"
+            ? "This API key is a legacy project agent key, not a room connection key from room create or rotate."
+            : helloResolution.status === "unknown_identity_model"
+                ? "The server /hello response did not include identity_model work_identity for this key."
+                : helloResolution.status === "missing_execution_surface"
+                    ? "/hello returned work_identity but no execution_surface.id."
+                    : helloResolution.status.startsWith("http_")
+                        ? `/hello failed (${helloResolution.status}).`
+                        : "AgentBridge could not resolve an execution surface for this key.";
+        throw (0, errors_1.catalogCliError)("CONNECT_EXECUTION_SURFACE_MISSING", {
+            what: `Project access was verified, but connect could not bind an execution surface (hello: ${diagnostics.helloIdentityModel}, status: ${diagnostics.helloStatus}).`,
+            why: helloWhy,
+        });
     }
     // Persist credentials
     (0, config_1.updateConfig)({
         projectId,
-        apiKey: effectiveApiKey,
+        apiKey,
         apiBaseUrl,
         ...(executionSurfaceId ? { executionSurfaceId } : {}),
     });
     process.stdout.write("Credentials saved to .agentbridge/config.json\n");
-    if (connectionUpgraded) {
-        process.stdout.write("Auto-configured an AgentConnection key and execution surface for this project.\n");
+    process.stdout.write(`Execution surface: ${executionSurfaceId}\n`);
+    // Auto-write .cursor/mcp.json (merge — preserves other MCP servers)
+    try {
+        const mcpPath = writeMcpConfig(projectId, apiKey, apiBaseUrl);
+        process.stdout.write(`MCP config written: ${mcpPath}\n`);
     }
-    else {
-        process.stdout.write(`Execution surface: ${executionSurfaceId}\n`);
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stdout.write(`⚠  Could not write MCP config automatically: ${msg}\n`);
+        process.stdout.write("   Run `agentbridge setup-mcp` to generate it manually.\n");
+    }
+    // Auto-install project rules (soft — failure is non-blocking)
+    try {
+        await (0, install_rules_1.runInstallRules)({ projectId, apiKey, apiBaseUrl });
+        process.stdout.write("AgentBridge rules installed.\n");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stdout.write(`⚠  Could not install project rules: ${msg}\n`);
+        process.stdout.write("   Run `agentbridge install-rules` manually after connecting.\n");
     }
     // Pick or auto-select an agent identity
     let activeAgentId = options.agentId ?? cfg.activeAgentId;
     if (!activeAgentId) {
-        const agents = await listAgents(projectId, effectiveApiKey, apiBaseUrl);
+        const agents = await listAgents(projectId, apiKey, apiBaseUrl);
         if (agents.length === 1 && agents[0]) {
             activeAgentId = agents[0].id;
             (0, config_1.updateConfig)({ activeAgentId });
@@ -360,15 +288,23 @@ async function runConnect(options = {}) {
         process.stdout.write([
             "",
             "Next:",
-            "  agentbridge doctor",
-            "  agentbridge watch",
+            "  1. Restart your editor to activate the MCP server.",
+            "  2. agentbridge doctor   (verify CLI + MCP + rules are aligned)",
+            "  3. agentbridge start \"task summary\"",
+            "  4. agentbridge watch",
             "",
         ].join("\n"));
     }
     else {
         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 watch\n");
+        process.stdout.write([
+            "",
+            "Next:",
+            "  1. Run `agentbridge use <agent-id>` to select an agent identity.",
+            "  2. Restart your editor to activate the MCP server.",
+            "  3. agentbridge doctor",
+            "  4. agentbridge start \"task summary\"",
+            "",
+        ].join("\n"));
     }
 }

package/dist/commands/doctor.js

@@ -97,16 +97,23 @@ function detectGovernanceSignals(workspaceRoot, expectedProjectId) {
     const analysis = (0, rules_sync_1.analyzeRulesArtifacts)(workspaceRoot, expectedProjectId);
     const mcpConfigPath = (0, node_path_1.resolve)(workspaceRoot, ".cursor", "mcp.json");
     let mcpConfigured = false;
+    let mcpProjectId = null;
     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"]));
+            const entry = parsed?.mcpServers?.["agentbridge"] ?? parsed?.mcpServers?.["agentbridge-mcp"];
+            mcpConfigured = Boolean(entry);
+            if (entry?.env?.AGENTBRIDGE_PROJECT_ID) {
+                mcpProjectId = entry.env.AGENTBRIDGE_PROJECT_ID;
+            }
         }
         catch {
             mcpConfigured = false;
         }
     }
+    const mcpCredentialMismatch = mcpConfigured && mcpProjectId !== null && expectedProjectId !== undefined
+        ? mcpProjectId !== expectedProjectId
+        : false;
     return {
         rulesFilesPresent: analysis.filesPresent,
         rulesFormat: analysis.format,
@@ -115,6 +122,8 @@ function detectGovernanceSignals(workspaceRoot, expectedProjectId) {
         rulesInstalled: analysis.protocolRulesValid,
         rulesIssues: analysis.issues,
         mcpConfigured,
+        mcpCredentialMismatch,
+        mcpProjectId,
         governanceStatus: analysis.protocolRulesValid && mcpConfigured ? "active" : "inactive",
     };
 }
@@ -180,7 +189,7 @@ async function checkProjectAccess(ctx) {
         catch {
             // Summary proves access; packet is optional (recovery metadata only).
         }
-        return { status: "ok", packet };
+        return { status: "ok", packet, projectId };
     }
     catch (error) {
         if (error instanceof http_1.CliHttpError &&
@@ -364,7 +373,36 @@ async function runDoctor(cliRootOverride) {
     }
     lines.push(`Rules installed: ${governance.rulesInstalled ? "yes" : "no"}`);
     lines.push(`MCP configured: ${governance.mcpConfigured ? "yes" : "no"}`);
+    if (governance.mcpConfigured && governance.mcpProjectId) {
+        lines.push(`MCP project id: ${governance.mcpProjectId}`);
+    }
     lines.push(`Agent governance: ${governance.governanceStatus}`);
+    const cliConnected = projectAccess.status === "ok";
+    const supervisionStatus = !cliConnected
+        ? "blind"
+        : governance.mcpCredentialMismatch
+            ? "broken"
+            : !governance.mcpConfigured && !governance.rulesInstalled
+                ? "blind"
+                : !governance.mcpConfigured || !governance.rulesInstalled
+                    ? "degraded"
+                    : "ready";
+    lines.push(`Supervision status: ${supervisionStatus}`);
+    if (supervisionStatus === "broken") {
+        lines.push(`  Supervision note: BROKEN — CLI project id (${projectAccess.projectId ?? "?"}) does not match MCP project id (${governance.mcpProjectId ?? "?"}).`);
+        lines.push("  Fix: run `agentbridge connect` again to re-write the MCP config with the correct credentials.");
+    }
+    else if (supervisionStatus === "blind") {
+        lines.push("  Supervision note: watch can observe filesystem changes only — MCP and rules both missing.");
+    }
+    else if (supervisionStatus === "degraded") {
+        if (!governance.mcpConfigured) {
+            lines.push("  Supervision note: MCP not configured — agent tool usage and implementation packets are invisible to watch.");
+        }
+        else {
+            lines.push("  Supervision note: rules not installed — agent is not operating under AgentBridge protocol.");
+        }
+    }
     if (governance.rulesIssues.length > 0) {
         for (const issue of governance.rulesIssues) {
             lines.push(`Rules issue: ${issue}`);
@@ -426,7 +464,7 @@ async function runDoctor(cliRootOverride) {
     lines.push("Product status:");
     if (productStatus === "ready") {
         lines.push("- Connection: ready");
-        lines.push("- Governance: " + governance.governanceStatus);
+        lines.push(`- Supervision: ${supervisionStatus}`);
         lines.push("- Recovery: ready");
         lines.push(`- Rules: ${governance.rulesInstalled ? "installed" : "missing"}`);
         lines.push(`- MCP: ${governance.mcpConfigured ? "configured" : "missing"}`);
@@ -434,7 +472,7 @@ async function runDoctor(cliRootOverride) {
     }
     else if (productStatus === "ready_basic_recovery") {
         lines.push("- Connection: ready");
-        lines.push("- Governance: " + governance.governanceStatus);
+        lines.push(`- Supervision: ${supervisionStatus}`);
         lines.push("- Recovery: basic");
         lines.push(`- Rules: ${governance.rulesInstalled ? "installed" : "missing"}`);
         lines.push(`- MCP: ${governance.mcpConfigured ? "configured" : "missing"}`);
@@ -444,7 +482,7 @@ async function runDoctor(cliRootOverride) {
     else if (productStatus === "active_work_found") {
         const recoveryBasic = (0, recovery_reconcile_1.recoveryIsBasicPacket)(projectAccess.packet);
         lines.push("- Connection: ready");
-        lines.push("- Governance: " + governance.governanceStatus);
+        lines.push(`- Supervision: ${supervisionStatus}`);
         lines.push("- Recovery: " + (recoveryBasic ? "basic" : "ready"));
         lines.push(`- Rules: ${governance.rulesInstalled ? "installed" : "missing"}`);
         lines.push(`- MCP: ${governance.mcpConfigured ? "configured" : "missing"}`);
@@ -456,7 +494,7 @@ async function runDoctor(cliRootOverride) {
     }
     else if (productStatus === "needs_recover") {
         lines.push("- Connection: ready");
-        lines.push("- Governance: " + governance.governanceStatus);
+        lines.push(`- Supervision: ${supervisionStatus}`);
         lines.push("- Recovery: required");
         lines.push(`- Rules: ${governance.rulesInstalled ? "installed" : "missing"}`);
         lines.push(`- MCP: ${governance.mcpConfigured ? "configured" : "missing"}`);
@@ -464,7 +502,7 @@ async function runDoctor(cliRootOverride) {
     }
     else {
         lines.push("- Connection: incomplete");
-        lines.push("- Governance: " + governance.governanceStatus);
+        lines.push(`- Supervision: ${supervisionStatus}`);
         lines.push("- Recovery: pending");
         lines.push(`- Rules: ${governance.rulesInstalled ? "installed" : "missing"}`);
         lines.push(`- MCP: ${governance.mcpConfigured ? "configured" : "missing"}`);

package/dist/commands/setup-mcp.js

@@ -3,72 +3,82 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSetupMcp = runSetupMcp;
 const node_path_1 = require("node:path");
 const config_1 = require("../config");
+const mcp_config_1 = require("../mcp-config");
 const mcp_runtime_1 = require("../mcp-runtime");
 const MCP_SERVER_NAME = "agentbridge";
-function standardSnippet(projectId, apiKey, apiBaseUrl) {
-    const serverConfig = {
-        command: "agentbridge",
-        args: ["mcp"],
-        env: {
-            AGENTBRIDGE_PROJECT_ID: projectId,
-            AGENTBRIDGE_API_KEY: apiKey,
-            AGENTBRIDGE_BASE_URL: apiBaseUrl,
-        },
-    };
-    return JSON.stringify({ [MCP_SERVER_NAME]: serverConfig }, null, 2);
-}
-async function runSetupMcp(options = {}) {
-    const cfg = (0, config_1.readConfig)();
-    const projectId = process.env.AGENTBRIDGE_PROJECT_ID ?? cfg.projectId ?? "<your-project-id>";
-    const apiKey = process.env.AGENTBRIDGE_API_KEY ?? cfg.apiKey ?? "<your-api-key>";
-    const apiBaseUrl = process.env.AGENTBRIDGE_BASE_URL ??
-        cfg.apiBaseUrl ??
-        "https://agentauth-api-production.up.railway.app";
-    const editor = options.editor ?? "cursor";
-    process.stdout.write("\nAgentBridge MCP Setup\n");
-    process.stdout.write("─────────────────────────────────────────\n\n");
+function editorConfigHint(editor) {
     if (editor === "cursor") {
-        process.stdout.write("Add this to your ~/.cursor/mcp.json (or project-level .cursor/mcp.json):\n\n");
-    }
-    else if (editor === "windsurf") {
-        process.stdout.write("Add this to your ~/.codeium/windsurf/mcp_config.json:\n\n");
-    }
-    else if (editor === "vscode") {
-        process.stdout.write("Add this to your .vscode/mcp.json:\n\n");
-    }
-    else {
-        process.stdout.write(`Add this to your ${editor} MCP config:\n\n`);
+        return "Add this to your ~/.cursor/mcp.json (or project-level .cursor/mcp.json):\n\n";
     }
-    process.stdout.write("Recommended config:\n\n");
-    process.stdout.write(JSON.stringify({
-        mcpServers: JSON.parse(standardSnippet(projectId, apiKey, apiBaseUrl)),
-    }, null, 2) + "\n");
-    if (projectId === "<your-project-id>" || apiKey === "<your-api-key>") {
-        process.stdout.write("\n⚠  Credentials not found. Run `agentbridge connect` first to save your project ID and API key.\n");
+    if (editor === "windsurf") {
+        return "Add this to your ~/.codeium/windsurf/mcp_config.json:\n\n";
     }
-    else {
-        process.stdout.write("\n✓ Credentials filled from .agentbridge/config.json\n");
+    if (editor === "vscode") {
+        return "Add this to your .vscode/mcp.json:\n\n";
     }
-    const cliDistDir = (0, node_path_1.resolve)(__dirname, "..");
+    return "Add this to your " + editor + " MCP config:\n\n";
+}
+function printRuntimeStatus(cliDistDir) {
     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:",
+            "   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"));
+        return;
     }
-    else {
+    process.stdout.write(["", "✓ MCP runtime is bundled with this CLI (agentbridge mcp is ready).", ""].join("\n"));
+}
+async function runSetupMcp(options = {}) {
+    const cliDistDir = (0, node_path_1.resolve)(__dirname, "..");
+    const editor = options.editor ?? "cursor";
+    process.stdout.write("\nAgentBridge MCP Setup\n");
+    process.stdout.write("─────────────────────────────────────────\n\n");
+    if (options.local) {
+        const entry = (0, mcp_config_1.buildLocalMcpServerEntry)(cliDistDir);
+        const mcpPath = (0, mcp_config_1.writeLocalMcpConfig)(cliDistDir);
+        process.stdout.write("Mode: local-first (no project ID or API key required)\n\n");
+        process.stdout.write("MCP config written: " + mcpPath + "\n\n");
+        process.stdout.write("Configured entry:\n\n");
+        process.stdout.write(JSON.stringify({ mcpServers: { [MCP_SERVER_NAME]: entry } }, null, 2) + "\n");
+        process.stdout.write("\nLocal mode: agent_hello creates work contracts on disk.\n" +
+            "  Run agentbridge watch in this repo, then restart Cursor.\n");
+        printRuntimeStatus(cliDistDir);
         process.stdout.write([
             "",
-            "✓ MCP runtime is bundled with this CLI (`agentbridge mcp` is ready).",
+            "Next:",
+            "  1. Restart Cursor to load MCP.",
+            "  2. agentbridge watch",
+            "  3. In chat: agent_hello({ intent: \"what you are about to do\" })",
             "",
         ].join("\n"));
+        return;
+    }
+    const cfg = (0, config_1.readConfig)();
+    const projectId = process.env.AGENTBRIDGE_PROJECT_ID ?? cfg.projectId ?? "<your-project-id>";
+    const apiKey = process.env.AGENTBRIDGE_API_KEY ?? cfg.apiKey ?? "<your-api-key>";
+    const apiBaseUrl = process.env.AGENTBRIDGE_BASE_URL ??
+        cfg.apiBaseUrl ??
+        "https://agentauth-api-production.up.railway.app";
+    process.stdout.write(editorConfigHint(editor));
+    process.stdout.write("Recommended config:\n\n");
+    const serverEntry = (0, mcp_config_1.buildServerMcpServerEntry)(projectId, apiKey, apiBaseUrl);
+    process.stdout.write(JSON.stringify({ mcpServers: { [MCP_SERVER_NAME]: serverEntry } }, null, 2) + "\n");
+    if (projectId === "<your-project-id>" || apiKey === "<your-api-key>") {
+        process.stdout.write("\n⚠  Credentials not found. Run agentbridge connect first to save your project ID and API key.\n" +
+            "   Or use local mode: agentbridge setup-mcp --local\n");
+    }
+    else {
+        const mcpPath = (0, mcp_config_1.mergeAgentbridgeIntoCursorMcp)(serverEntry);
+        process.stdout.write("\nMCP config written: " + mcpPath + "\n");
+        process.stdout.write("\n✓ Credentials filled from .agentbridge/config.json\n");
     }
+    printRuntimeStatus(cliDistDir);
     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.",