@haven_ai/connect 0.1.28-alpha.0 → 0.1.30-alpha.0

package/dist/cli.js

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
+import crypto from 'crypto';
+import { Wallet } from 'ethers';
+import { mkdir, rm, stat, readdir, readFile, chmod, access, writeFile, unlink, rename } from 'fs/promises';
+import { homedir, platform } from 'os';
+import { join, resolve, dirname, basename } from 'path';
 import { ensureConsent, computeConsentHash, loadCredentials, consentInputFromClient, registeredToolNames, MCP_VERSION } from '@haven_ai/mcp';
 import { ensureSignerConsent, computeSignerConsentHash, loadSignerCredentials, createEdgeSigner, toolSchemas } from '@haven_ai/signer';
-import { isSupportedNodeVersion, unsupportedNodeVersionMessage, SKILL_FOLDER_NAME, resolveTokenFromAddress, HAVEN_SKILL_MD, HAVEN_SKILL_BODY_MD, HAVEN_MINIMUM_NODE_VERSION } from '@haven_ai/sdk';
-import { mkdir, rm, chmod, access, writeFile, readFile, unlink, readdir, stat } from 'fs/promises';
-import { homedir, platform } from 'os';
-import { join, resolve, dirname } from 'path';
+import { isSupportedNodeVersion, SKILL_FOLDER_NAME, resolveTokenFromAddress, HAVEN_SKILL_MD, HAVEN_SKILL_BODY_MD, HAVEN_MINIMUM_NODE_VERSION, unsupportedNodeVersionMessage } from '@haven_ai/sdk';
 import { parseDocument, isMap, stringify } from 'yaml';
 import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
 import { realpathSync } from 'fs';
 import { fileURLToPath, pathToFileURL } from 'url';
-import crypto from 'crypto';
-import { Wallet } from 'ethers';
+import { createInterface } from 'readline';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -22,125 +23,605 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-function mcpPackageSpec() {
-  return `${MCP_RUNTIME_MANIFEST.mcpPackage}@${MCP_RUNTIME_MANIFEST.mcpVersion}`;
-}
-function sdkPackageSpec() {
-  return `${MCP_RUNTIME_MANIFEST.sdkPackage}@${MCP_RUNTIME_MANIFEST.sdkVersion}`;
+
+// src/api.ts
+function createConnectApiClient(baseUrl, fetchImpl = fetch) {
+  const root = baseUrl.replace(/\/+$/, "");
+  return {
+    resolveSetup: (input) => request(fetchImpl, `${root}/agent-connection-setups/resolve`, {
+      method: "POST",
+      body: JSON.stringify({
+        setup_token: input.setupToken,
+        connector_version: input.connectorVersion,
+        runtime: input.runtime
+      })
+    }),
+    registerSetup: (input) => request(fetchImpl, `${root}/agent-connection-setups/register`, {
+      method: "POST",
+      body: JSON.stringify({
+        setup_token: input.setupToken,
+        challenge_id: input.challengeId,
+        delegate_address: input.delegateAddress,
+        proof_signature: input.proofSignature,
+        api_key_hash: input.apiKeyHash,
+        api_key_prefix: input.apiKeyPrefix,
+        runtime: input.runtime,
+        connector_version: input.connectorVersion,
+        mcp_server_name: input.mcpServerName,
+        connector_context: input.connectorContext,
+        install_capabilities: input.installCapabilities && {
+          can_write_runtime_config: input.installCapabilities.canWriteRuntimeConfig,
+          restart_required: input.installCapabilities.restartRequired
+        }
+      })
+    }),
+    getAgentIdentity: (apiKey) => request(fetchImpl, `${root}/machine-payments/agent`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${apiKey}` }
+    }),
+    getConnectorStatus: (setupId, apiKey) => request(fetchImpl, `${root}/agent-connection-setups/${encodeURIComponent(setupId)}/connector-status`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${apiKey}` }
+    }),
+    updateInstallStatus: async (setupId, apiKey, input) => {
+      await request(fetchImpl, `${root}/agent-connection-setups/${encodeURIComponent(setupId)}/install-status`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}` },
+        body: JSON.stringify({
+          runtime: input.runtime,
+          connector_version: input.connectorVersion,
+          runtime_mcp_mode: input.runtimeMcpMode,
+          hosted_mcp_configured: input.hostedMcpConfigured,
+          local_signer_configured: input.localSignerConfigured,
+          local_mcp_configured: input.localMcpConfigured,
+          credential_files_written: input.credentialFilesWritten,
+          signer_acknowledged: input.signerAcknowledged,
+          local_mcp_acknowledged: input.localMcpAcknowledged,
+          activation_command_available: input.activationCommandAvailable,
+          skill_installed: input.skillInstalled,
+          probe_result: input.probeResult,
+          restart_required: input.restartRequired,
+          next_user_action: input.nextUserAction,
+          error_code: input.errorCode ?? null,
+          environment_label: input.environmentLabel
+        })
+      });
+    }
+  };
 }
-function signerPackageSpec() {
-  return `${MCP_RUNTIME_MANIFEST.signerPackage}@${MCP_RUNTIME_MANIFEST.signerVersion}`;
+async function request(fetchImpl, url, init) {
+  const response = await fetchImpl(url, {
+    ...init,
+    headers: {
+      "Content-Type": "application/json",
+      ...init.headers ?? {}
+    }
+  });
+  const text = await response.text();
+  const body = text ? JSON.parse(text) : null;
+  if (!response.ok) {
+    const message = body?.error ?? body?.message ?? `${response.status} ${response.statusText}`;
+    throw new ConnectRequestError(`Haven setup request failed: ${message}`, response.status);
+  }
+  return body;
 }
-var MCP_RUNTIME_MANIFEST;
-var init_runtime_manifest = __esm({
-  "src/runtime-manifest.ts"() {
-    MCP_RUNTIME_MANIFEST = {
-      mcpPackage: "@haven_ai/mcp",
-      mcpVersion: MCP_VERSION,
-      sdkPackage: "@haven_ai/sdk",
-      sdkVersion: "0.1.28-alpha.0",
-      signerPackage: "@haven_ai/signer",
-      signerVersion: "0.1.28-alpha.0",
-      // Sourced from the SDK, never a literal (#1161). This field read '20.0.0'
-      // while every package's `engines` said `>=24` and the docs said `>=24.0.0`,
-      // so the guard that was supposed to enforce the floor waved Node v23 through
-      // — including on the `--local` path where it does run. A hand-maintained
-      // second copy of a number is a drift waiting to happen; a guard test pins
-      // this against `package.json`'s `engines.node`.
-      minimumNodeVersion: HAVEN_MINIMUM_NODE_VERSION,
-      supportedClients: ["codex-cli", "codex-desktop", "claude-code"],
-      requiredTools: registeredToolNames(),
-      /**
-       * The signer MCP's tool surface, DERIVED from the pinned @haven_ai/signer
-       * package (#1587) — same anti-drift rule as `requiredTools` above: a
-       * literal list here would rot the first time the signer gains a tool.
-       * The handshake probe requires all of them.
-       */
-      requiredSignerTools: Object.keys(toolSchemas)
+var ConnectRequestError;
+var init_api = __esm({
+  "src/api.ts"() {
+    ConnectRequestError = class extends Error {
+      constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "ConnectRequestError";
+      }
+      status;
     };
   }
 });
-async function writeRuntimeConfig(input, deps = {}) {
-  switch (input.runtime) {
-    case "codex-cli":
-    case "codex-desktop":
-      return writeCodexConfig(input);
-    case "cursor":
-      return writeJsonRuntimeConfig(input, cursorConfigPath(input.homeDir), "mcpServers");
-    case "vscode":
-      return writeJsonRuntimeConfig(input, vscodeConfigPath(input.homeDir), "servers");
-    case "vscode-insiders":
-      return writeJsonRuntimeConfig(input, vscodeInsidersConfigPath(input.homeDir), "servers");
-    case "claude-desktop":
-      return writeJsonRuntimeConfig(input, claudeDesktopConfigPath(input.homeDir), "mcpServers");
-    case "hermes":
-      return writeHermesConfig(input, deps);
-    default:
-      return {
-        hostedConfigured: false,
-        signerConfigured: false,
-        localMcpConfigured: false,
-        runtimeMcpMode: "manual",
-        target: "manual runtime setup",
-        changed: false,
-        restartRequired: true,
-        messages: ["Runtime config needs to be added manually for this agent environment."],
-        errorCode: "manual_runtime_setup_required"
-      };
+function generateDelegateKey() {
+  return delegateKeyFromPrivateKey(Wallet.createRandom().privateKey);
+}
+function delegateKeyFromPrivateKey(privateKey) {
+  const wallet = new Wallet(privateKey);
+  return {
+    privateKey: wallet.privateKey,
+    address: wallet.address,
+    signChallenge: (message) => wallet.signMessage(message)
+  };
+}
+function generateAgentApiKey() {
+  return `sk_agent_${crypto.randomBytes(24).toString("hex")}`;
+}
+function hashAgentApiKey(apiKey) {
+  return crypto.createHash("sha256").update(apiKey).digest("hex");
+}
+function agentApiKeyPrefix(apiKey) {
+  return apiKey.slice(0, 12);
+}
+var init_key = __esm({
+  "src/key.ts"() {
   }
+});
+
+// src/redact.ts
+function redactSecrets(value) {
+  return value.replace(API_KEY_RE, "sk_agent_[redacted]").replace(PRIVATE_KEY_RE, "0x[redacted-private-key]");
 }
-function buildHostedServer(hostedMcpUrl, apiKey, runtime) {
-  if (runtime === "vscode" || runtime === "vscode-insiders") {
+function shortAddress(address) {
+  if (!/^0x[0-9a-fA-F]{40}$/.test(address)) return address;
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+var API_KEY_RE, PRIVATE_KEY_RE;
+var init_redact = __esm({
+  "src/redact.ts"() {
+    API_KEY_RE = /sk_agent_[A-Za-z0-9]+/g;
+    PRIVATE_KEY_RE = /0x[0-9a-fA-F]{64}/g;
+  }
+});
+
+// src/server-names.ts
+function assertValidServerSlug(slug) {
+  if (slug.length === 0 || slug.length > 32 || !SLUG_RE.test(slug)) {
+    throw new Error(
+      `Invalid server name ${JSON.stringify(slug)}: use 1-32 lowercase letters, digits, and single hyphens (e.g. "research").`
+    );
+  }
+  if (slug === "haven" || slug === "haven-signer") {
+    throw new Error(
+      `Invalid server name ${JSON.stringify(slug)}: "haven" and "haven-signer" are the unnamed pair's own names \u2014 omit --name for the bare pair.`
+    );
+  }
+  if (slug === "signer" || slug.startsWith("signer-")) {
+    throw new Error(
+      `Invalid server name ${JSON.stringify(slug)}: "signer" and "signer-*" are reserved \u2014 they would collide with another pair's haven-signer-* entry.`
+    );
+  }
+}
+function serverNamesFor(slug) {
+  if (slug === void 0) {
     return {
-      type: "http",
-      url: hostedMcpUrl,
-      headers: { Authorization: `Bearer ${apiKey}` }
+      hosted: "haven",
+      signer: "haven-signer",
+      // Historical Codex table names — every wired Codex host has these.
+      codexHosted: "haven",
+      codexSigner: "haven_signer",
+      hermesEnvKey: "MCP_HAVEN_API_KEY"
     };
   }
+  assertValidServerSlug(slug);
   return {
-    url: hostedMcpUrl,
-    headers: { Authorization: `Bearer ${apiKey}` }
+    hosted: `haven-${slug}`,
+    signer: `haven-signer-${slug}`,
+    // Hyphens are valid TOML bare keys, so named Codex tables match the
+    // JSON/YAML names instead of inheriting the legacy underscore.
+    codexHosted: `haven-${slug}`,
+    codexSigner: `haven-signer-${slug}`,
+    hermesEnvKey: `MCP_HAVEN_${slug.toUpperCase().replace(/-/g, "_")}_API_KEY`
   };
 }
-function resolveSignerLaunchSpec(input) {
-  return input.signerCommand ?? {
-    command: "npx",
-    args: ["-y", signerPackageSpec(), "--credentials", input.signerPath]
+var SLUG_RE;
+var init_server_names = __esm({
+  "src/server-names.ts"() {
+    SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+  }
+});
+async function preflightCredentialStorage(input = {}) {
+  const directory = defaultCredentialRoot(input.baseDir);
+  await mkdir(directory, { recursive: true, mode: 448 });
+  await restrictPermissions(directory, 448, input.warn);
+  const probePath = join(directory, `.haven-connect-preflight-${crypto.randomBytes(8).toString("hex")}`);
+  try {
+    await writeOwnerOnlyJson(probePath, { ok: true }, input.warn);
+  } finally {
+    await rm(probePath, { force: true }).catch(() => void 0);
+  }
+  return directory;
+}
+async function writeCredentialFiles(input) {
+  const directory = defaultAgentDirectory(input.serverName ?? input.agentId, input.baseDir);
+  await mkdir(directory, { recursive: true, mode: 448 });
+  await restrictPermissions(directory, 448, input.warn);
+  const identityPath = join(directory, "identity.json");
+  const signerPath = join(directory, "signer.json");
+  const agentPath = join(directory, "agent.json");
+  await assertDoesNotExist(identityPath);
+  await assertDoesNotExist(signerPath);
+  await assertDoesNotExist(agentPath);
+  await writeOwnerOnlyJson(signerPath, signerPayload(input), input.warn);
+  try {
+    await writeOwnerOnlyJson(identityPath, identityPayload(input), input.warn);
+  } catch (err) {
+    await rm(signerPath, { force: true }).catch(() => void 0);
+    throw err;
+  }
+  try {
+    await writeOwnerOnlyJson(agentPath, agentPayload(input), input.warn);
+  } catch (err) {
+    await rm(signerPath, { force: true }).catch(() => void 0);
+    await rm(identityPath, { force: true }).catch(() => void 0);
+    await rm(agentPath, { force: true }).catch(() => void 0);
+    throw err;
+  }
+  return { directory, identityPath, signerPath, agentPath };
+}
+function signerPayload(input) {
+  return {
+    delegate_key: input.delegateKey,
+    delegate_address: input.delegateAddress,
+    agent_id: input.agentId,
+    safe_address: input.safeAddress,
+    chain_id: input.chainId,
+    network: input.network,
+    x402_binding_signer: input.x402BindingSigner,
+    note: "Local signer credential. Haven backend never receives this private key."
   };
 }
-function buildSignerServer(spec, runtime) {
-  const server = {
-    command: spec.command,
-    args: spec.args
+function identityPayload(input) {
+  return {
+    api_key: input.apiKey,
+    agent_id: input.agentId,
+    safe_address: input.safeAddress,
+    chain_id: input.chainId,
+    network: input.network,
+    api_url: input.apiUrl,
+    hosted_mcp_url: input.hostedMcpUrl,
+    agent_budget: input.agentBudget,
+    note: "Haven API key identifies the agent only. It cannot spend without the local signer key and on-chain Haven wallet rules."
   };
-  if (runtime === "vscode" || runtime === "vscode-insiders") return { type: "stdio", ...server };
-  return server;
 }
-function mergeJsonMcpConfig(existingJson, serverRoot, hostedServer, signerServer) {
-  const config = existingJson?.trim() ? parseJsonObject(existingJson) : {};
-  const existingRoot = config[serverRoot];
-  const servers = existingRoot && typeof existingRoot === "object" && !Array.isArray(existingRoot) ? existingRoot : {};
-  config[serverRoot] = {
-    ...servers,
-    haven: hostedServer,
-    "haven-signer": signerServer
+function agentPayload(input) {
+  return {
+    agent_id: input.agentId,
+    delegate_address: input.delegateAddress,
+    safe_address: input.safeAddress,
+    chain_id: input.chainId,
+    network: input.network,
+    agent_budget: input.agentBudget,
+    note: "Non-secret orientation for the agent: public delegate/Haven wallet identity + configured budget. Contains no API key or signing key. For the live remaining budget, call haven_get_allowances."
   };
-  return `${JSON.stringify(config, null, 2)}
-`;
 }
-function mergeHermesYaml(existingYaml, hostedServer, signerServer) {
-  if (!existingYaml?.trim()) return renderHermesYaml({ haven: hostedServer, "haven-signer": signerServer });
-  const doc = parseDocument(existingYaml, { keepSourceTokens: true });
-  if (doc.errors.length > 0 || !isMap(doc.contents)) {
-    throw new Error("Hermes config must be a YAML object");
+async function readStoredCredentials(serverName, agentIdOrSlug, baseDir) {
+  const key = serverName ?? agentIdOrSlug;
+  const directory = key ? defaultAgentDirectory(key, baseDir) : await discoverSoleAgentDirectory(baseDir);
+  const identity = await readJsonFile(join(directory, "identity.json"));
+  if (!identity) {
+    throw new Error(
+      `No Haven credentials at ${directory}. Nothing to re-key \u2014 connect this agent first, or pass the --name you wired it under.`
+    );
   }
-  const mcpPair = doc.contents.items.find((item) => item.key?.toString() === "mcp_servers");
-  const existingServers = mcpPair && isMap(mcpPair.value) ? mcpPair.value.toJSON() : {};
-  const servers = isRecord(existingServers) ? existingServers : {};
+  const agent = await readJsonFile(join(directory, "agent.json")) ?? {};
+  const signer = await readJsonFile(join(directory, "signer.json")) ?? {};
+  const agentId = asString(identity.agent_id);
+  const apiKey = asString(identity.api_key);
+  const apiUrl = asString(identity.api_url);
+  const hostedMcpUrl = asString(identity.hosted_mcp_url);
+  if (!agentId || !apiKey || !apiUrl || !hostedMcpUrl) {
+    throw new Error(
+      `The credential set at ${directory} is incomplete (identity.json is missing agent_id, api_key, api_url or hosted_mcp_url). Re-key cannot rebuild it \u2014 reconnect the agent instead.`
+    );
+  }
+  return {
+    directory,
+    agentId,
+    apiKey,
+    apiUrl,
+    hostedMcpUrl,
+    delegateAddress: asString(agent.delegate_address) ?? asString(signer.delegate_address),
+    safeAddress: asString(identity.safe_address) ?? asString(agent.safe_address),
+    chainId: typeof identity.chain_id === "number" ? identity.chain_id : void 0,
+    network: asString(identity.network),
+    x402BindingSigner: asString(signer.x402_binding_signer),
+    agentBudget: Array.isArray(identity.agent_budget) ? identity.agent_budget : void 0
+  };
+}
+async function discoverSoleAgentDirectory(baseDir) {
+  const root = defaultCredentialRoot(baseDir);
+  let entries = [];
+  try {
+    entries = await readdir(root);
+  } catch {
+    throw new Error(`No Haven credentials found under ${root}. Connect an agent on this machine first.`);
+  }
+  const candidates = [];
+  for (const entry of entries) {
+    const directory = join(root, entry);
+    if (!await readJsonFile(join(directory, "identity.json"))) continue;
+    if (await readJsonFile(join(directory, "TOMBSTONE.json"))) continue;
+    candidates.push(directory);
+  }
+  if (candidates.length === 1) return candidates[0];
+  if (candidates.length === 0) {
+    throw new Error(`No Haven credentials found under ${root}. Connect an agent on this machine first.`);
+  }
+  throw new Error(
+    `Several agents are wired on this machine, so --rekey cannot tell which one you mean:
+` + candidates.map((d) => `  ${d}`).join("\n") + "\nRe-run with --name <slug> to pick one."
+  );
+}
+async function rewriteCredentialFiles(input) {
+  const directory = defaultAgentDirectory(input.serverName ?? input.agentId, input.baseDir);
+  const identityPath = join(directory, "identity.json");
+  const signerPath = join(directory, "signer.json");
+  const agentPath = join(directory, "agent.json");
+  const targets = [
+    { path: signerPath, payload: signerPayload(input) },
+    { path: identityPath, payload: identityPayload(input) },
+    { path: agentPath, payload: agentPayload(input) }
+  ];
+  const originals = /* @__PURE__ */ new Map();
+  for (const { path } of targets) {
+    originals.set(path, await readRawFile(path));
+  }
+  const temps = [];
+  try {
+    for (const { path, payload } of targets) {
+      const temp = `${path}.rekey-${crypto.randomBytes(6).toString("hex")}.tmp`;
+      await writeOwnerOnlyJson(temp, payload, input.warn);
+      temps.push({ from: temp, to: path });
+    }
+    for (const { from, to } of temps) {
+      await rename(from, to);
+    }
+  } catch (err) {
+    for (const { from } of temps) await rm(from, { force: true }).catch(() => void 0);
+    for (const [path, contents] of originals) {
+      if (contents === null) {
+        await rm(path, { force: true }).catch(() => void 0);
+      } else {
+        await writeFile(path, contents, { mode: 384 }).catch(() => void 0);
+      }
+    }
+    throw err;
+  }
+  return { directory, identityPath, signerPath, agentPath };
+}
+async function writeRekeyPending(directory, pending, warn) {
+  const path = join(directory, REKEY_PENDING_FILENAME);
+  await rm(path, { force: true }).catch(() => void 0);
+  await writeOwnerOnlyJson(path, { ...pending }, warn);
+  return path;
+}
+async function readRekeyPending(directory, now = Date.now()) {
+  const path = join(directory, REKEY_PENDING_FILENAME);
+  const raw = await readJsonFile(path);
+  if (!raw) {
+    throw new Error(
+      `No re-key in progress at ${directory}. Run the connector with --rekey first \u2014 it prints the new signing address to paste into the Haven agent page.`
+    );
+  }
+  const pending = raw;
+  if (!pending.new_delegate_key || !pending.new_delegate_address || !pending.agent_id) {
+    throw new Error(`The pending re-key at ${path} is unreadable. Delete it and start again with --rekey.`);
+  }
+  if (pending.expires_at && Date.parse(pending.expires_at) < now) {
+    throw new Error(
+      `The re-key started at ${pending.started_at} has expired. Start again with --rekey \u2014 the address currently shown in your dashboard is no longer the one this machine holds.`
+    );
+  }
+  return pending;
+}
+async function inspectRekeyPending(directory, now = Date.now()) {
+  const path = join(directory, REKEY_PENDING_FILENAME);
+  const raw = await readJsonFile(path);
+  if (!raw) {
+    const present = await readRawFile(path) !== null;
+    return present ? { state: "unreadable", path } : null;
+  }
+  const agentId = asString(raw.agent_id);
+  const newDelegateAddress = asString(raw.new_delegate_address);
+  const startedAt = asString(raw.started_at);
+  const expiresAt = asString(raw.expires_at);
+  if (!agentId || !newDelegateAddress) {
+    return { state: "unreadable", path, ...startedAt ? { startedAt } : {} };
+  }
+  const expired = expiresAt !== void 0 && Date.parse(expiresAt) < now;
+  return {
+    state: expired ? "expired" : "pending",
+    path,
+    agentId,
+    newDelegateAddress,
+    ...startedAt ? { startedAt } : {},
+    ...expiresAt ? { expiresAt } : {}
+  };
+}
+async function clearRekeyPending(directory) {
+  await rm(join(directory, REKEY_PENDING_FILENAME), { force: true }).catch(() => void 0);
+}
+async function readJsonFile(path) {
+  const raw = await readRawFile(path);
+  if (raw === null) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function readRawFile(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+async function assertServerSlugAvailable(serverName, baseDir) {
+  const directory = defaultAgentDirectory(serverName, baseDir);
+  try {
+    await stat(join(directory, "identity.json"));
+  } catch {
+    return;
+  }
+  throw new Error(
+    `The name "${serverName}" is already wired on this machine (${directory} holds credentials). Pick a different --name, or revoke and remove that agent first \u2014 connect never overwrites credentials.`
+  );
+}
+function defaultAgentDirectory(agentId, baseDir = join(homedir(), ".haven", "agents")) {
+  return resolve(defaultCredentialRoot(baseDir), safePathPart(agentId));
+}
+function defaultCredentialRoot(baseDir = join(homedir(), ".haven", "agents")) {
+  return resolve(baseDir);
+}
+async function writeOwnerOnlyJson(path, value, warn) {
+  const json = JSON.stringify(dropUndefined(value), null, 2);
+  await writeFile(path, `${json}
+`, { mode: 384, flag: "wx" });
+  await restrictPermissions(path, 384, warn);
+}
+function safePathPart(value) {
+  return value.replace(/[^A-Za-z0-9_.-]/g, "_");
+}
+function dropUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== void 0));
+}
+async function assertDoesNotExist(path) {
+  try {
+    await access(path);
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") return;
+    throw err;
+  }
+  throw new Error(`Refusing to overwrite existing Haven credential file: ${path}`);
+}
+async function restrictPermissions(path, mode, warn) {
+  try {
+    await chmod(path, mode);
+  } catch (err) {
+    warn?.(
+      `Warning: could not restrict permissions on ${path} to ${mode.toString(8)}. Move this credential to a private location or run chmod ${mode.toString(8)} ${path}. ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+var REKEY_PENDING_FILENAME, REKEY_PENDING_TTL_MS;
+var init_storage = __esm({
+  "src/storage.ts"() {
+    REKEY_PENDING_FILENAME = "rekey-pending.json";
+    REKEY_PENDING_TTL_MS = 24 * 60 * 60 * 1e3;
+  }
+});
+function mcpPackageSpec() {
+  return `${MCP_RUNTIME_MANIFEST.mcpPackage}@${MCP_RUNTIME_MANIFEST.mcpVersion}`;
+}
+function sdkPackageSpec() {
+  return `${MCP_RUNTIME_MANIFEST.sdkPackage}@${MCP_RUNTIME_MANIFEST.sdkVersion}`;
+}
+function signerPackageSpec() {
+  return `${MCP_RUNTIME_MANIFEST.signerPackage}@${MCP_RUNTIME_MANIFEST.signerVersion}`;
+}
+var MCP_RUNTIME_MANIFEST;
+var init_runtime_manifest = __esm({
+  "src/runtime-manifest.ts"() {
+    MCP_RUNTIME_MANIFEST = {
+      mcpPackage: "@haven_ai/mcp",
+      mcpVersion: MCP_VERSION,
+      sdkPackage: "@haven_ai/sdk",
+      sdkVersion: "0.1.30-alpha.0",
+      signerPackage: "@haven_ai/signer",
+      signerVersion: "0.1.30-alpha.0",
+      // Sourced from the SDK, never a literal (#1161). This field read '20.0.0'
+      // while every package's `engines` said `>=24` and the docs said `>=24.0.0`,
+      // so the guard that was supposed to enforce the floor waved Node v23 through
+      // — including on the `--local` path where it does run. A hand-maintained
+      // second copy of a number is a drift waiting to happen; a guard test pins
+      // this against `package.json`'s `engines.node`.
+      minimumNodeVersion: HAVEN_MINIMUM_NODE_VERSION,
+      supportedClients: ["codex-cli", "codex-desktop", "claude-code"],
+      requiredTools: registeredToolNames(),
+      /**
+       * The signer MCP's tool surface, DERIVED from the pinned @haven_ai/signer
+       * package (#1587) — same anti-drift rule as `requiredTools` above: a
+       * literal list here would rot the first time the signer gains a tool.
+       * The handshake probe requires all of them.
+       */
+      requiredSignerTools: Object.keys(toolSchemas)
+    };
+  }
+});
+async function writeRuntimeConfig(input, deps = {}) {
+  switch (input.runtime) {
+    case "codex-cli":
+    case "codex-desktop":
+      return writeCodexConfig(input);
+    case "cursor":
+      return writeJsonRuntimeConfig(input, cursorConfigPath(input.homeDir), "mcpServers");
+    case "vscode":
+      return writeJsonRuntimeConfig(input, vscodeConfigPath(input.homeDir), "servers");
+    case "vscode-insiders":
+      return writeJsonRuntimeConfig(input, vscodeInsidersConfigPath(input.homeDir), "servers");
+    case "claude-desktop":
+      return writeJsonRuntimeConfig(input, claudeDesktopConfigPath(input.homeDir), "mcpServers");
+    case "hermes":
+      return writeHermesConfig(input, deps);
+    default:
+      return {
+        hostedConfigured: false,
+        signerConfigured: false,
+        localMcpConfigured: false,
+        runtimeMcpMode: "manual",
+        target: "manual runtime setup",
+        changed: false,
+        restartRequired: true,
+        messages: ["Runtime config needs to be added manually for this agent environment."],
+        errorCode: "manual_runtime_setup_required"
+      };
+  }
+}
+function buildHostedServer(hostedMcpUrl, apiKey, runtime) {
+  if (runtime === "vscode" || runtime === "vscode-insiders") {
+    return {
+      type: "http",
+      url: hostedMcpUrl,
+      headers: { Authorization: `Bearer ${apiKey}` }
+    };
+  }
+  return {
+    url: hostedMcpUrl,
+    headers: { Authorization: `Bearer ${apiKey}` }
+  };
+}
+function resolveSignerLaunchSpec(input) {
+  return input.signerCommand ?? {
+    command: "npx",
+    args: ["-y", signerPackageSpec(), "--credentials", input.signerPath]
+  };
+}
+function buildSignerServer(spec, runtime) {
+  const server = {
+    command: spec.command,
+    args: spec.args
+  };
+  if (runtime === "vscode" || runtime === "vscode-insiders") return { type: "stdio", ...server };
+  return server;
+}
+function mergeJsonMcpConfig(existingJson, serverRoot, hostedServer, signerServer, names = serverNamesFor(), configPath) {
+  const config = existingJson?.trim() ? parseJsonObject(existingJson, configPath) : {};
+  const existingRoot = config[serverRoot];
+  const servers = existingRoot && typeof existingRoot === "object" && !Array.isArray(existingRoot) ? existingRoot : {};
+  config[serverRoot] = {
+    ...servers,
+    [names.hosted]: hostedServer,
+    [names.signer]: signerServer
+  };
+  return `${JSON.stringify(config, null, 2)}
+`;
+}
+function mergeHermesYaml(existingYaml, hostedServer, signerServer, names = serverNamesFor(), configPath) {
+  if (!existingYaml?.trim()) {
+    return renderHermesYaml({ [names.hosted]: hostedServer, [names.signer]: signerServer });
+  }
+  const doc = parseDocument(existingYaml, { keepSourceTokens: true });
+  if (doc.errors.length > 0 || !isMap(doc.contents)) {
+    throw new UnreadableRuntimeConfigError(configPath ?? "the Hermes config", "it is not a YAML object");
+  }
+  const mcpPair = doc.contents.items.find((item) => item.key?.toString() === "mcp_servers");
+  const existingServers = mcpPair && isMap(mcpPair.value) ? mcpPair.value.toJSON() : {};
+  const servers = isRecord(existingServers) ? existingServers : {};
   const mergedServers = {
     ...servers,
-    haven: hostedServer,
-    "haven-signer": signerServer
+    [names.hosted]: hostedServer,
+    [names.signer]: signerServer
   };
   if (!mcpPair) {
     return appendHermesMcpServers(existingYaml, mergedServers);
@@ -148,9 +629,9 @@ function mergeHermesYaml(existingYaml, hostedServer, signerServer) {
   if (!mcpPair.value?.range) return replaceEmptyHermesMcpServers(existingYaml, mcpPair.key?.range, mergedServers);
   return replaceHermesMcpServers(existingYaml, mcpPair.key?.range, mcpPair.value.range, mergedServers);
 }
-function mergeHermesEnv(existingEnv, apiKey) {
+function mergeHermesEnv(existingEnv, apiKey, envKey = HERMES_API_KEY_ENV) {
   if (/[\r\n]/.test(apiKey)) throw new Error("Hermes API key must be a single line");
-  const assignment = `${HERMES_API_KEY_ENV}=${apiKey}`;
+  const assignment = `${envKey}=${apiKey}`;
   if (!existingEnv) return `${assignment}
 `;
   const lineEnding = existingEnv.includes("\r\n") ? "\r\n" : "\n";
@@ -159,12 +640,12 @@ function mergeHermesEnv(existingEnv, apiKey) {
   if (hasTrailingNewline) lines.pop();
   let found = false;
   const merged = lines.flatMap((line) => {
-    if (isHermesEnvAssignment(line)) {
+    if (isHermesEnvAssignment(line, envKey)) {
       if (found) return [];
       found = true;
       return [assignment];
     }
-    if (isAmbiguousHermesEnvLine(line)) {
+    if (isAmbiguousHermesEnvLine(line, envKey)) {
       throw new Error("Hermes environment contains an ambiguous managed key");
     }
     return [line];
@@ -174,11 +655,11 @@ function mergeHermesEnv(existingEnv, apiKey) {
   }
   return `${merged.join(lineEnding)}${hasTrailingNewline ? lineEnding : ""}`;
 }
-function isHermesEnvAssignment(line) {
-  return /^\s*(?:export[ \t]+)?MCP_HAVEN_API_KEY[ \t]*=/.test(line);
+function isHermesEnvAssignment(line, envKey) {
+  return new RegExp(`^\\s*(?:export[ \\t]+)?${envKey}[ \\t]*=`).test(line);
 }
-function isAmbiguousHermesEnvLine(line) {
-  return /^\s*(?:export[ \t]+)?MCP_HAVEN_API_KEY\b/.test(line);
+function isAmbiguousHermesEnvLine(line, envKey) {
+  return new RegExp(`^\\s*(?:export[ \\t]+)?${envKey}\\b`).test(line);
 }
 function appendHermesMcpServers(source, servers) {
   const documentEnd = /(?:^|\n)[ \t]*\.\.\.[ \t]*(?:#[^\n]*)?\r?\n?$/.exec(source);
@@ -237,11 +718,14 @@ function renderHermesMcpServerEntries(servers, indent) {
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function mergeCodexToml(existingToml, localMcpCommand) {
-  let next = removeTomlTableTree(removeTomlTableTree(existingToml, "mcp_servers.haven"), "mcp_servers.haven_signer");
+function mergeCodexToml(existingToml, localMcpCommand, names = serverNamesFor()) {
+  let next = removeTomlTableTree(
+    removeTomlTableTree(existingToml, `mcp_servers.${names.codexHosted}`),
+    `mcp_servers.${names.codexSigner}`
+  );
   next = next.trimEnd();
   const block = [
-    "[mcp_servers.haven]",
+    `[mcp_servers.${names.codexHosted}]`,
     `command = ${tomlString(localMcpCommand)}`,
     "args = []",
     "startup_timeout_sec = 120"
@@ -253,15 +737,18 @@ function mergeCodexToml(existingToml, localMcpCommand) {
 `;
   return merged;
 }
-function mergeCodexTomlHosted(existingToml, hostedMcpUrl, apiKey, signerSpec) {
-  let next = removeTomlTableTree(removeTomlTableTree(existingToml, "mcp_servers.haven"), "mcp_servers.haven_signer");
+function mergeCodexTomlHosted(existingToml, hostedMcpUrl, apiKey, signerSpec, names = serverNamesFor()) {
+  let next = removeTomlTableTree(
+    removeTomlTableTree(existingToml, `mcp_servers.${names.codexHosted}`),
+    `mcp_servers.${names.codexSigner}`
+  );
   next = next.trimEnd();
   const block = [
-    "[mcp_servers.haven]",
+    `[mcp_servers.${names.codexHosted}]`,
     `url = ${tomlString(hostedMcpUrl)}`,
     `http_headers = { "Authorization" = ${tomlString(`Bearer ${apiKey}`)} }`,
     "",
-    "[mcp_servers.haven_signer]",
+    `[mcp_servers.${names.codexSigner}]`,
     `command = ${tomlString(signerSpec.command)}`,
     `args = [${signerSpec.args.map((arg) => tomlString(arg)).join(", ")}]`,
     "startup_timeout_sec = 120"
@@ -280,7 +767,9 @@ async function writeJsonRuntimeConfig(input, target, serverRoot) {
       existing,
       serverRoot,
       buildHostedServer(input.hostedMcpUrl, input.apiKey, input.runtime),
-      buildSignerServer(resolveSignerLaunchSpec(input), input.runtime)
+      buildSignerServer(resolveSignerLaunchSpec(input), input.runtime),
+      serverNamesFor(input.serverName),
+      target
     );
     await writeOwnerOnlyText(target, merged);
     return {
@@ -294,6 +783,7 @@ async function writeJsonRuntimeConfig(input, target, serverRoot) {
       messages: [`Updated Haven MCP entries in ${configTargetLabel(input.runtime)}.`]
     };
   } catch (err) {
+    const unreadable = err instanceof UnreadableRuntimeConfigError;
     return {
       hostedConfigured: false,
       signerConfigured: false,
@@ -302,8 +792,11 @@ async function writeJsonRuntimeConfig(input, target, serverRoot) {
       target: configTargetLabel(input.runtime),
       changed: false,
       restartRequired: true,
-      messages: [`Could not update ${configTargetLabel(input.runtime)}: ${err instanceof Error ? err.message : String(err)}`],
-      errorCode: "runtime_config_write_failed"
+      messages: unreadable ? [
+        `Could not update ${configTargetLabel(input.runtime)}: ${err.message}.`,
+        `Nothing was written to ${err.configPath}. Fix the JSON there (or move the file aside), then run \`${REPAIR_COMMAND_PREFIX} ${input.runtime}\` to write the Haven entries from the credentials already stored on this machine. Do not re-run the setup command: its token is already used.`
+      ] : [`Could not update ${configTargetLabel(input.runtime)}: ${err instanceof Error ? err.message : String(err)}`],
+      errorCode: unreadable ? "runtime_config_unreadable" : "runtime_config_write_failed"
     };
   }
 }
@@ -312,8 +805,9 @@ async function writeHermesConfig(input, deps) {
   const envTarget = hermesEnvPath(input.homeDir);
   try {
     const [existing, existingEnv] = await Promise.all([readOptional(target), readOptional(envTarget)]);
+    const names = serverNamesFor(input.serverName);
     const hostedServer = {
-      ...buildHostedServer(input.hostedMcpUrl, `\${${HERMES_API_KEY_ENV}}`, input.runtime),
+      ...buildHostedServer(input.hostedMcpUrl, `\${${names.hermesEnvKey}}`, input.runtime),
       enabled: true
     };
     const signerServer = {
@@ -323,9 +817,11 @@ async function writeHermesConfig(input, deps) {
     const merged = mergeHermesYaml(
       existing,
       hostedServer,
-      signerServer
+      signerServer,
+      names,
+      target
     );
-    const mergedEnv = mergeHermesEnv(existingEnv, input.apiKey);
+    const mergedEnv = mergeHermesEnv(existingEnv, input.apiKey, names.hermesEnvKey);
     const writeText = deps.writeOwnerOnlyText ?? writeOwnerOnlyText;
     await writeText(envTarget, mergedEnv);
     try {
@@ -346,11 +842,13 @@ async function writeHermesConfig(input, deps) {
       messages: [
         `Updated Haven MCP entries in ${target}; stored the hosted MCP identity in ${envTarget}.`,
         "Restart Hermes (start a new session; gateway users: /restart), then verify with `hermes mcp list`, `hermes mcp test haven`, and `hermes mcp test haven-signer`.",
+        "If several long-lived Hermes processes are running (a gateway plus TUI workers), restart EVERY one: each loads its MCP wiring at startup, so a process started before this setup keeps using its old snapshot.",
         "If no mcp_* tools appear after restart, ensure the MCP SDK is installed in Hermes: pip install mcp"
       ]
     };
   } catch (err) {
     const recoveryIncomplete = err instanceof HermesConfigRecoveryError;
+    const unreadable = err instanceof UnreadableRuntimeConfigError;
     return {
       hostedConfigured: false,
       signerConfigured: false,
@@ -359,8 +857,11 @@ async function writeHermesConfig(input, deps) {
       target: "Hermes Agent config",
       changed: false,
       restartRequired: true,
-      messages: [recoveryIncomplete ? "Could not update Hermes Agent config. Recovery did not complete; inspect the Hermes configuration before retrying." : "Could not update Hermes Agent config. Existing configuration was left unchanged."],
-      errorCode: "runtime_config_write_failed"
+      messages: unreadable ? [
+        `Could not update Hermes Agent config: ${err.message}.`,
+        `Nothing was written to ${err.configPath}. Fix the YAML there (or move the file aside), then run \`${REPAIR_COMMAND_PREFIX} hermes\` to write the Haven entries from the credentials already stored on this machine. Do not re-run the setup command: its token is already used.`
+      ] : [recoveryIncomplete ? "Could not update Hermes Agent config. Recovery did not complete; inspect the Hermes configuration before retrying." : "Could not update Hermes Agent config. Existing configuration was left unchanged."],
+      errorCode: unreadable ? "runtime_config_unreadable" : "runtime_config_write_failed"
     };
   }
 }
@@ -392,7 +893,7 @@ async function writeCodexConfig(input) {
       if (!input.localMcpCommand) {
         throw new Error("local MCP wrapper command is required");
       }
-      const merged2 = mergeCodexToml(existing ?? "", input.localMcpCommand);
+      const merged2 = mergeCodexToml(existing ?? "", input.localMcpCommand, serverNamesFor(input.serverName));
       await writeOwnerOnlyText(target, merged2);
       return {
         hostedConfigured: false,
@@ -407,7 +908,13 @@ async function writeCodexConfig(input) {
         ]
       };
     }
-    const merged = mergeCodexTomlHosted(existing ?? "", input.hostedMcpUrl, input.apiKey, resolveSignerLaunchSpec(input));
+    const merged = mergeCodexTomlHosted(
+      existing ?? "",
+      input.hostedMcpUrl,
+      input.apiKey,
+      resolveSignerLaunchSpec(input),
+      serverNamesFor(input.serverName)
+    );
     await writeOwnerOnlyText(target, merged);
     return {
       hostedConfigured: true,
@@ -449,10 +956,15 @@ async function writeOwnerOnlyText(path, value) {
   await writeFile(path, value, { mode: 384 });
   await chmod(path, 384).catch(() => void 0);
 }
-function parseJsonObject(value) {
-  const parsed = JSON.parse(value);
+function parseJsonObject(value, configPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new UnreadableRuntimeConfigError(configPath ?? "the runtime config", "it is not valid JSON");
+  }
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("runtime config must be a JSON object");
+    throw new UnreadableRuntimeConfigError(configPath ?? "the runtime config", "the top level is not a JSON object");
   }
   return parsed;
 }
@@ -719,10 +1231,11 @@ function configTargetLabel(runtime) {
       return "runtime MCP config";
   }
 }
-var HERMES_API_KEY_ENV, HermesConfigRecoveryError, InvalidCodexTomlError;
+var HERMES_API_KEY_ENV, HermesConfigRecoveryError, InvalidCodexTomlError, REPAIR_COMMAND_PREFIX, UnreadableRuntimeConfigError;
 var init_config_writers = __esm({
   "src/config-writers.ts"() {
     init_runtime_manifest();
+    init_server_names();
     HERMES_API_KEY_ENV = "MCP_HAVEN_API_KEY";
     HermesConfigRecoveryError = class extends Error {
       constructor() {
@@ -736,27 +1249,136 @@ var init_config_writers = __esm({
         this.name = "InvalidCodexTomlError";
       }
     };
+    REPAIR_COMMAND_PREFIX = "npx @haven_ai/connect@alpha --doctor --repair --runtime";
+    UnreadableRuntimeConfigError = class extends Error {
+      configPath;
+      constructor(configPath, detail) {
+        super(`${configPath} is not a config Haven can merge into (${detail})`);
+        this.name = "UnreadableRuntimeConfigError";
+        this.configPath = configPath;
+      }
+    };
   }
 });
-async function probeHostedMcpTools(apiKey, hostedMcpUrl, fetchImpl = fetch) {
-  let response;
+async function acknowledgeLocalMcpConsent(identityPath, signerPath, log) {
   try {
-    response = await fetchWithTimeout(fetchImpl, hostedMcpUrl, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json",
-        Accept: "application/json, text/event-stream"
-      },
-      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list" })
+    const input = await buildLocalMcpConsentInput(identityPath, signerPath);
+    const decision = await ensureConsent(input, {
+      credentialsPath: identityPath,
+      writeAck: true,
+      out: log ? { write: (chunk) => writeLogChunk(log, chunk) } : void 0
     });
-  } catch {
-    return { status: "network_error" };
+    return {
+      acknowledged: decision.ok,
+      hash: decision.hash,
+      reason: decision.reason
+    };
+  } catch (err) {
+    return {
+      acknowledged: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
   }
-  if (response.status === 401 || response.status === 403) return { status: "unauthorized" };
-  if (!response.ok) return { status: "bad_response" };
+}
+async function getLocalMcpConsentStatus(identityPath, signerPath) {
   try {
-    const payload = parseJsonRpcPayload(await response.text());
+    const input = await buildLocalMcpConsentInput(identityPath, signerPath);
+    const hash = computeConsentHash(input);
+    const stored = await readLocalMcpAckFile(localMcpAckPath(identityPath));
+    if (stored === hash) {
+      return { acknowledged: true, hash, reason: "ack_file_match" };
+    }
+    return {
+      acknowledged: false,
+      hash,
+      reason: stored ? "ack_file_mismatch" : "ack_file_missing"
+    };
+  } catch (err) {
+    return {
+      acknowledged: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function localMcpAckPath(identityPath) {
+  return resolve(`${identityPath}.ack.json`);
+}
+async function buildLocalMcpConsentInput(identityPath, signerPath) {
+  const credentials = await loadCredentials({ identityPath, signerPath });
+  const unavailableDuringSetup = {
+    getAllowances: async () => {
+      throw new Error("Haven approval is not complete yet.");
+    }
+  };
+  return consentInputFromClient(
+    unavailableDuringSetup,
+    {
+      apiKey: credentials.apiKey,
+      apiUrl: credentials.apiUrl,
+      agentId: credentials.agentId,
+      safeAddress: credentials.safeAddress,
+      delegateAddress: credentials.delegateAddress,
+      chainId: credentials.chainId,
+      allowanceSummary: credentials.allowanceSummary
+    },
+    registeredToolNames()
+  );
+}
+async function readLocalMcpAckFile(path) {
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    return typeof parsed.ack === "string" ? parsed.ack : null;
+  } catch {
+    return null;
+  }
+}
+function writeLogChunk(log, chunk) {
+  const message = String(chunk).trimEnd();
+  if (message) log(message);
+}
+var init_local_mcp_consent = __esm({
+  "src/local-mcp-consent.ts"() {
+  }
+});
+async function probeHostedAgentIdentity(apiKey, apiUrl, fetchImpl = fetch) {
+  let response;
+  try {
+    response = await fetchWithTimeout(fetchImpl, `${apiUrl.replace(/\/+$/, "")}/machine-payments/agent`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" }
+    });
+  } catch {
+    return { status: "network_error" };
+  }
+  if (response.status === 401 || response.status === 403) return { status: "unauthorized" };
+  if (!response.ok) return { status: "bad_response" };
+  try {
+    const payload = JSON.parse(await response.text());
+    if (typeof payload?.delegate_address !== "string") return { status: "bad_response" };
+    return { status: "ok", agentId: payload.id, delegateAddress: payload.delegate_address };
+  } catch {
+    return { status: "bad_response" };
+  }
+}
+async function probeHostedMcpTools(apiKey, hostedMcpUrl, fetchImpl = fetch) {
+  let response;
+  try {
+    response = await fetchWithTimeout(fetchImpl, hostedMcpUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream"
+      },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list" })
+    });
+  } catch {
+    return { status: "network_error" };
+  }
+  if (response.status === 401 || response.status === 403) return { status: "unauthorized" };
+  if (!response.ok) return { status: "bad_response" };
+  try {
+    const payload = parseJsonRpcPayload(await response.text());
     if (!payload || payload.error) return { status: "bad_response" };
     const tools = payload.result?.tools;
     return { status: "ok", toolCount: Array.isArray(tools) ? tools.length : void 0 };
@@ -775,7 +1397,7 @@ async function probeLocalSignerCredential(signerPath) {
   }
 }
 async function probeLocalMcpTools(command, args, requiredTools, timeoutMs = 1e4) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const child = spawn(command, args, { stdio: ["pipe", "pipe", "ignore"] });
     let stdout = "";
     let settled = false;
@@ -787,7 +1409,7 @@ async function probeLocalMcpTools(command, args, requiredTools, timeoutMs = 1e4)
       settled = true;
       clearTimeout(timeout);
       child.kill();
-      resolve8(result);
+      resolve9(result);
     };
     const timeout = setTimeout(() => finish({ status: "timeout" }), timeoutMs);
     child.on("error", () => finish({ status: "process_error" }));
@@ -901,7 +1523,8 @@ async function prepareSignerRuntime(input, deps = {}) {
     wrapperPath,
     runtimeDirectory,
     npmCacheDirectory,
-    cliPath
+    cliPath,
+    serverName: input.serverName
   });
   messages.push(`Prepared stable local Haven signer wrapper: ${wrapperPath}`);
   return {
@@ -1002,6 +1625,7 @@ async function readRuntimeSidecar(credentialDirectory) {
 }
 async function writeRuntimeSidecar(input) {
   const value = {
+    ...input.serverName ? { server_name: input.serverName } : {},
     signer_package: MCP_RUNTIME_MANIFEST.signerPackage,
     signer_version: MCP_RUNTIME_MANIFEST.signerVersion,
     sdk_package: MCP_RUNTIME_MANIFEST.sdkPackage,
@@ -1031,61 +1655,391 @@ var init_signer_runtime = __esm({
     SIGNER_INSTALL_HEARTBEAT_MS = 15e3;
   }
 });
-
-// src/runtime-registry.ts
-function runtimeProfile(runtime, env = process.env) {
-  return RUNTIME_PROFILES[normalizeRuntime(runtime, env)];
+async function prepareLocalMcpRuntime(input, deps = {}) {
+  assertSupportedNodeVersion(input.nodeVersion);
+  const homeDir = input.homeDir ?? homedir();
+  const runtimeDirectory = resolve(homeDir, ".haven", "mcp-runtime", MCP_RUNTIME_MANIFEST.mcpVersion);
+  const npmCacheDirectory = resolve(homeDir, ".haven", "npm-cache");
+  const cliPath = join(runtimeDirectory, "node_modules", "@haven_ai", "mcp", "dist", "cli.js");
+  const messages = [];
+  await mkdir(runtimeDirectory, { recursive: true, mode: 448 });
+  await chmod(runtimeDirectory, 448).catch(() => void 0);
+  await mkdir(npmCacheDirectory, { recursive: true, mode: 448 });
+  await chmod(npmCacheDirectory, 448).catch(() => void 0);
+  if (await installedRuntimeMatches2(runtimeDirectory, cliPath)) {
+    messages.push(`Using existing local Haven MCP runtime ${mcpPackageSpec()}.`);
+  } else {
+    await installRuntimePackages2(runtimeDirectory, npmCacheDirectory, deps);
+    messages.push(`Installed local Haven MCP runtime ${mcpPackageSpec()}.`);
+  }
+  await assertFileExists2(cliPath, "local Haven MCP CLI");
+  const wrapperPath = join(input.credentialDirectory, "bin", "haven-mcp");
+  await writeWrapper2({
+    wrapperPath,
+    cliPath,
+    identityPath: input.identityPath,
+    signerPath: input.signerPath
+  });
+  await writeRuntimeSidecar2({
+    path: join(input.credentialDirectory, "mcp-runtime.json"),
+    wrapperPath,
+    runtimeDirectory,
+    npmCacheDirectory,
+    cliPath,
+    serverName: input.serverName
+  });
+  messages.push(`Prepared stable local Haven MCP wrapper: ${wrapperPath}`);
+  return {
+    command: wrapperPath,
+    args: [],
+    wrapperPath,
+    runtimeDirectory,
+    npmCacheDirectory,
+    cliPath,
+    messages
+  };
 }
-function normalizeRuntime(runtime, env = process.env) {
-  const explicit = normalizeRuntimeName(runtime);
-  if (explicit) return explicit;
-  return detectRuntime(env) ?? "other";
+function assertSupportedNodeVersion(nodeVersion = process.versions.node, minimumNodeVersion = MCP_RUNTIME_MANIFEST.minimumNodeVersion, subject = "Haven setup") {
+  if (!isSupportedNodeVersion(nodeVersion, minimumNodeVersion)) {
+    throw new UnsupportedNodeVersionError(nodeVersion, minimumNodeVersion, subject);
+  }
 }
-function restartRequiredForRuntime(runtime, env = process.env) {
-  const mode = runtimeProfile(runtime, env).restartMode;
-  return mode === "restart-session" || mode === "restart-app";
+async function installRuntimePackages2(runtimeDirectory, npmCacheDirectory, deps) {
+  const { runCommand, onProgress } = deps;
+  const baseArgs = [
+    "install",
+    "--prefix",
+    runtimeDirectory,
+    "--no-audit",
+    "--no-fund",
+    "--omit=dev",
+    "--prefer-offline",
+    mcpPackageSpec(),
+    sdkPackageSpec()
+  ];
+  const run = async (args) => {
+    const startedAt = Date.now();
+    const heartbeat = setInterval(() => {
+      const seconds = Math.round((Date.now() - startedAt) / 1e3);
+      onProgress?.(`Still installing the local Haven MCP runtime\u2026 (${seconds}s \u2014 a cold cache can take several minutes)`);
+    }, SIGNER_INSTALL_HEARTBEAT_MS);
+    heartbeat.unref?.();
+    try {
+      if (runCommand) await runCommand("npm", args);
+      else await execFileAsync2("npm", args, { timeout: SIGNER_INSTALL_TIMEOUT_MS, maxBuffer: 1024 * 1024 });
+    } finally {
+      clearInterval(heartbeat);
+    }
+  };
+  try {
+    await run(baseArgs);
+  } catch {
+    try {
+      await run([...baseArgs, "--cache", npmCacheDirectory]);
+    } catch (err) {
+      throw new Error(`Could not install local Haven MCP runtime ${mcpPackageSpec()}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
 }
-function runtimeVerificationInstruction(runtime) {
-  const label = RUNTIME_PROFILES[runtime].label;
-  return `In ${label}, run the read-only \`haven_get_agent\` and \`haven_get_allowances\` tools to confirm the Haven wallet and live budget. Do not sign, fund, or create a payment to verify setup.`;
+async function installedRuntimeMatches2(runtimeDirectory, cliPath) {
+  try {
+    await assertFileExists2(cliPath, "local Haven MCP CLI");
+    const [mcpPackage, sdkPackage] = await Promise.all([
+      readPackageJson2(join(runtimeDirectory, "node_modules", "@haven_ai", "mcp", "package.json")),
+      readPackageJson2(join(runtimeDirectory, "node_modules", "@haven_ai", "sdk", "package.json"))
+    ]);
+    return mcpPackage.version === MCP_RUNTIME_MANIFEST.mcpVersion && sdkPackage.version === MCP_RUNTIME_MANIFEST.sdkVersion;
+  } catch {
+    return false;
+  }
 }
-function normalizeRuntimeName(runtime) {
-  const key = runtime?.trim().toLowerCase();
-  if (!key) return null;
-  return RUNTIME_ALIASES[key.replace(/\s+/g, "-")] ?? null;
+async function readPackageJson2(path) {
+  return JSON.parse(await readFile(path, "utf8"));
 }
-function detectRuntime(env) {
-  if (env.CLAUDECODE || env.CLAUDE_CODE || env.CLAUDECODE_CWD) return "claude-code";
-  if (env.CODEX_SANDBOX || env.CODEX_HOME || env.CODEX_CWD) return "codex-cli";
-  if (env.VSCODE_CWD || env.VSCODE_IPC_HOOK_CLI || env.TERM_PROGRAM === "vscode") return "vscode";
-  if (env.HERMES_HOME || env.HERMES_AGENT) return "hermes";
-  return null;
+async function writeWrapper2(input) {
+  await mkdir(dirname(input.wrapperPath), { recursive: true, mode: 448 });
+  await chmod(dirname(input.wrapperPath), 448).catch(() => void 0);
+  const source = [
+    "#!/usr/bin/env node",
+    "import { spawn } from 'node:child_process'",
+    "",
+    `const cliPath = ${JSON.stringify(input.cliPath)}`,
+    `const identityPath = ${JSON.stringify(input.identityPath)}`,
+    `const signerPath = ${JSON.stringify(input.signerPath)}`,
+    "",
+    "const child = spawn(process.execPath, [cliPath, '--identity', identityPath, '--signer', signerPath, ...process.argv.slice(2)], {",
+    "  stdio: 'inherit',",
+    "})",
+    "",
+    "child.on('exit', (code, signal) => {",
+    "  if (signal) process.kill(process.pid, signal)",
+    "  else process.exit(code ?? 1)",
+    "})",
+    ""
+  ].join("\n");
+  await writeFile(input.wrapperPath, source, { mode: 448 });
+  await chmod(input.wrapperPath, 448).catch(() => void 0);
 }
-var RUNTIME_PROFILES, RUNTIME_ALIASES;
-var init_runtime_registry = __esm({
-  "src/runtime-registry.ts"() {
-    RUNTIME_PROFILES = {
-      "claude-code": {
-        id: "claude-code",
-        label: "Claude Code",
-        restartMode: "restart-session",
-        canWriteRuntimeConfig: true,
-        activationInstruction: "Start a new Claude Code session so it loads the Haven MCP entries."
-      },
-      "codex-cli": {
-        id: "codex-cli",
-        label: "Codex CLI",
-        restartMode: "restart-session",
-        canWriteRuntimeConfig: true,
-        activationInstruction: "Start a fresh Codex CLI session (for example, run `codex resume --last`)."
-      },
-      "codex-desktop": {
-        id: "codex-desktop",
-        label: "Codex Desktop",
-        restartMode: "restart-session",
-        canWriteRuntimeConfig: true,
-        activationInstruction: "Quit and reopen Codex Desktop so it loads the Haven MCP entries."
-      },
+async function writeRuntimeSidecar2(input) {
+  const value = {
+    ...input.serverName ? { server_name: input.serverName } : {},
+    mcp_package: MCP_RUNTIME_MANIFEST.mcpPackage,
+    mcp_version: MCP_RUNTIME_MANIFEST.mcpVersion,
+    sdk_package: MCP_RUNTIME_MANIFEST.sdkPackage,
+    sdk_version: MCP_RUNTIME_MANIFEST.sdkVersion,
+    minimum_node_version: MCP_RUNTIME_MANIFEST.minimumNodeVersion,
+    wrapper_path: input.wrapperPath,
+    runtime_directory: input.runtimeDirectory,
+    npm_cache_directory: input.npmCacheDirectory,
+    cli_path: input.cliPath
+  };
+  await writeFile(input.path, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  await chmod(input.path, 384).catch(() => void 0);
+}
+async function assertFileExists2(path, label) {
+  try {
+    await access(path);
+  } catch {
+    throw new Error(`Missing ${label}: ${path}`);
+  }
+}
+var execFileAsync2, UnsupportedNodeVersionError;
+var init_local_mcp_runtime = __esm({
+  "src/local-mcp-runtime.ts"() {
+    init_signer_runtime();
+    init_runtime_manifest();
+    execFileAsync2 = promisify(execFile);
+    UnsupportedNodeVersionError = class extends Error {
+      code = "local_mcp_unsupported_node_version";
+      nodeVersion;
+      minimumNodeVersion;
+      constructor(nodeVersion, minimumNodeVersion, subject = "Haven setup") {
+        super(unsupportedNodeVersionMessage({ subject, nodeVersion, minimumNodeVersion }));
+        this.name = "UnsupportedNodeVersionError";
+        this.nodeVersion = nodeVersion;
+        this.minimumNodeVersion = minimumNodeVersion;
+      }
+    };
+  }
+});
+async function installSkillForRuntime(runtime, deps = {}) {
+  switch (runtime) {
+    case "claude-code":
+      return installSkillFile(
+        resolve(deps.homeDir ?? homedir(), ".claude", "skills", SKILL_FOLDER_NAME),
+        "~/.claude/skills/haven-pay"
+      );
+    case "hermes":
+      return installSkillFile(
+        join(hermesHome(deps), "skills", SKILL_FOLDER_NAME),
+        "the Hermes skills folder"
+      );
+    case "codex-cli":
+    case "codex-desktop":
+      return installCodexAgentsSection(deps);
+    default:
+      return void 0;
+  }
+}
+async function installSkillFile(skillDir, label) {
+  try {
+    await mkdir(skillDir, { recursive: true });
+    const target = join(skillDir, "SKILL.md");
+    await writeFile(target, HAVEN_SKILL_MD, "utf8");
+    return {
+      installed: true,
+      target,
+      messages: [`Installed the generic Haven payment skill (${label}). It contains no secrets.`]
+    };
+  } catch (err) {
+    return {
+      installed: false,
+      messages: [
+        `Could not install the Haven payment skill: ${err instanceof Error ? err.message : String(err)}. Download it from the Haven dashboard instead.`
+      ]
+    };
+  }
+}
+async function installCodexAgentsSection(deps) {
+  try {
+    const codexDir = resolve(deps.homeDir ?? homedir(), ".codex");
+    const target = join(codexDir, "AGENTS.md");
+    await mkdir(codexDir, { recursive: true });
+    const existing = await readFile(target, "utf8").catch(() => null);
+    const next = upsertManagedSection(existing, codexManagedSection());
+    if (next !== existing) {
+      await writeFile(target, next, "utf8");
+    }
+    return {
+      installed: true,
+      target,
+      messages: [
+        "Installed the generic Haven payment guidance as a managed section in ~/.codex/AGENTS.md (Codex reads it as global instructions). It contains no secrets; your own content in that file is untouched."
+      ]
+    };
+  } catch (err) {
+    return {
+      installed: false,
+      messages: [
+        `Could not install the Haven payment guidance into ~/.codex/AGENTS.md: ${err instanceof Error ? err.message : String(err)}. Download the skill from the Haven dashboard instead.`
+      ]
+    };
+  }
+}
+function codexManagedSection() {
+  return `${CODEX_AGENTS_BEGIN_MARKER}
+
+${HAVEN_SKILL_BODY_MD.trimEnd()}
+
+${CODEX_AGENTS_END_MARKER}
+`;
+}
+function upsertManagedSection(existing, section) {
+  if (existing === null || existing.trim() === "") return section;
+  const begins = markerLineIndexes(existing, CODEX_AGENTS_BEGIN_MARKER);
+  const ends = markerLineIndexes(existing, CODEX_AGENTS_END_MARKER);
+  if (begins.length === 1 && ends.length === 1 && ends[0] > begins[0]) {
+    const afterEnd = ends[0] + CODEX_AGENTS_END_MARKER.length;
+    const tail = existing.startsWith("\r\n", afterEnd) ? existing.slice(afterEnd + 2) : existing.startsWith("\n", afterEnd) ? existing.slice(afterEnd + 1) : existing.slice(afterEnd);
+    return existing.slice(0, begins[0]) + section + tail;
+  }
+  if (begins.length > 0 || ends.length > 0) {
+    throw new Error(
+      "found a damaged Haven marker section (orphaned or duplicated markers); remove the leftover marker lines and re-run setup"
+    );
+  }
+  return `${existing.replace(/\n*$/, "\n\n")}${section}`;
+}
+function markerLineIndexes(text, marker) {
+  const indexes = [];
+  for (let from = 0; ; ) {
+    const at = text.indexOf(marker, from);
+    if (at === -1) return indexes;
+    if (at === 0 || text[at - 1] === "\n") indexes.push(at);
+    from = at + marker.length;
+  }
+}
+function hermesHome(deps) {
+  const env = deps.env ?? process.env;
+  return env.HERMES_HOME ?? join(deps.homeDir ?? homedir(), ".hermes");
+}
+var CODEX_AGENTS_BEGIN_MARKER, CODEX_AGENTS_END_MARKER;
+var init_skill_install = __esm({
+  "src/skill-install.ts"() {
+    CODEX_AGENTS_BEGIN_MARKER = "<!-- BEGIN haven-pay (managed by @haven_ai/connect; edits inside this section are overwritten on re-setup) -->";
+    CODEX_AGENTS_END_MARKER = "<!-- END haven-pay -->";
+  }
+});
+
+// src/connect-error.ts
+var ConnectError;
+var init_connect_error = __esm({
+  "src/connect-error.ts"() {
+    ConnectError = class extends Error {
+      code;
+      nextAction;
+      constructor(code, message, nextAction2) {
+        super(message);
+        this.name = "ConnectError";
+        this.code = code;
+        this.nextAction = nextAction2;
+      }
+    };
+  }
+});
+
+// src/runtime-registry.ts
+function runtimeProfile(runtime, env = process.env) {
+  return RUNTIME_PROFILES[normalizeRuntime(runtime, env)];
+}
+function normalizeRuntime(runtime, env = process.env) {
+  const explicit = normalizeRuntimeName(runtime);
+  if (explicit) return explicit;
+  return detectRuntime(env) ?? "other";
+}
+async function resolveRuntimeSelection(explicit, force, options = {}) {
+  const env = options.env ?? process.env;
+  if (force !== void 0) {
+    const forced = normalizeRuntimeName(force);
+    if (!forced) {
+      throw new ConnectError(
+        "runtime_force_unrecognized",
+        `Unknown --runtime-force value "${force}". Valid values: ${RUNTIME_FLAG_VALUES}.`,
+        "rerun_connect_with_a_valid_runtime_name"
+      );
+    }
+    return { runtime: forced, source: "force" };
+  }
+  const detected = detectRuntime(env);
+  const supplied = explicit?.trim() || options.selfReported?.trim() || void 0;
+  const hint = normalizeRuntimeName(supplied);
+  if (supplied && !hint) {
+    if (!detected) {
+      throw new ConnectError(
+        "runtime_unrecognized",
+        `"${supplied}" is not an agent runtime Haven knows. Valid values: ${RUNTIME_FLAG_VALUES} (the aliases cowork, codex and openclaw are accepted too). Re-run with one of those, or --runtime other to store credentials and finish the MCP setup by hand. Nothing was written and the Haven setup token is still unused.`,
+        "rerun_connect_with_a_valid_runtime_name"
+      );
+    }
+    return { runtime: detected, source: "detected", discardedHint: supplied };
+  }
+  if (detected && hint && detected !== hint) {
+    return { runtime: detected, source: "detected", overrodeHint: hint };
+  }
+  if (hint) return { runtime: hint, source: "explicit" };
+  if (detected) return { runtime: detected, source: "detected" };
+  if (options.promptForRuntime) {
+    return { runtime: await options.promptForRuntime(), source: "prompted" };
+  }
+  return { runtime: null, source: "none" };
+}
+function restartRequiredForRuntime(runtime, env = process.env) {
+  const mode = runtimeProfile(runtime, env).restartMode;
+  return mode === "restart-session" || mode === "restart-app";
+}
+function runtimeVerificationInstruction(runtime) {
+  const label = RUNTIME_PROFILES[runtime].label;
+  return `In ${label}, run the read-only \`haven_get_agent\` and \`haven_get_allowances\` tools to confirm the Haven wallet and live budget. Do not sign, fund, or create a payment to verify setup.`;
+}
+function normalizeRuntimeName(runtime) {
+  const key = runtime?.trim().toLowerCase();
+  if (!key) return null;
+  return RUNTIME_ALIASES[key.replace(/\s+/g, "-")] ?? null;
+}
+function detectRuntime(env) {
+  if (env.CLAUDECODE || env.CLAUDE_CODE || env.CLAUDECODE_CWD) return "claude-code";
+  if (env.CODEX_SANDBOX || env.CODEX_HOME || env.CODEX_CWD) return "codex-cli";
+  if (env.VSCODE_CWD || env.VSCODE_IPC_HOOK_CLI || env.TERM_PROGRAM === "vscode") return "vscode";
+  if (env.HERMES_HOME || env.HERMES_AGENT) return "hermes";
+  return null;
+}
+var RUNTIME_PROFILES, RUNTIME_ALIASES, RUNTIME_FLAG_VALUES;
+var init_runtime_registry = __esm({
+  "src/runtime-registry.ts"() {
+    init_connect_error();
+    RUNTIME_PROFILES = {
+      "claude-code": {
+        id: "claude-code",
+        label: "Claude Code",
+        restartMode: "restart-session",
+        canWriteRuntimeConfig: true,
+        activationInstruction: "Start a new Claude Code session so it loads the Haven MCP entries."
+      },
+      "codex-cli": {
+        id: "codex-cli",
+        label: "Codex CLI",
+        restartMode: "restart-session",
+        canWriteRuntimeConfig: true,
+        activationInstruction: "Start a fresh Codex CLI session (for example, run `codex resume --last`)."
+      },
+      "codex-desktop": {
+        id: "codex-desktop",
+        label: "Codex Desktop",
+        restartMode: "restart-session",
+        canWriteRuntimeConfig: true,
+        activationInstruction: "Quit and reopen Codex Desktop so it loads the Haven MCP entries."
+      },
       cursor: {
         id: "cursor",
         label: "Cursor",
@@ -1134,6 +2088,11 @@ var init_runtime_registry = __esm({
       "claude-code": "claude-code",
       claudecode: "claude-code",
       "claude_code": "claude-code",
+      // #1682: Cowork runs Claude Code's config, so it resolves to the same
+      // profile. The dashboard's command carries no --runtime for it (it is a
+      // detected, command-path runtime), but an explicit `--runtime cowork` typed
+      // by hand must not fall through to the no-runtime refusal.
+      cowork: "claude-code",
       codex: "codex-cli",
       "codex-cli": "codex-cli",
       codexcli: "codex-cli",
@@ -1163,9 +2122,18 @@ var init_runtime_registry = __esm({
       "hermes-agent": "hermes",
       hermes_agent: "hermes",
       hermesagent: "hermes",
+      // #1682: OpenClaw is a SNIPPET target — the user pastes an mcpServers entry
+      // into ~/.openclaw/openclaw.json and restarts the gateway. That is exactly
+      // the 'other' profile's behaviour (credentials written to disk, no config
+      // auto-written, manual finish), so it resolves there rather than earning a
+      // profile whose only distinguishing feature would be its label.
+      openclaw: "other",
+      "open-claw": "other",
+      "open_claw": "other",
       other: "other",
       manual: "other"
     };
+    RUNTIME_FLAG_VALUES = "claude-code, codex-cli, codex-desktop, cursor, vscode, vscode-insiders, claude-desktop, hermes, other";
   }
 });
 async function acknowledgeLocalSignerConsent(signerPath, log) {
@@ -1241,1254 +2209,1494 @@ var init_signer_consent = __esm({
   "src/signer-consent.ts"() {
   }
 });
-
-// src/doctor.ts
-var doctor_exports = {};
-__export(doctor_exports, {
-  runDoctor: () => runDoctor,
-  runRepair: () => runRepair
-});
-async function discoverCredentialDirectory(homeDir, explicit) {
-  if (explicit) return { directory: explicit };
-  const root = join(homeDir, ".haven", "agents");
-  let entries = [];
-  try {
-    entries = await readdir(root);
-  } catch {
-    return {};
+async function installRuntime(input, deps = {}) {
+  const runtime = normalizeRuntime(input.runtime, deps.env);
+  const profile = runtimeProfile(runtime, deps.env);
+  const progress = deps.onProgress ?? (() => void 0);
+  const localRuntime = input.localMcp === true && supportsLocalMcp(runtime);
+  const consentMessages = [];
+  const localMcpConsent = localRuntime ? await resolveLocalMcpConsent(input, consentMessages) : void 0;
+  const signerConsent = localRuntime ? void 0 : await resolveSignerConsent(input, consentMessages);
+  if (runtime === "other") {
+    const signerCredentialReady2 = await probeLocalSignerCredential(input.signerPath);
+    const signerReady = signerCredentialReady2 && signerConsent?.acknowledged;
+    return {
+      runtime,
+      runtimeMcpMode: "manual",
+      hostedMcpConfigured: false,
+      localSignerConfigured: false,
+      localMcpConfigured: false,
+      probeResult: signerReady ? "manual_runtime_setup_required_local_signer_ready" : "manual_runtime_setup_required_local_signer_unavailable",
+      restartRequired: true,
+      nextUserAction: "return_to_haven_for_wallet_approval_then_configure_runtime",
+      errorCode: "manual_runtime_setup_required",
+      configTarget: "manual runtime setup",
+      signerAcknowledged: signerConsent?.acknowledged,
+      localMcpAcknowledged: false,
+      messages: [
+        ...consentMessages,
+        "Custom runtime: Haven did not auto-configure it. Your credentials are on disk (chmod 600) \u2014 read them at runtime; never paste a key into the agent prompt, memory, or logs.",
+        `  identity (hosted MCP Bearer): ${input.identityPath}`,
+        `  signer (local signing key):   ${input.signerPath}`,
+        "After wallet approval, wire the runtime to Haven by reference:",
+        `  Hosted MCP + local signer: point your MCP client at ${input.hostedMcpUrl} with the api_key from identity.json, then run  npx -y ${signerPackageSpec()} --credentials ${input.signerPath}`,
+        `  Fully local MCP (no hosted dependency):  npx -y ${mcpPackageSpec()} --identity ${input.identityPath} --signer ${input.signerPath}`
+      ]
+    };
   }
-  const candidates = [];
-  for (const entry of entries) {
-    const directory = join(root, entry);
+  let localRuntimeInstall;
+  let localRuntimeError;
+  if (localRuntime) {
     try {
-      const s = await stat(join(directory, "identity.json"));
-      candidates.push({ directory, mtimeMs: s.mtimeMs });
-    } catch {
-    }
-  }
-  if (candidates.length === 0) return {};
-  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  return {
-    directory: candidates[0].directory,
-    note: candidates.length > 1 ? `${candidates.length} agent credential dirs found; examining the newest.` : void 0
-  };
-}
-async function runDoctor(input, deps = {}) {
-  const homeDir = deps.homeDir ?? homedir();
-  const checks = [];
-  let signerCapabilities;
-  const { directory, note } = await discoverCredentialDirectory(homeDir, input.credentialsDir);
-  let identity;
-  let signerParses = false;
-  if (!directory) {
-    checks.push({
-      id: "credentials",
-      label: "Agent credentials",
-      ok: false,
-      detail: "No agent credential directory with an identity.json under ~/.haven/agents.",
-      repair: `Run the full setup once: ${RERUN} --setup <token from the Haven dashboard>.`
-    });
-  } else {
-    try {
-      identity = JSON.parse(await readFile(join(directory, "identity.json"), "utf8"));
-    } catch {
-      identity = void 0;
-    }
-    try {
-      const signer = JSON.parse(await readFile(join(directory, "signer.json"), "utf8"));
-      signerParses = typeof signer === "object" && signer !== null;
-    } catch {
-      signerParses = false;
-    }
-    const ok = Boolean(identity?.api_key) && signerParses;
-    checks.push({
-      id: "credentials",
-      label: "Agent credentials",
-      ok,
-      detail: ok ? `identity.json and signer.json parse (agent ${identity?.agent_id ?? "unknown"})${note ? ` \u2014 ${note}` : ""}` : "identity.json or signer.json is missing or unparseable.",
-      ...ok ? {} : { repair: `Re-run the full setup with a fresh token: ${RERUN} --setup <token>.` }
-    });
-  }
-  let sidecar = null;
-  if (directory) {
-    sidecar = await readRuntimeSidecar(directory);
-    if (!sidecar) {
-      checks.push({
-        id: "signer_runtime",
-        label: "Signer runtime (preinstalled wrapper)",
-        ok: false,
-        detail: "No signer-runtime.json sidecar \u2014 the pinned signer runtime was never prepared (or a pre-#1586 npx config).",
-        repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}`
-      });
-    } else {
-      const matches = await installedRuntimeMatches(sidecar.runtime_directory, sidecar.cli_path);
-      const versionOk = sidecar.signer_version === MCP_RUNTIME_MANIFEST.signerVersion;
-      const ok = matches && versionOk;
-      checks.push({
-        id: "signer_runtime",
-        label: "Signer runtime (preinstalled wrapper)",
-        ok,
-        detail: ok ? `Installed ${sidecar.signer_package}@${sidecar.signer_version} at ${sidecar.runtime_directory}` : matches ? `Installed version ${sidecar.signer_version} does not match the connector's pinned ${MCP_RUNTIME_MANIFEST.signerVersion}.` : `Runtime directory is stale or empty (${sidecar.runtime_directory}) \u2014 the CLI or package versions are missing.`,
-        ...ok ? {} : { repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}` }
-      });
-    }
-  }
-  const configPath = runtimeConfigPathFor(input.runtime, homeDir);
-  if (configPath === null) {
-    checks.push({
-      id: "runtime_config",
-      label: "Runtime MCP config",
-      ok: true,
-      detail: `Runtime '${input.runtime}' has no file-based config the connector owns (CLI-managed) \u2014 skipping the file check.`
-    });
-  } else {
-    let configText = null;
-    try {
-      configText = await readFile(configPath, "utf8");
-    } catch {
-      configText = null;
-    }
-    if (configText === null) {
-      checks.push({
-        id: "runtime_config",
-        label: "Runtime MCP config",
-        ok: false,
-        detail: `No runtime config at ${configPath}.`,
-        repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}`
-      });
-    } else {
-      const hasHaven = identity?.hosted_mcp_url ? configText.includes(identity.hosted_mcp_url) : configText.includes("haven");
-      const signerViaNpx = configText.includes("@haven_ai/signer");
-      const wrapperReferenced = sidecar ? configText.includes(sidecar.wrapper_path) : false;
-      const ok = hasHaven && !signerViaNpx && (sidecar ? wrapperReferenced : true);
-      checks.push({
-        id: "runtime_config",
-        label: "Runtime MCP config",
-        ok,
-        detail: ok ? `Config at ${configPath} references the hosted server and the prepared signer wrapper.` : signerViaNpx ? `Config at ${configPath} still launches the signer via npx \u2014 the pre-#1586 shape that cannot start under a 120s startup timeout.` : `Config at ${configPath} is missing the Haven entries${sidecar && !wrapperReferenced ? " (or references a different signer wrapper)" : ""}.`,
-        ...ok ? {} : { repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}` }
-      });
-    }
-  }
-  if (identity?.api_key && (identity.hosted_mcp_url || identity.api_url)) {
-    const hostedUrl = identity.hosted_mcp_url ?? `${identity.api_url}/mcp`;
-    const probe = await (deps.probeHosted ?? probeHostedMcpTools)(identity.api_key, hostedUrl, deps.fetch);
-    checks.push({
-      id: "hosted_mcp",
-      label: "Hosted Haven MCP",
-      ok: probe.status === "ok",
-      detail: probe.status === "ok" ? `Reachable and authorized (${hostedUrl}).` : `Probe failed: ${probe.status} (${hostedUrl}).`,
-      ...probe.status === "ok" ? {} : {
-        repair: probe.status === "unauthorized" ? `The stored API key was rejected \u2014 re-run the full setup with a fresh token: ${RERUN} --setup <token>.` : "Check network access to the hosted MCP URL, then re-run --doctor."
-      }
-    });
-  } else {
-    checks.push({
-      id: "hosted_mcp",
-      label: "Hosted Haven MCP",
-      ok: false,
-      detail: "No stored API key / hosted MCP URL to probe with.",
-      repair: `Re-run the full setup: ${RERUN} --setup <token>.`
-    });
-  }
-  if (sidecar && directory) {
-    const consent = await getLocalSignerConsentStatus(join(directory, "signer.json"));
-    if (!consent.acknowledged) {
-      checks.push({
-        id: "signer_process",
-        label: "Signer stdio handshake",
-        ok: false,
-        detail: "The local-tools consent is not acknowledged, so the signer refuses to start (by design).",
-        repair: `Run: ${RERUN} --ack-local-tools --setup <token>  (or re-run your original setup command with --ack-local-tools).`
-      });
-    } else {
-      const probe = await (deps.probeSignerTools ?? probeLocalMcpTools)(
-        sidecar.wrapper_path,
-        [],
-        MCP_RUNTIME_MANIFEST.requiredSignerTools
-      );
-      const experimental = probe.capabilities?.experimental ?? probe.capabilities;
-      const compat = experimental?.["haven/signer-compatibility"];
-      signerCapabilities = compat ? { "haven/signer-compatibility": compat } : void 0;
-      const compatDetail = compat ? ` Compat: x402 expected-context v${JSON.stringify(compat.x402_expected_context_versions ?? "?")}.` : "";
-      checks.push({
-        id: "signer_process",
-        label: "Signer stdio handshake",
-        ok: probe.status === "ok",
-        detail: probe.status === "ok" ? `Signer started, listed ${probe.toolNames?.length ?? 0} tools${probe.serverInfo?.version ? ` (v${probe.serverInfo.version})` : ""}.${compatDetail}` : `Handshake failed: ${probe.status}.`,
-        ...probe.status === "ok" ? {} : { repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}` }
-      });
+      localRuntimeInstall = await prepareRuntimeForLocalMcp(input, deps);
+    } catch (err) {
+      localRuntimeError = err;
     }
-  } else if (directory) {
-    checks.push({
-      id: "signer_process",
-      label: "Signer stdio handshake",
-      ok: false,
-      detail: "Skipped \u2014 no prepared signer runtime to probe.",
-      repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}`
-    });
   }
-  const restart = restartRequiredForRuntime(input.runtime, deps.env);
-  checks.push({
-    id: "restart",
-    label: "Runtime restart",
-    ok: true,
-    detail: restart ? "This runtime loads MCP config at startup \u2014 restart it after any repair before expecting the tools to appear." : "No restart requirement known for this runtime."
-  });
-  return {
-    version: 1,
-    ok: checks.every((check) => check.ok),
-    runtime: input.runtime,
-    credentialDirectory: directory,
-    checks,
-    ...signerCapabilities ? { signerCapabilities } : {}
-  };
-}
-async function runRepair(input, deps = {}) {
-  const homeDir = deps.homeDir ?? homedir();
-  const messages = [];
-  const { directory, note } = await discoverCredentialDirectory(homeDir, input.credentialsDir);
-  if (note) messages.push(`Note: ${note}`);
-  if (!directory) {
+  if (localRuntimeError) {
+    const errorCode2 = localRuntimePrepareErrorCode(localRuntimeError);
     return {
-      ok: false,
-      messages: [`No agent credentials found to repair \u2014 run the full setup: ${RERUN} --setup <token>.`]
+      runtime,
+      runtimeMcpMode: "local_stdio",
+      hostedMcpConfigured: false,
+      localSignerConfigured: false,
+      localMcpConfigured: false,
+      probeResult: errorCode2 === "local_mcp_unsupported_node_version" ? "local_stdio_mcp_unsupported_node_version" : "local_stdio_mcp_runtime_install_failed",
+      restartRequired: true,
+      nextUserAction: nextAction(runtime, profile.restartMode, errorCode2),
+      errorCode: errorCode2,
+      configTarget: profile.label,
+      signerAcknowledged: signerConsent?.acknowledged,
+      localMcpAcknowledged: localMcpConsent?.acknowledged,
+      activationCommand: void 0,
+      messages: [
+        ...consentMessages,
+        `Could not prepare local Haven MCP runtime: ${localRuntimeError instanceof Error ? localRuntimeError.message : String(localRuntimeError)}`
+      ]
     };
   }
-  let identity;
-  try {
-    identity = JSON.parse(await readFile(join(directory, "identity.json"), "utf8"));
-  } catch {
-    return { ok: false, messages: ["identity.json is unreadable \u2014 re-run the full setup with a fresh token."] };
-  }
-  if (!identity.api_key || !(identity.hosted_mcp_url || identity.api_url)) {
-    return { ok: false, messages: ["identity.json lacks the stored API key / hosted URL \u2014 re-run the full setup."] };
-  }
-  const configPath = runtimeConfigPathFor(input.runtime, homeDir);
-  if (configPath) {
+  let signerCommand;
+  if (!localRuntime) {
+    progress("Getting the signer ready\u2026");
     try {
-      const existing = await readFile(configPath, "utf8");
-      if (existing.includes("bin/haven-mcp") || existing.includes(".haven/mcp-runtime")) {
-        return {
-          ok: false,
-          messages: [
-            `The config at ${configPath} is the LOCAL-stdio topology (--local). Repair currently rewrites only the hosted+signer shape and will not touch it.`,
-            "Re-run your original setup command (with --local) to repair a local-stdio install."
-          ]
-        };
-      }
-    } catch {
+      const signerRuntime = await prepareSignerForRuntime(input, deps);
+      signerCommand = { command: signerRuntime.command, args: signerRuntime.args };
+      consentMessages.push(...signerRuntime.messages);
+    } catch (err) {
+      return {
+        runtime,
+        runtimeMcpMode: "hosted_plus_signer",
+        hostedMcpConfigured: false,
+        localSignerConfigured: false,
+        localMcpConfigured: false,
+        probeResult: "signer_runtime_install_failed",
+        restartRequired: false,
+        nextUserAction: "The local Haven signer runtime could not be installed, so no configuration was written. Check your network (a cold install downloads the signer package set) and re-run: npx @haven_ai/connect@alpha",
+        errorCode: "signer_runtime_install_failed",
+        configTarget: profile.label,
+        signerAcknowledged: signerConsent?.acknowledged,
+        localMcpAcknowledged: localMcpConsent?.acknowledged,
+        activationCommand: void 0,
+        signerRuntimePrepared: false,
+        messages: [
+          ...consentMessages,
+          `Could not pre-install the local Haven signer: ${err instanceof Error ? err.message : String(err)}`,
+          "No runtime configuration was written (fail-closed): a config pointing at an uninstalled signer looks wired but cannot start.",
+          "Re-run `npx @haven_ai/connect@alpha` to retry the setup."
+        ]
+      };
     }
   }
-  const signerPath = join(directory, "signer.json");
-  const prepared = await prepareSignerRuntime(
-    { credentialDirectory: directory, signerPath, homeDir },
-    { runCommand: deps.runCommand }
-  );
-  messages.push(...prepared.messages);
-  const configResult = await writeRuntimeConfig({
-    runtime: input.runtime,
-    hostedMcpUrl: identity.hosted_mcp_url ?? `${identity.api_url}/mcp`,
-    apiKey: identity.api_key,
-    identityPath: join(directory, "identity.json"),
-    signerPath,
-    credentialDirectory: directory,
-    signerCommand: { command: prepared.command, args: prepared.args },
-    homeDir,
-    mode: "hosted"
-  });
-  messages.push(...configResult.messages);
-  messages.push("Repair complete \u2014 restart the runtime, then verify with --doctor.");
-  return { ok: true, messages };
-}
-var RERUN;
-var init_doctor = __esm({
-  "src/doctor.ts"() {
-    init_runtime_manifest();
-    init_probes();
-    init_signer_runtime();
-    init_config_writers();
-    init_runtime_registry();
-    init_signer_consent();
-    RERUN = "npx @haven_ai/connect@alpha";
-  }
-});
-
-// src/api.ts
-function createConnectApiClient(baseUrl, fetchImpl = fetch) {
-  const root = baseUrl.replace(/\/+$/, "");
-  return {
-    resolveSetup: (input) => request(fetchImpl, `${root}/agent-connection-setups/resolve`, {
-      method: "POST",
-      body: JSON.stringify({
-        setup_token: input.setupToken,
-        connector_version: input.connectorVersion,
-        runtime: input.runtime
-      })
-    }),
-    registerSetup: (input) => request(fetchImpl, `${root}/agent-connection-setups/register`, {
-      method: "POST",
-      body: JSON.stringify({
-        setup_token: input.setupToken,
-        challenge_id: input.challengeId,
-        delegate_address: input.delegateAddress,
-        proof_signature: input.proofSignature,
-        api_key_hash: input.apiKeyHash,
-        api_key_prefix: input.apiKeyPrefix,
-        runtime: input.runtime,
-        connector_version: input.connectorVersion,
-        connector_context: input.connectorContext,
-        install_capabilities: input.installCapabilities && {
-          can_write_runtime_config: input.installCapabilities.canWriteRuntimeConfig,
-          restart_required: input.installCapabilities.restartRequired
-        }
-      })
-    }),
-    getConnectorStatus: (setupId, apiKey) => request(fetchImpl, `${root}/agent-connection-setups/${encodeURIComponent(setupId)}/connector-status`, {
-      method: "GET",
-      headers: { Authorization: `Bearer ${apiKey}` }
-    }),
-    updateInstallStatus: async (setupId, apiKey, input) => {
-      await request(fetchImpl, `${root}/agent-connection-setups/${encodeURIComponent(setupId)}/install-status`, {
-        method: "POST",
-        headers: { Authorization: `Bearer ${apiKey}` },
-        body: JSON.stringify({
-          runtime: input.runtime,
-          connector_version: input.connectorVersion,
-          runtime_mcp_mode: input.runtimeMcpMode,
-          hosted_mcp_configured: input.hostedMcpConfigured,
-          local_signer_configured: input.localSignerConfigured,
-          local_mcp_configured: input.localMcpConfigured,
-          credential_files_written: input.credentialFilesWritten,
-          signer_acknowledged: input.signerAcknowledged,
-          local_mcp_acknowledged: input.localMcpAcknowledged,
-          activation_command_available: input.activationCommandAvailable,
-          skill_installed: input.skillInstalled,
-          probe_result: input.probeResult,
-          restart_required: input.restartRequired,
-          next_user_action: input.nextUserAction,
-          error_code: input.errorCode ?? null,
-          environment_label: input.environmentLabel
-        })
+  const signerRuntimePrepared = localRuntime ? void 0 : signerCommand !== void 0;
+  progress("Setting up your Haven tools\u2026");
+  const configResult = localRuntime ? runtime === "claude-code" ? await configureClaudeCode(deps, localRuntimeInstall?.command ?? "", input.serverName) : await writeRuntimeConfig({
+    runtime,
+    hostedMcpUrl: input.hostedMcpUrl,
+    apiKey: input.apiKey,
+    identityPath: input.identityPath,
+    signerPath: input.signerPath,
+    serverName: input.serverName,
+    credentialDirectory: input.credentialDirectory,
+    localMcpCommand: localRuntimeInstall?.command,
+    signerCommand,
+    homeDir: deps.homeDir,
+    mode: "local"
+  }) : await writeHostedRuntimeConfig(deps, { ...input, runtime }, signerCommand);
+  if (deps.onRuntimeConfigured) {
+    const signerCredentialOnDisk = await probeLocalSignerCredential(input.signerPath);
+    const earlyLocalMcpOk = configResult.runtimeMcpMode === "local_stdio" && configResult.localMcpConfigured && signerCredentialOnDisk && Boolean(localMcpConsent?.acknowledged);
+    const earlySignerOk = configResult.runtimeMcpMode === "local_stdio" ? earlyLocalMcpOk : configResult.signerConfigured && signerCredentialOnDisk && Boolean(signerConsent?.acknowledged);
+    try {
+      await deps.onRuntimeConfigured({
+        runtime,
+        runtimeMcpMode: configResult.runtimeMcpMode,
+        hostedMcpConfigured: configResult.hostedConfigured,
+        localSignerConfigured: earlySignerOk,
+        localMcpConfigured: earlyLocalMcpOk,
+        signerAcknowledged: signerConsent?.acknowledged,
+        localMcpAcknowledged: localMcpConsent?.acknowledged,
+        restartRequired: configResult.restartRequired || restartRequiredForRuntime(runtime, deps.env),
+        nextUserAction: nextAction(runtime, profile.restartMode, configResult.errorCode),
+        errorCode: configResult.errorCode
       });
+    } catch {
     }
-  };
-}
-var ConnectRequestError = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-    this.name = "ConnectRequestError";
-  }
-  status;
-};
-async function request(fetchImpl, url, init) {
-  const response = await fetchImpl(url, {
-    ...init,
-    headers: {
-      "Content-Type": "application/json",
-      ...init.headers ?? {}
-    }
-  });
-  const text = await response.text();
-  const body = text ? JSON.parse(text) : null;
-  if (!response.ok) {
-    const message = body?.error ?? body?.message ?? `${response.status} ${response.statusText}`;
-    throw new ConnectRequestError(`Haven setup request failed: ${message}`, response.status);
-  }
-  return body;
-}
-function generateDelegateKey() {
-  return delegateKeyFromPrivateKey(Wallet.createRandom().privateKey);
-}
-function delegateKeyFromPrivateKey(privateKey) {
-  const wallet = new Wallet(privateKey);
-  return {
-    privateKey: wallet.privateKey,
-    address: wallet.address,
-    signChallenge: (message) => wallet.signMessage(message)
-  };
-}
-function generateAgentApiKey() {
-  return `sk_agent_${crypto.randomBytes(24).toString("hex")}`;
-}
-function hashAgentApiKey(apiKey) {
-  return crypto.createHash("sha256").update(apiKey).digest("hex");
-}
-function agentApiKeyPrefix(apiKey) {
-  return apiKey.slice(0, 12);
-}
-
-// src/redact.ts
-var API_KEY_RE = /sk_agent_[A-Za-z0-9]+/g;
-var PRIVATE_KEY_RE = /0x[0-9a-fA-F]{64}/g;
-function redactSecrets(value) {
-  return value.replace(API_KEY_RE, "sk_agent_[redacted]").replace(PRIVATE_KEY_RE, "0x[redacted-private-key]");
-}
-function shortAddress(address) {
-  if (!/^0x[0-9a-fA-F]{40}$/.test(address)) return address;
-  return `${address.slice(0, 6)}...${address.slice(-4)}`;
-}
-async function preflightCredentialStorage(input = {}) {
-  const directory = defaultCredentialRoot(input.baseDir);
-  await mkdir(directory, { recursive: true, mode: 448 });
-  await restrictPermissions(directory, 448, input.warn);
-  const probePath = join(directory, `.haven-connect-preflight-${crypto.randomBytes(8).toString("hex")}`);
-  try {
-    await writeOwnerOnlyJson(probePath, { ok: true }, input.warn);
-  } finally {
-    await rm(probePath, { force: true }).catch(() => void 0);
   }
-  return directory;
-}
-async function writeCredentialFiles(input) {
-  const directory = defaultAgentDirectory(input.agentId, input.baseDir);
-  await mkdir(directory, { recursive: true, mode: 448 });
-  await restrictPermissions(directory, 448, input.warn);
-  const identityPath = join(directory, "identity.json");
-  const signerPath = join(directory, "signer.json");
-  const agentPath = join(directory, "agent.json");
-  await assertDoesNotExist(identityPath);
-  await assertDoesNotExist(signerPath);
-  await assertDoesNotExist(agentPath);
-  await writeOwnerOnlyJson(
-    signerPath,
-    {
-      delegate_key: input.delegateKey,
-      delegate_address: input.delegateAddress,
-      agent_id: input.agentId,
-      safe_address: input.safeAddress,
-      chain_id: input.chainId,
-      network: input.network,
-      x402_binding_signer: input.x402BindingSigner,
-      note: "Local signer credential. Haven backend never receives this private key."
-    },
-    input.warn
-  );
-  try {
-    await writeOwnerOnlyJson(
-      identityPath,
-      {
-        api_key: input.apiKey,
-        agent_id: input.agentId,
-        safe_address: input.safeAddress,
-        chain_id: input.chainId,
-        network: input.network,
-        api_url: input.apiUrl,
-        hosted_mcp_url: input.hostedMcpUrl,
-        agent_budget: input.agentBudget,
-        note: "Haven API key identifies the agent only. It cannot spend without the local signer key and on-chain Haven wallet rules."
-      },
-      input.warn
-    );
-  } catch (err) {
-    await rm(signerPath, { force: true }).catch(() => void 0);
-    throw err;
-  }
-  try {
-    await writeOwnerOnlyJson(
-      agentPath,
-      {
-        agent_id: input.agentId,
-        delegate_address: input.delegateAddress,
-        safe_address: input.safeAddress,
-        chain_id: input.chainId,
-        network: input.network,
-        agent_budget: input.agentBudget,
-        note: "Non-secret orientation for the agent: public delegate/Haven wallet identity + configured budget. Contains no API key or signing key. For the live remaining budget, call haven_get_allowances."
-      },
-      input.warn
-    );
-  } catch (err) {
-    await rm(signerPath, { force: true }).catch(() => void 0);
-    await rm(identityPath, { force: true }).catch(() => void 0);
-    await rm(agentPath, { force: true }).catch(() => void 0);
-    throw err;
-  }
-  return { directory, identityPath, signerPath, agentPath };
-}
-function defaultAgentDirectory(agentId, baseDir = join(homedir(), ".haven", "agents")) {
-  return resolve(defaultCredentialRoot(baseDir), safePathPart(agentId));
-}
-function defaultCredentialRoot(baseDir = join(homedir(), ".haven", "agents")) {
-  return resolve(baseDir);
-}
-async function writeOwnerOnlyJson(path, value, warn) {
-  const json = JSON.stringify(dropUndefined(value), null, 2);
-  await writeFile(path, `${json}
-`, { mode: 384, flag: "wx" });
-  await restrictPermissions(path, 384, warn);
-}
-function safePathPart(value) {
-  return value.replace(/[^A-Za-z0-9_.-]/g, "_");
-}
-function dropUndefined(value) {
-  return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== void 0));
-}
-async function assertDoesNotExist(path) {
-  try {
-    await access(path);
-  } catch (err) {
-    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") return;
-    throw err;
-  }
-  throw new Error(`Refusing to overwrite existing Haven credential file: ${path}`);
+  progress("Almost there \u2014 just confirming everything connects\u2026");
+  const localProbePromise = configResult.runtimeMcpMode === "local_stdio" && localRuntimeInstall ? runLocalMcpProbe(localRuntimeInstall, deps) : Promise.resolve(void 0);
+  const signerProbePromise = configResult.runtimeMcpMode !== "local_stdio" && signerCommand ? (deps.probeSignerTools ?? probeLocalMcpTools)(
+    signerCommand.command,
+    signerCommand.args,
+    MCP_RUNTIME_MANIFEST.requiredSignerTools
+  ) : Promise.resolve(void 0);
+  const [hostedProbe, signerCredentialReady, localMcpProbe, signerProbe] = await Promise.all([
+    configResult.hostedConfigured ? probeHostedMcpTools(input.apiKey, input.hostedMcpUrl, deps.fetch) : Promise.resolve({ status: "bad_response" }),
+    probeLocalSignerCredential(input.signerPath),
+    localProbePromise,
+    signerProbePromise
+  ]);
+  const hostedOk = configResult.hostedConfigured && hostedProbe.status === "ok";
+  const localMcpOk = configResult.runtimeMcpMode === "local_stdio" && configResult.localMcpConfigured && signerCredentialReady && Boolean(localMcpConsent?.acknowledged) && localMcpProbe?.status === "ok";
+  const signerOk = configResult.runtimeMcpMode === "local_stdio" ? localMcpOk : configResult.signerConfigured && signerCredentialReady && Boolean(signerConsent?.acknowledged) && // #1587: no handshake, no green. A signer command that was registered
+  // but not probed (manual topology) keeps the old semantics.
+  (signerProbe === void 0 || signerProbe.status === "ok");
+  const restartRequired = configResult.restartRequired || restartRequiredForRuntime(runtime, deps.env);
+  const errorCode = configResult.errorCode ?? (configResult.runtimeMcpMode === "local_stdio" ? localMcpErrorCode(signerCredentialReady, localMcpConsent, localMcpProbe?.status) : hostedMcpErrorCode(configResult.hostedConfigured, hostedProbe.status) ?? signerConsentErrorCode(signerCredentialReady, signerConsent) ?? signerProbeErrorCode(signerProbe));
+  const hostedProbeMessages = configResult.hostedConfigured && hostedProbe.status !== "ok" ? [`Hosted Haven MCP probe failed: ${hostedProbe.status}.`] : configResult.hostedConfigured ? ["Verified hosted Haven MCP tools with a read-only handshake."] : [];
+  const signerProbeMessages = signerProbe ? signerProbe.status === "ok" ? ["Verified local Haven signer with a stdio handshake."] : [
+    `Local Haven signer handshake failed: ${signerProbe.status}.`,
+    "Re-run `npx @haven_ai/connect@alpha` to repair the signer setup."
+  ] : [];
+  const localProbeMessages = localMcpProbe && localMcpProbe.status !== "ok" ? [`Local Haven MCP handshake failed: ${localMcpProbe.status}.`] : localMcpProbe?.status === "ok" ? ["Verified local Haven MCP tools with a stdio handshake."] : [];
+  const skillInstall = !configResult.errorCode ? await installSkillForRuntime(runtime, { homeDir: deps.homeDir, env: deps.env }) : void 0;
+  return {
+    runtime,
+    runtimeMcpMode: configResult.runtimeMcpMode,
+    hostedMcpConfigured: hostedOk,
+    localSignerConfigured: signerOk,
+    localMcpConfigured: localMcpOk,
+    probeResult: buildProbeResult(configResult.runtimeMcpMode, configResult.hostedConfigured, hostedProbe.status, signerOk, localMcpOk, localMcpProbe?.status),
+    restartRequired,
+    nextUserAction: nextAction(runtime, profile.restartMode, errorCode),
+    errorCode,
+    configTarget: configResult.target,
+    signerAcknowledged: signerConsent?.acknowledged,
+    localMcpAcknowledged: localMcpConsent?.acknowledged,
+    activationCommand: configResult.activationCommand,
+    skillInstalled: skillInstall?.installed,
+    signerRuntimePrepared,
+    messages: [...consentMessages, ...localRuntimeInstall?.messages ?? [], ...configResult.messages, ...hostedProbeMessages, ...signerProbeMessages, ...localProbeMessages, ...skillInstall?.messages ?? []]
+  };
 }
-async function restrictPermissions(path, mode, warn) {
-  try {
-    await chmod(path, mode);
-  } catch (err) {
-    warn?.(
-      `Warning: could not restrict permissions on ${path} to ${mode.toString(8)}. Move this credential to a private location or run chmod ${mode.toString(8)} ${path}. ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
+function runtimeInstallCapabilities(runtime, env = process.env) {
+  const profile = runtimeProfile(runtime, env);
+  return {
+    canWriteRuntimeConfig: profile.canWriteRuntimeConfig,
+    restartRequired: restartRequiredForRuntime(runtime, env)
+  };
 }
-
-// src/runtime-install.ts
-init_config_writers();
-async function acknowledgeLocalMcpConsent(identityPath, signerPath, log) {
+async function configureClaudeCode(deps, localMcpCommand, serverName) {
+  const runCommand = deps.runCommand ?? defaultRunCommand;
+  const serverJson = JSON.stringify({
+    type: "stdio",
+    command: localMcpCommand,
+    args: [],
+    env: {}
+  });
   try {
-    const input = await buildLocalMcpConsentInput(identityPath, signerPath);
-    const decision = await ensureConsent(input, {
-      credentialsPath: identityPath,
-      writeAck: true,
-      out: log ? { write: (chunk) => writeLogChunk(log, chunk) } : void 0
+    if (!localMcpCommand) throw new Error("local MCP wrapper command is required");
+    const names = serverNamesFor(serverName);
+    await runCommand("claude", ["mcp", "remove", names.hosted]).catch(() => void 0);
+    await runCommand("claude", ["mcp", "remove", names.signer]).catch(() => void 0);
+    await runCommand("claude", ["mcp", "add-json", names.hosted, serverJson, "--scope", "user"]).catch(async () => {
+      await runCommand("claude", ["mcp", "add", names.hosted, "--scope", "user", "--", localMcpCommand]);
     });
+    const verified = await runCommand("claude", ["mcp", "get", names.hosted]).then(() => true).catch(() => false);
     return {
-      acknowledged: decision.ok,
-      hash: decision.hash,
-      reason: decision.reason
+      hostedConfigured: false,
+      signerConfigured: true,
+      localMcpConfigured: true,
+      runtimeMcpMode: "local_stdio",
+      target: "Claude Code MCP config",
+      changed: true,
+      restartRequired: true,
+      messages: [
+        "Updated local Haven MCP entry with Claude Code.",
+        ...verified ? ["Verified Claude Code MCP entry."] : []
+      ]
     };
   } catch (err) {
     return {
-      acknowledged: false,
-      error: err instanceof Error ? err.message : String(err)
+      hostedConfigured: false,
+      signerConfigured: false,
+      localMcpConfigured: false,
+      runtimeMcpMode: "local_stdio",
+      target: "Claude Code MCP config",
+      changed: false,
+      restartRequired: true,
+      messages: [
+        `Could not update Claude Code MCP config: ${err instanceof Error ? err.message : String(err)}`,
+        "Install Claude Code or rerun the Haven setup command inside a Claude Code terminal."
+      ],
+      errorCode: "claude_code_config_failed"
     };
   }
 }
-async function getLocalMcpConsentStatus(identityPath, signerPath) {
+async function writeHostedRuntimeConfig(deps, input, signerCommand) {
+  if (input.runtime === "claude-code") {
+    return configureClaudeCodeHosted(deps, input, signerCommand);
+  }
+  return writeRuntimeConfig({
+    runtime: input.runtime,
+    hostedMcpUrl: input.hostedMcpUrl,
+    apiKey: input.apiKey,
+    identityPath: input.identityPath,
+    signerPath: input.signerPath,
+    serverName: input.serverName,
+    credentialDirectory: input.credentialDirectory,
+    signerCommand,
+    homeDir: deps.homeDir,
+    mode: "hosted"
+  });
+}
+async function configureClaudeCodeHosted(deps, input, signerCommand) {
+  const runCommand = deps.runCommand ?? defaultRunCommand;
+  const hostedJson = JSON.stringify({
+    type: "http",
+    url: input.hostedMcpUrl,
+    headers: { Authorization: `Bearer ${input.apiKey}` }
+  });
+  const signerJson = JSON.stringify({
+    type: "stdio",
+    command: signerCommand?.command ?? "npx",
+    args: signerCommand?.args ?? ["-y", signerPackageSpec(), "--credentials", input.signerPath],
+    env: {}
+  });
   try {
-    const input = await buildLocalMcpConsentInput(identityPath, signerPath);
-    const hash = computeConsentHash(input);
-    const stored = await readLocalMcpAckFile(localMcpAckPath(identityPath));
-    if (stored === hash) {
-      return { acknowledged: true, hash, reason: "ack_file_match" };
-    }
+    const names = serverNamesFor(input.serverName);
+    await runCommand("claude", ["mcp", "remove", names.hosted]).catch(() => void 0);
+    await runCommand("claude", ["mcp", "remove", names.signer]).catch(() => void 0);
+    await runCommand("claude", ["mcp", "add-json", names.hosted, hostedJson, "--scope", "user"]);
+    await runCommand("claude", ["mcp", "add-json", names.signer, signerJson, "--scope", "user"]);
+    const verified = await runCommand("claude", ["mcp", "get", names.hosted]).then(() => true).catch(() => false);
     return {
-      acknowledged: false,
-      hash,
-      reason: stored ? "ack_file_mismatch" : "ack_file_missing"
+      hostedConfigured: true,
+      signerConfigured: true,
+      localMcpConfigured: false,
+      runtimeMcpMode: "hosted_plus_signer",
+      target: "Claude Code MCP config",
+      changed: true,
+      restartRequired: true,
+      messages: [
+        "Updated hosted Haven MCP and local signer entries with Claude Code.",
+        ...verified ? ["Verified Claude Code MCP entry."] : []
+      ]
     };
   } catch (err) {
     return {
-      acknowledged: false,
-      error: err instanceof Error ? err.message : String(err)
+      hostedConfigured: false,
+      signerConfigured: false,
+      localMcpConfigured: false,
+      runtimeMcpMode: "hosted_plus_signer",
+      target: "Claude Code MCP config",
+      changed: false,
+      restartRequired: true,
+      messages: [
+        `Could not update Claude Code MCP config: ${err instanceof Error ? err.message : String(err)}`,
+        "Install Claude Code or rerun the Haven setup command inside a Claude Code terminal."
+      ],
+      errorCode: "claude_code_config_failed"
     };
   }
 }
-function localMcpAckPath(identityPath) {
-  return resolve(`${identityPath}.ack.json`);
+async function defaultRunCommand(command, args) {
+  await execFileAsync3(command, args, { timeout: 1e4 });
 }
-async function buildLocalMcpConsentInput(identityPath, signerPath) {
-  const credentials = await loadCredentials({ identityPath, signerPath });
-  const unavailableDuringSetup = {
-    getAllowances: async () => {
-      throw new Error("Haven approval is not complete yet.");
+function buildProbeResult(mode, hostedConfigured, hostedStatus, signerReady, localMcpReady, localMcpProbeStatus) {
+  if (mode === "local_stdio") {
+    if (localMcpReady) return "local_stdio_mcp_ready";
+    return localMcpProbeStatus ? `local_stdio_mcp_${localMcpProbeStatus}` : "local_stdio_mcp_unavailable";
+  }
+  const hostedPart = hostedConfigured ? `hosted_${hostedStatus}` : "hosted_not_configured";
+  const signerPart = signerReady ? "local_signer_ready" : "local_signer_unavailable";
+  return `${hostedPart}_${signerPart}`.slice(0, 120);
+}
+async function resolveLocalMcpConsent(input, messages) {
+  if (input.ackLocalTools || input.ackSigner) {
+    const status = await acknowledgeLocalMcpConsent(input.identityPath, input.signerPath, (message) => messages.push(message));
+    if (status.acknowledged) {
+      messages.push("Prepared the local Haven tools acknowledgement.");
+    } else {
+      messages.push("Local Haven tools acknowledgement still needs attention.");
     }
-  };
-  return consentInputFromClient(
-    unavailableDuringSetup,
-    {
-      apiKey: credentials.apiKey,
-      apiUrl: credentials.apiUrl,
-      agentId: credentials.agentId,
-      safeAddress: credentials.safeAddress,
-      delegateAddress: credentials.delegateAddress,
-      chainId: credentials.chainId,
-      allowanceSummary: credentials.allowanceSummary
-    },
-    registeredToolNames()
-  );
+    return status;
+  }
+  return getLocalMcpConsentStatus(input.identityPath, input.signerPath);
 }
-async function readLocalMcpAckFile(path) {
-  try {
-    const parsed = JSON.parse(await readFile(path, "utf8"));
-    return typeof parsed.ack === "string" ? parsed.ack : null;
-  } catch {
-    return null;
+async function resolveSignerConsent(input, messages) {
+  if (input.ackSigner || input.ackLocalTools) {
+    const status = await acknowledgeLocalSignerConsent(input.signerPath, (message) => messages.push(message));
+    if (status.acknowledged) {
+      messages.push("Prepared the local Haven signer acknowledgement.");
+    } else {
+      messages.push("Local Haven signer acknowledgement still needs attention.");
+    }
+    return status;
   }
+  return getLocalSignerConsentStatus(input.signerPath);
 }
-function writeLogChunk(log, chunk) {
-  const message = String(chunk).trimEnd();
-  if (message) log(message);
+function signerConsentErrorCode(signerCredentialReady, signerConsent) {
+  if (!signerCredentialReady) return "local_signer_credential_unavailable";
+  if (!signerConsent?.acknowledged) return "local_signer_ack_required";
+  return void 0;
 }
-
-// src/runtime-install.ts
-init_probes();
-
-// src/local-mcp-runtime.ts
-init_signer_runtime();
-init_runtime_manifest();
-var execFileAsync2 = promisify(execFile);
-var UnsupportedNodeVersionError = class extends Error {
-  code = "local_mcp_unsupported_node_version";
-  nodeVersion;
-  minimumNodeVersion;
-  constructor(nodeVersion, minimumNodeVersion, subject = "Haven setup") {
-    super(unsupportedNodeVersionMessage({ subject, nodeVersion, minimumNodeVersion }));
-    this.name = "UnsupportedNodeVersionError";
-    this.nodeVersion = nodeVersion;
-    this.minimumNodeVersion = minimumNodeVersion;
-  }
-};
-async function prepareLocalMcpRuntime(input, deps = {}) {
-  assertSupportedNodeVersion(input.nodeVersion);
-  const homeDir = input.homeDir ?? homedir();
-  const runtimeDirectory = resolve(homeDir, ".haven", "mcp-runtime", MCP_RUNTIME_MANIFEST.mcpVersion);
-  const npmCacheDirectory = resolve(homeDir, ".haven", "npm-cache");
-  const cliPath = join(runtimeDirectory, "node_modules", "@haven_ai", "mcp", "dist", "cli.js");
-  const messages = [];
-  await mkdir(runtimeDirectory, { recursive: true, mode: 448 });
-  await chmod(runtimeDirectory, 448).catch(() => void 0);
-  await mkdir(npmCacheDirectory, { recursive: true, mode: 448 });
-  await chmod(npmCacheDirectory, 448).catch(() => void 0);
-  if (await installedRuntimeMatches2(runtimeDirectory, cliPath)) {
-    messages.push(`Using existing local Haven MCP runtime ${mcpPackageSpec()}.`);
-  } else {
-    await installRuntimePackages2(runtimeDirectory, npmCacheDirectory, deps);
-    messages.push(`Installed local Haven MCP runtime ${mcpPackageSpec()}.`);
-  }
-  await assertFileExists2(cliPath, "local Haven MCP CLI");
-  const wrapperPath = join(input.credentialDirectory, "bin", "haven-mcp");
-  await writeWrapper2({
-    wrapperPath,
-    cliPath,
+function signerProbeErrorCode(probe) {
+  if (!probe || probe.status === "ok") return void 0;
+  return `local_signer_probe_${probe.status}`;
+}
+function hostedMcpErrorCode(hostedConfigured, hostedProbeStatus) {
+  if (!hostedConfigured || hostedProbeStatus === "ok") return void 0;
+  return `hosted_mcp_probe_${hostedProbeStatus}`;
+}
+function localMcpErrorCode(signerCredentialReady, localMcpConsent, localMcpProbeStatus) {
+  if (!signerCredentialReady) return "local_signer_credential_unavailable";
+  if (!localMcpConsent?.acknowledged) return "local_mcp_ack_required";
+  if (localMcpProbeStatus && localMcpProbeStatus !== "ok") return `local_mcp_probe_${localMcpProbeStatus}`;
+  return void 0;
+}
+function nextAction(runtime, restartMode, errorCode) {
+  if (errorCode) return "return_to_haven_for_wallet_approval_then_finish_runtime_setup";
+  if (restartMode === "hot-reload") return "return_to_haven_for_wallet_approval";
+  if (runtime === "codex-cli" || runtime === "codex-desktop") return "return_to_haven_for_wallet_approval_then_restart_codex";
+  if (runtime === "claude-code") return "return_to_haven_for_wallet_approval_then_restart_claude_code";
+  if (restartMode === "restart-app") return "return_to_haven_for_wallet_approval_then_restart_app";
+  if (restartMode === "restart-session") return "return_to_haven_for_wallet_approval_then_restart_agent_session";
+  return "return_to_haven_for_wallet_approval_then_configure_runtime";
+}
+function supportsLocalMcp(runtime) {
+  return runtime === "codex-cli" || runtime === "codex-desktop" || runtime === "claude-code";
+}
+async function prepareRuntimeForLocalMcp(input, deps) {
+  const prepare = deps.prepareLocalMcpRuntime ?? ((runtimeInput) => prepareLocalMcpRuntime(runtimeInput, { runCommand: deps.runCommand, onProgress: deps.onProgress }));
+  return prepare({
+    credentialDirectory: input.credentialDirectory,
     identityPath: input.identityPath,
-    signerPath: input.signerPath
-  });
-  await writeRuntimeSidecar2({
-    path: join(input.credentialDirectory, "mcp-runtime.json"),
-    wrapperPath,
-    runtimeDirectory,
-    npmCacheDirectory,
-    cliPath
+    signerPath: input.signerPath,
+    homeDir: deps.homeDir,
+    serverName: input.serverName
   });
-  messages.push(`Prepared stable local Haven MCP wrapper: ${wrapperPath}`);
-  return {
-    command: wrapperPath,
-    args: [],
-    wrapperPath,
-    runtimeDirectory,
-    npmCacheDirectory,
-    cliPath,
-    messages
-  };
 }
-function assertSupportedNodeVersion(nodeVersion = process.versions.node, minimumNodeVersion = MCP_RUNTIME_MANIFEST.minimumNodeVersion, subject = "Haven setup") {
-  if (!isSupportedNodeVersion(nodeVersion, minimumNodeVersion)) {
-    throw new UnsupportedNodeVersionError(nodeVersion, minimumNodeVersion, subject);
-  }
+async function prepareSignerForRuntime(input, deps) {
+  const prepare = deps.prepareSignerRuntime ?? ((runtimeInput) => (
+    // onProgress threaded through on purpose (#1586 review): without it the
+    // install heartbeat was dead code in production and the console still
+    // went silent for the whole cold install — the exact symptom the issue
+    // set out to remove, at a longer timeout.
+    prepareSignerRuntime(runtimeInput, { runCommand: deps.runCommand, onProgress: deps.onProgress })
+  ));
+  return prepare({
+    credentialDirectory: input.credentialDirectory,
+    signerPath: input.signerPath,
+    homeDir: deps.homeDir,
+    serverName: input.serverName
+  });
 }
-async function installRuntimePackages2(runtimeDirectory, npmCacheDirectory, deps) {
-  const { runCommand, onProgress } = deps;
-  const baseArgs = [
-    "install",
-    "--prefix",
-    runtimeDirectory,
-    "--no-audit",
-    "--no-fund",
-    "--omit=dev",
-    "--prefer-offline",
-    mcpPackageSpec(),
-    sdkPackageSpec()
-  ];
-  const run = async (args) => {
-    const startedAt = Date.now();
-    const heartbeat = setInterval(() => {
-      const seconds = Math.round((Date.now() - startedAt) / 1e3);
-      onProgress?.(`Still installing the local Haven MCP runtime\u2026 (${seconds}s \u2014 a cold cache can take several minutes)`);
-    }, SIGNER_INSTALL_HEARTBEAT_MS);
-    heartbeat.unref?.();
-    try {
-      if (runCommand) await runCommand("npm", args);
-      else await execFileAsync2("npm", args, { timeout: SIGNER_INSTALL_TIMEOUT_MS, maxBuffer: 1024 * 1024 });
-    } finally {
-      clearInterval(heartbeat);
-    }
-  };
+async function runLocalMcpProbe(runtimeInstall, deps) {
+  const probe = deps.probeLocalMcpTools ?? probeLocalMcpTools;
   try {
-    await run(baseArgs);
+    return await probe(runtimeInstall.command, runtimeInstall.args, MCP_RUNTIME_MANIFEST.requiredTools);
   } catch {
-    try {
-      await run([...baseArgs, "--cache", npmCacheDirectory]);
-    } catch (err) {
-      throw new Error(`Could not install local Haven MCP runtime ${mcpPackageSpec()}: ${err instanceof Error ? err.message : String(err)}`);
-    }
+    return { status: "process_error" };
   }
 }
-async function installedRuntimeMatches2(runtimeDirectory, cliPath) {
-  try {
-    await assertFileExists2(cliPath, "local Haven MCP CLI");
-    const [mcpPackage, sdkPackage] = await Promise.all([
-      readPackageJson2(join(runtimeDirectory, "node_modules", "@haven_ai", "mcp", "package.json")),
-      readPackageJson2(join(runtimeDirectory, "node_modules", "@haven_ai", "sdk", "package.json"))
-    ]);
-    return mcpPackage.version === MCP_RUNTIME_MANIFEST.mcpVersion && sdkPackage.version === MCP_RUNTIME_MANIFEST.sdkVersion;
-  } catch {
-    return false;
+function localRuntimePrepareErrorCode(err) {
+  if (err && typeof err === "object" && "code" in err && err.code === "local_mcp_unsupported_node_version") {
+    return "local_mcp_unsupported_node_version";
   }
+  return "local_mcp_runtime_install_failed";
 }
-async function readPackageJson2(path) {
-  return JSON.parse(await readFile(path, "utf8"));
-}
-async function writeWrapper2(input) {
-  await mkdir(dirname(input.wrapperPath), { recursive: true, mode: 448 });
-  await chmod(dirname(input.wrapperPath), 448).catch(() => void 0);
-  const source = [
-    "#!/usr/bin/env node",
-    "import { spawn } from 'node:child_process'",
+var execFileAsync3;
+var init_runtime_install = __esm({
+  "src/runtime-install.ts"() {
+    init_config_writers();
+    init_server_names();
+    init_local_mcp_consent();
+    init_probes();
+    init_local_mcp_runtime();
+    init_signer_runtime();
+    init_runtime_manifest();
+    init_skill_install();
+    init_runtime_registry();
+    init_signer_consent();
+    execFileAsync3 = promisify(execFile);
+  }
+});
+
+// src/tombstone.ts
+var tombstone_exports = {};
+__export(tombstone_exports, {
+  TOMBSTONE_FILENAME: () => TOMBSTONE_FILENAME,
+  TOMBSTONE_MARKER: () => TOMBSTONE_MARKER,
+  readAgentTombstone: () => readAgentTombstone,
+  writeAgentTombstone: () => writeAgentTombstone
+});
+function tombstoneScript(info) {
+  const lines = [
+    `${TOMBSTONE_MARKER}: this Haven agent was retired.`,
     "",
-    `const cliPath = ${JSON.stringify(input.cliPath)}`,
-    `const identityPath = ${JSON.stringify(input.identityPath)}`,
-    `const signerPath = ${JSON.stringify(input.signerPath)}`,
+    `  agent:      ${info.agent_id}`,
+    `  retired at: ${info.retired_at}`,
+    `  reason:     ${info.reason}`,
+    ...info.replaced_by ? [`  replaced by: ${info.replaced_by}`] : [],
     "",
-    "const child = spawn(process.execPath, [cliPath, '--identity', identityPath, '--signer', signerPath, ...process.argv.slice(2)], {",
-    "  stdio: 'inherit',",
-    "})",
+    "This process is running with a wiring snapshot that predates the",
+    "retirement \u2014 it loaded its MCP config at startup and has kept it since.",
+    "Restart THIS host to pick up the current wiring. If several long-lived",
+    "hosts are running (a gateway, a TUI worker, an editor), restart EVERY",
+    "one of them: each holds the snapshot from its own start time, so after",
+    "a chain of recreations each can be parked on a DIFFERENT old agent.",
     "",
-    "child.on('exit', (code, signal) => {",
-    "  if (signal) process.kill(process.pid, signal)",
-    "  else process.exit(code ?? 1)",
-    "})",
+    "Then verify with: npx @haven_ai/connect@alpha --doctor --runtime <runtime>"
+  ];
+  return [
+    "#!/usr/bin/env node",
+    `// ${TOMBSTONE_MARKER} \u2014 written by @haven_ai/connect (#1681). Safe to delete`,
+    "// once every long-lived MCP host on this machine has been restarted.",
+    `process.stderr.write(${JSON.stringify(lines.join("\n") + "\n")})`,
+    "process.exit(1)",
     ""
   ].join("\n");
-  await writeFile(input.wrapperPath, source, { mode: 448 });
-  await chmod(input.wrapperPath, 448).catch(() => void 0);
 }
-async function writeRuntimeSidecar2(input) {
-  const value = {
-    mcp_package: MCP_RUNTIME_MANIFEST.mcpPackage,
-    mcp_version: MCP_RUNTIME_MANIFEST.mcpVersion,
-    sdk_package: MCP_RUNTIME_MANIFEST.sdkPackage,
-    sdk_version: MCP_RUNTIME_MANIFEST.sdkVersion,
-    minimum_node_version: MCP_RUNTIME_MANIFEST.minimumNodeVersion,
-    wrapper_path: input.wrapperPath,
-    runtime_directory: input.runtimeDirectory,
-    npm_cache_directory: input.npmCacheDirectory,
-    cli_path: input.cliPath
+async function writeAgentTombstone(input) {
+  const dirStat = await stat(input.directory).catch(() => null);
+  if (!dirStat?.isDirectory()) {
+    throw new Error(`Not a directory: ${input.directory} \u2014 nothing to tombstone.`);
+  }
+  const info = {
+    // reason / replaced_by are persisted to disk and re-emitted to the host's
+    // MCP stderr log on EVERY stale probe, potentially for months — redact
+    // like every other output path, at the write layer so any future caller
+    // inherits it. (#1681 review, finding 1)
+    agent_id: input.agentId,
+    retired_at: input.retiredAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    reason: redactSecrets(input.reason),
+    ...input.replacedBy ? { replaced_by: redactSecrets(input.replacedBy) } : {}
   };
-  await writeFile(input.path, `${JSON.stringify(value, null, 2)}
-`, { mode: 384 });
-  await chmod(input.path, 384).catch(() => void 0);
-}
-async function assertFileExists2(path, label) {
+  const binDir = join(input.directory, "bin");
+  await mkdir(binDir, { recursive: true });
+  const wrapperPath = join(binDir, "haven-signer.mjs");
+  await writeFile(wrapperPath, tombstoneScript(info), "utf8");
+  await chmod(wrapperPath, 493);
+  await writeFile(join(input.directory, TOMBSTONE_FILENAME), JSON.stringify(info, null, 2) + "\n", "utf8");
+  return info;
+}
+async function readAgentTombstone(directory) {
   try {
-    await access(path);
+    const parsed = JSON.parse(await readFile(join(directory, TOMBSTONE_FILENAME), "utf8"));
+    if (typeof parsed?.agent_id !== "string") return null;
+    return parsed;
   } catch {
-    throw new Error(`Missing ${label}: ${path}`);
+    return null;
   }
 }
+var TOMBSTONE_FILENAME, TOMBSTONE_MARKER;
+var init_tombstone = __esm({
+  "src/tombstone.ts"() {
+    init_redact();
+    TOMBSTONE_FILENAME = "TOMBSTONE.json";
+    TOMBSTONE_MARKER = "HAVEN-TOMBSTONE";
+  }
+});
 
-// src/runtime-install.ts
-init_signer_runtime();
-init_runtime_manifest();
-var CODEX_AGENTS_BEGIN_MARKER = "<!-- BEGIN haven-pay (managed by @haven_ai/connect; edits inside this section are overwritten on re-setup) -->";
-var CODEX_AGENTS_END_MARKER = "<!-- END haven-pay -->";
-async function installSkillForRuntime(runtime, deps = {}) {
-  switch (runtime) {
-    case "claude-code":
-      return installSkillFile(
-        resolve(deps.homeDir ?? homedir(), ".claude", "skills", SKILL_FOLDER_NAME),
-        "~/.claude/skills/haven-pay"
-      );
-    case "hermes":
-      return installSkillFile(
-        join(hermesHome(deps), "skills", SKILL_FOLDER_NAME),
-        "the Hermes skills folder"
+// src/rekey.ts
+var rekey_exports = {};
+__export(rekey_exports, {
+  finishRekey: () => finishRekey,
+  startRekey: () => startRekey
+});
+async function startRekey(options, deps = {}) {
+  const now = deps.now ?? (() => Date.now());
+  const stored = await readStoredCredentials(
+    options.serverName,
+    options.agentId,
+    options.credentialsDir
+  );
+  const api = (deps.createApi ?? ((url) => createConnectApiClient(url)))(stored.apiUrl);
+  const identity = await probeIdentity(api, stored.apiKey, "current");
+  assertRekeyable(identity, stored);
+  const key = (deps.generateKey ?? generateDelegateKey)();
+  const startedAt = new Date(now()).toISOString();
+  const expiresAt = new Date(now() + REKEY_PENDING_TTL_MS).toISOString();
+  await writeRekeyPending(stored.directory, {
+    agent_id: stored.agentId,
+    new_delegate_address: key.address,
+    new_delegate_key: key.privateKey,
+    started_at: startedAt,
+    expires_at: expiresAt
+  });
+  const finishCommand = [
+    "npx @haven_ai/connect@alpha --rekey-finish",
+    options.serverName ? `--name ${options.serverName}` : void 0,
+    "--api-key <the key the dashboard showed you>",
+    options.runtime ? `--runtime ${options.runtime}` : "--runtime <your runtime>"
+  ].filter(Boolean).join(" ");
+  return {
+    started: true,
+    agentId: stored.agentId,
+    directory: stored.directory,
+    newDelegateAddress: key.address,
+    expiresAt,
+    messages: [
+      `New signing key generated on this machine for agent ${identity.name || stored.agentId}.`,
+      "",
+      `  New signing address:  ${key.address}`,
+      "",
+      "The private half stays here \u2014 Haven never receives it, and there is no way to move it",
+      "between machines. That is what keeps the account non-custodial.",
+      "",
+      'Next, on the Haven agent page: choose "Replace signing key" and paste that address.',
+      "When it finishes it shows a new API key ONCE. Come back here and run:",
+      "",
+      `  ${finishCommand}`,
+      "",
+      `Nothing has changed yet \u2014 the agent keeps working on its old key until you finish.`,
+      `This pending re-key expires ${expiresAt}.`
+    ]
+  };
+}
+async function finishRekey(options, deps = {}) {
+  const now = deps.now ?? (() => Date.now());
+  if (!options.newApiKey) {
+    throw new Error("--rekey-finish needs --api-key <key> \u2014 the one the Haven agent page showed once.");
+  }
+  const stored = await readStoredCredentials(
+    options.serverName,
+    options.agentId,
+    options.credentialsDir
+  );
+  const pending = await readRekeyPending(stored.directory, now());
+  if (pending.agent_id !== stored.agentId) {
+    throw new Error(
+      `The pending re-key at ${stored.directory} belongs to agent ${pending.agent_id}, but that directory now holds ${stored.agentId}. Refusing to write a key into the wrong agent.`
+    );
+  }
+  const api = (deps.createApi ?? ((url) => createConnectApiClient(url)))(stored.apiUrl);
+  const identity = await probeIdentity(api, options.newApiKey, "new");
+  if (identity.id !== stored.agentId) {
+    throw new Error(
+      `That API key belongs to agent ${identity.id}, not ${stored.agentId}. Nothing was changed.`
+    );
+  }
+  const onChain = (identity.delegate_address ?? "").toLowerCase();
+  const expected = pending.new_delegate_address.toLowerCase();
+  if (onChain !== expected) {
+    throw new Error(
+      `Haven says this agent's signing address is ${identity.delegate_address ?? "unset"}, but this machine generated ${pending.new_delegate_address}. Nothing was changed. Either the re-key on the agent page used a different address, or it has not finished yet.`
+    );
+  }
+  await rewriteCredentialFiles({
+    baseDir: options.credentialsDir,
+    agentId: stored.agentId,
+    serverName: options.serverName,
+    apiKey: options.newApiKey,
+    delegateKey: pending.new_delegate_key,
+    delegateAddress: pending.new_delegate_address,
+    safeAddress: stored.safeAddress ?? identity.safe_address ?? void 0,
+    chainId: stored.chainId ?? identity.chain_id ?? void 0,
+    network: stored.network,
+    agentBudget: stored.agentBudget,
+    apiUrl: stored.apiUrl,
+    hostedMcpUrl: stored.hostedMcpUrl,
+    x402BindingSigner: stored.x402BindingSigner,
+    warn: deps.log
+  });
+  await clearRekeyPending(stored.directory);
+  const names = serverNamesFor(options.serverName);
+  const messages = [
+    `Agent ${identity.name || stored.agentId} is now on its new signing key.`,
+    `  Signing address:  ${pending.new_delegate_address}`,
+    `  Credentials:      ${stored.directory} (rewritten in place)`,
+    `  MCP servers:      ${names.hosted} / ${names.signer} (unchanged names)`
+  ];
+  let configRewritten = false;
+  if (options.runtime) {
+    const prepared = await (deps.prepareSigner ?? prepareSignerRuntime)(
+      {
+        credentialDirectory: stored.directory,
+        signerPath: `${stored.directory}/signer.json`,
+        homeDir: options.homeDir
+      },
+      { runCommand: deps.runCommand }
+    );
+    const result = await (deps.writeConfig ?? writeHostedRuntimeConfig)(
+      { runCommand: deps.runCommand, homeDir: options.homeDir },
+      {
+        runtime: options.runtime,
+        hostedMcpUrl: stored.hostedMcpUrl,
+        apiKey: options.newApiKey,
+        identityPath: `${stored.directory}/identity.json`,
+        signerPath: `${stored.directory}/signer.json`,
+        credentialDirectory: stored.directory,
+        serverName: options.serverName
+      },
+      { command: prepared.command, args: prepared.args }
+    );
+    configRewritten = result.hostedConfigured;
+    messages.push(`  Config:           ${result.target}`);
+    messages.push(...result.messages.map((line) => `  ${line}`));
+    if (!configRewritten) {
+      messages.push(
+        "",
+        "WARNING: the MCP config was NOT updated, so it still carries the OLD API key and every",
+        `wired host will fail with 401. Fix the cause above and re-run with --runtime ${options.runtime},`,
+        "or update the config by hand. The credential files on disk are already on the new key."
       );
-    case "codex-cli":
-    case "codex-desktop":
-      return installCodexAgentsSection(deps);
-    default:
-      return void 0;
+    }
+  } else {
+    messages.push(
+      "",
+      "NOTE: no --runtime was given, so the MCP config still carries the OLD API key and every",
+      "wired host will fail with 401. Re-run with --runtime <name> to rewrite it."
+    );
   }
+  return {
+    finished: true,
+    agentId: stored.agentId,
+    directory: stored.directory,
+    newDelegateAddress: pending.new_delegate_address,
+    serverNames: { hosted: names.hosted, signer: names.signer },
+    configRewritten,
+    messages
+  };
 }
-async function installSkillFile(skillDir, label) {
+async function probeIdentity(api, apiKey, which) {
   try {
-    await mkdir(skillDir, { recursive: true });
-    const target = join(skillDir, "SKILL.md");
-    await writeFile(target, HAVEN_SKILL_MD, "utf8");
-    return {
-      installed: true,
-      target,
-      messages: [`Installed the generic Haven payment skill (${label}). It contains no secrets.`]
+    return await api.getAgentIdentity(apiKey);
+  } catch (err) {
+    const status = err?.status;
+    if (status === 401 || status === 403) {
+      throw new Error(
+        which === "current" ? "This machine's Haven API key is no longer accepted. If a re-key already finished elsewhere, run --rekey-finish with the key that re-key produced instead of starting a new one." : "Haven rejected that API key. Check you pasted the whole key from the agent page \u2014 nothing was changed."
+      );
+    }
+    throw new Error(
+      `Could not reach Haven to check this agent (${redactSecrets(
+        err instanceof Error ? err.message : String(err)
+      )}). Nothing was changed.`
+    );
+  }
+}
+function assertRekeyable(identity, stored) {
+  if (identity.id !== stored.agentId) {
+    throw new Error(
+      `The credentials at ${stored.directory} say agent ${stored.agentId}, but Haven says that key belongs to ${identity.id}. Refusing to re-key an agent this directory does not own.`
+    );
+  }
+  if (identity.execution_rail === "legacy") {
+    throw new Error(
+      `Agent ${identity.name || identity.id} is on the legacy rail, which cannot be re-keyed \u2014 its authority is per-token Safe allowances, not a signed delegation there is anything to re-issue. Re-onboard the agent on the delegation rail instead.`
+    );
+  }
+  if (identity.status === "revoked") {
+    throw new Error(
+      `Agent ${identity.name || identity.id} is revoked. Re-keying would hand a revoked agent fresh credentials \u2014 create a new agent instead.`
+    );
+  }
+}
+var init_rekey = __esm({
+  "src/rekey.ts"() {
+    init_api();
+    init_runtime_install();
+    init_signer_runtime();
+    init_key();
+    init_redact();
+    init_server_names();
+    init_storage();
+  }
+});
+
+// src/rekey-restart.ts
+var rekey_restart_exports = {};
+__export(rekey_restart_exports, {
+  restartGuidance: () => restartGuidance
+});
+function restartGuidance(runtime) {
+  const profile = runtime ? BY_RUNTIME[runtime] : void 0;
+  const lines = ["The new key is only live in a process that started after now.", ""];
+  if (profile) {
+    lines.push(profile.how);
+    for (const command of profile.commands) lines.push(`    ${command}`);
+    if (profile.commands.length > 0) lines.push("");
+  } else {
+    lines.push(
+      runtime ? `No standard restart command is known for "${runtime}" \u2014 restart it the way you start it.` : "Pass --runtime <name> to get the restart command for a specific host."
+    );
+    lines.push("");
+  }
+  lines.push(SWEEP);
+  return { commands: profile?.commands ?? [], lines };
+}
+var SWEEP, BY_RUNTIME;
+var init_rekey_restart = __esm({
+  "src/rekey-restart.ts"() {
+    SWEEP = "Then restart EVERY other long-lived MCP host on this machine \u2014 gateways, TUI workers, editors. Each holds the wiring snapshot from its own start time, so after a re-key each one is still presenting the OLD API key and will fail with 401 until it restarts.";
+    BY_RUNTIME = {
+      "claude-code": {
+        commands: ["claude --continue"],
+        how: "Exit this Claude Code session and start a new one:"
+      },
+      "codex-cli": {
+        commands: ["codex resume --last"],
+        how: "Start a fresh Codex CLI session:"
+      },
+      "codex-desktop": {
+        commands: [],
+        how: "Quit Codex Desktop completely (not just the window) and reopen it."
+      },
+      "claude-desktop": {
+        commands: [],
+        how: "Quit Claude Desktop completely (not just the window) and reopen it."
+      },
+      hermes: {
+        commands: ["systemctl --user restart hermes-gateway", "/restart"],
+        how: "Restart the Hermes gateway, or run /restart inside a Hermes session. The first form is the one that matters if you run it as a user service:"
+      },
+      cursor: {
+        commands: [],
+        how: 'Cursor hot-reloads MCP config, so it will pick the new key up on its own. If a tool call still fails with 401, reload the window (Cmd/Ctrl+Shift+P \u2192 "Reload Window").'
+      },
+      vscode: {
+        commands: [],
+        how: 'VS Code hot-reloads MCP config. If a tool call still fails with 401, reload the window (Cmd/Ctrl+Shift+P \u2192 "Reload Window").'
+      },
+      "vscode-insiders": {
+        commands: [],
+        how: 'VS Code Insiders hot-reloads MCP config. If a tool call still fails with 401, reload the window (Cmd/Ctrl+Shift+P \u2192 "Reload Window").'
+      }
     };
-  } catch (err) {
+  }
+});
+
+// src/doctor.ts
+var doctor_exports = {};
+__export(doctor_exports, {
+  runDoctor: () => runDoctor,
+  runRepair: () => runRepair
+});
+async function discoverCredentialDirectory(homeDir, explicit) {
+  const root = explicit ? dirname(explicit) : join(homeDir, ".haven", "agents");
+  let entries = [];
+  try {
+    entries = await readdir(root);
+  } catch {
+    return explicit ? { directory: explicit, others: [], parkedOnly: /* @__PURE__ */ new Set() } : { others: [], parkedOnly: /* @__PURE__ */ new Set() };
+  }
+  const candidates = [];
+  const tombstonedOnly = [];
+  const parkedOnly = [];
+  for (const entry of entries) {
+    const directory = join(root, entry);
+    try {
+      const s = await stat(join(directory, "identity.json"));
+      candidates.push({ directory, mtimeMs: s.mtimeMs });
+    } catch {
+      try {
+        await stat(join(directory, TOMBSTONE_FILENAME));
+        tombstonedOnly.push(directory);
+      } catch {
+        try {
+          await stat(join(directory, REKEY_PENDING_FILENAME));
+          parkedOnly.push(directory);
+        } catch {
+        }
+      }
+    }
+  }
+  const parkedOnlySet = new Set(parkedOnly);
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  if (explicit) {
     return {
-      installed: false,
-      messages: [
-        `Could not install the Haven payment skill: ${err instanceof Error ? err.message : String(err)}. Download it from the Haven dashboard instead.`
-      ]
+      directory: explicit,
+      others: [...candidates.map((c) => c.directory), ...tombstonedOnly, ...parkedOnly].filter((d) => d !== explicit),
+      parkedOnly: parkedOnlySet
     };
   }
+  if (candidates.length === 0 && tombstonedOnly.length === 0 && parkedOnly.length === 0) {
+    return { others: [], parkedOnly: parkedOnlySet };
+  }
+  return {
+    directory: candidates[0]?.directory,
+    others: [...candidates.slice(1).map((c) => c.directory), ...tombstonedOnly, ...parkedOnly],
+    parkedOnly: parkedOnlySet
+  };
 }
-async function installCodexAgentsSection(deps) {
-  try {
-    const codexDir = resolve(deps.homeDir ?? homedir(), ".codex");
-    const target = join(codexDir, "AGENTS.md");
-    await mkdir(codexDir, { recursive: true });
-    const existing = await readFile(target, "utf8").catch(() => null);
-    const next = upsertManagedSection(existing, codexManagedSection());
-    if (next !== existing) {
-      await writeFile(target, next, "utf8");
+function agentIsWired(configText, names, slug, identity, sidecar, isPrimary, bareOwnerExists) {
+  if (configText === null) return isPrimary;
+  if (slug) {
+    for (const name of [names.hosted, names.codexHosted, names.signer, names.codexSigner]) {
+      if (new RegExp(`(^|[."'\\s\\[])${name}(["'\\]:\\s]|$)`, "m").test(configText)) return true;
     }
+    return false;
+  }
+  if (sidecar?.wrapper_path && configText.includes(sidecar.wrapper_path)) return true;
+  if (bareOwnerExists) return false;
+  return isPrimary && Boolean(identity?.hosted_mcp_url && configText.includes(identity.hosted_mcp_url));
+}
+function rekeyPendingCheck(status, hostedDelegateAddress, runtime, slug) {
+  const label = "Pending re-key";
+  const nameFlag = slug ? ` --name ${slug}` : "";
+  if (status.state === "unreadable") {
     return {
-      installed: true,
-      target,
-      messages: [
-        "Installed the generic Haven payment guidance as a managed section in ~/.codex/AGENTS.md (Codex reads it as global instructions). It contains no secrets; your own content in that file is untouched."
-      ]
+      id: "rekey_pending",
+      label,
+      ok: false,
+      detail: `A re-key was started here but ${status.path} does not parse, so neither the address it generated nor when it started can be read. The file still holds what was a private key.`,
+      repair: `Delete ${status.path}, then start again: ${RERUN} --rekey${nameFlag}`
     };
-  } catch (err) {
+  }
+  const started = status.startedAt ?? "an unknown time";
+  const address = status.newDelegateAddress ?? "unknown";
+  const completedOnHaven = hostedDelegateAddress !== void 0 && status.newDelegateAddress !== void 0 && hostedDelegateAddress.toLowerCase() === status.newDelegateAddress.toLowerCase();
+  if (completedOnHaven) {
     return {
-      installed: false,
-      messages: [
-        `Could not install the Haven payment guidance into ~/.codex/AGENTS.md: ${err instanceof Error ? err.message : String(err)}. Download the skill from the Haven dashboard instead.`
-      ]
+      id: "rekey_pending",
+      label,
+      ok: false,
+      detail: `A re-key started ${started} has COMPLETED on Haven \u2014 the agent's signing address is already ${address}, the one this machine generated \u2014 but the local half was never finished, so the credential files here still hold the old key. Parked at ${status.path}.` + (status.state === "expired" ? " The local file is also past its 24h TTL, which --rekey-finish refuses, so the finish command below will not accept it any more." : ""),
+      repair: status.state === "expired" ? `The parked key expired. Start again \u2014 ${RERUN} --rekey${nameFlag} \u2014 and re-run "Replace signing key" on the Haven agent page with the new address it prints.` : `Run: ${RERUN} --rekey-finish${nameFlag} --api-key <the key the agent page showed you> --runtime ${runtime}`
     };
   }
-}
-function codexManagedSection() {
-  return `${CODEX_AGENTS_BEGIN_MARKER}
-
-${HAVEN_SKILL_BODY_MD.trimEnd()}
-
-${CODEX_AGENTS_END_MARKER}
-`;
-}
-function upsertManagedSection(existing, section) {
-  if (existing === null || existing.trim() === "") return section;
-  const begins = markerLineIndexes(existing, CODEX_AGENTS_BEGIN_MARKER);
-  const ends = markerLineIndexes(existing, CODEX_AGENTS_END_MARKER);
-  if (begins.length === 1 && ends.length === 1 && ends[0] > begins[0]) {
-    const afterEnd = ends[0] + CODEX_AGENTS_END_MARKER.length;
-    const tail = existing.startsWith("\r\n", afterEnd) ? existing.slice(afterEnd + 2) : existing.startsWith("\n", afterEnd) ? existing.slice(afterEnd + 1) : existing.slice(afterEnd);
-    return existing.slice(0, begins[0]) + section + tail;
-  }
-  if (begins.length > 0 || ends.length > 0) {
-    throw new Error(
-      "found a damaged Haven marker section (orphaned or duplicated markers); remove the leftover marker lines and re-run setup"
-    );
+  const wedgeNote = "Haven is NOT yet on this address, so the re-key did not complete. This machine cannot tell whether the on-chain revoke on the agent page already ran: if it did not, closing this costs nothing; if it did, the agent's old delegations are revoked, no new ones were issued, and only an owner re-grant restores its spend authority (#1868). Check the agent page before assuming the harmless case.";
+  if (status.state === "expired") {
+    return {
+      id: "rekey_pending",
+      label,
+      ok: false,
+      detail: `A re-key started ${started} EXPIRED ${status.expiresAt ?? ""} without being finished. Its address was ${address}; the private half it generated is still on disk at ${status.path}. ` + wedgeNote,
+      repair: `Either delete ${status.path} to drop the parked key, or start over: ${RERUN} --rekey${nameFlag}. Connect never deletes it for you \u2014 an expired TTL is a refusal to USE the key, not a licence to destroy key material you may still be mid-flow on.`
+    };
   }
-  return `${existing.replace(/\n*$/, "\n\n")}${section}`;
+  return {
+    id: "rekey_pending",
+    label,
+    ok: true,
+    detail: `A re-key started ${started} is still open (expires ${status.expiresAt ?? "unknown"}). Paste this address into "Replace signing key" on the Haven agent page: ${address}. Parked at ${status.path}. ` + wedgeNote
+  };
 }
-function markerLineIndexes(text, marker) {
-  const indexes = [];
-  for (let from = 0; ; ) {
-    const at = text.indexOf(marker, from);
-    if (at === -1) return indexes;
-    if (at === 0 || text[at - 1] === "\n") indexes.push(at);
-    from = at + marker.length;
+async function readIdentity(directory) {
+  try {
+    return JSON.parse(await readFile(join(directory, "identity.json"), "utf8"));
+  } catch {
+    return void 0;
   }
 }
-function hermesHome(deps) {
-  const env = deps.env ?? process.env;
-  return env.HERMES_HOME ?? join(deps.homeDir ?? homedir(), ".hermes");
-}
-
-// src/runtime-install.ts
-init_runtime_registry();
-init_signer_consent();
-var execFileAsync3 = promisify(execFile);
-async function installRuntime(input, deps = {}) {
-  const runtime = normalizeRuntime(input.runtime, deps.env);
-  const profile = runtimeProfile(runtime, deps.env);
-  const progress = deps.onProgress ?? (() => void 0);
-  const localRuntime = input.localMcp === true && supportsLocalMcp(runtime);
-  const consentMessages = [];
-  const localMcpConsent = localRuntime ? await resolveLocalMcpConsent(input, consentMessages) : void 0;
-  const signerConsent = localRuntime ? void 0 : await resolveSignerConsent(input, consentMessages);
-  if (runtime === "other") {
-    const signerCredentialReady2 = await probeLocalSignerCredential(input.signerPath);
-    const signerReady = signerCredentialReady2 && signerConsent?.acknowledged;
-    return {
-      runtime,
-      runtimeMcpMode: "manual",
-      hostedMcpConfigured: false,
-      localSignerConfigured: false,
-      localMcpConfigured: false,
-      probeResult: signerReady ? "manual_runtime_setup_required_local_signer_ready" : "manual_runtime_setup_required_local_signer_unavailable",
-      restartRequired: true,
-      nextUserAction: "return_to_haven_for_wallet_approval_then_configure_runtime",
-      errorCode: "manual_runtime_setup_required",
-      configTarget: "manual runtime setup",
-      signerAcknowledged: signerConsent?.acknowledged,
-      localMcpAcknowledged: false,
-      messages: [
-        ...consentMessages,
-        "Custom runtime: Haven did not auto-configure it. Your credentials are on disk (chmod 600) \u2014 read them at runtime; never paste a key into the agent prompt, memory, or logs.",
-        `  identity (hosted MCP Bearer): ${input.identityPath}`,
-        `  signer (local signing key):   ${input.signerPath}`,
-        "After wallet approval, wire the runtime to Haven by reference:",
-        `  Hosted MCP + local signer: point your MCP client at ${input.hostedMcpUrl} with the api_key from identity.json, then run  npx -y ${signerPackageSpec()} --credentials ${input.signerPath}`,
-        `  Fully local MCP (no hosted dependency):  npx -y ${mcpPackageSpec()} --identity ${input.identityPath} --signer ${input.signerPath}`
-      ]
-    };
+async function checksForAgent(entry, input, deps) {
+  const { directory, identity, sidecar } = entry;
+  const checks = [];
+  let signerCapabilities;
+  let signerFile;
+  try {
+    const parsed = JSON.parse(await readFile(join(directory, "signer.json"), "utf8"));
+    signerFile = typeof parsed === "object" && parsed !== null ? parsed : void 0;
+  } catch {
+    signerFile = void 0;
   }
-  let localRuntimeInstall;
-  let localRuntimeError;
-  if (localRuntime) {
-    try {
-      localRuntimeInstall = await prepareRuntimeForLocalMcp(input, deps);
-    } catch (err) {
-      localRuntimeError = err;
+  const credentialsOk = Boolean(identity?.api_key) && signerFile !== void 0;
+  checks.push({
+    id: "credentials",
+    label: "Agent credentials",
+    ok: credentialsOk,
+    detail: credentialsOk ? `identity.json and signer.json parse (agent ${identity?.agent_id ?? "unknown"})` : "identity.json or signer.json is missing or unparseable.",
+    ...credentialsOk ? {} : { repair: `Re-run the full setup with a fresh token: ${RERUN} --setup <token>.` }
+  });
+  if (!sidecar) {
+    checks.push({
+      id: "signer_runtime",
+      label: "Signer runtime (preinstalled wrapper)",
+      ok: false,
+      detail: "No signer-runtime.json sidecar \u2014 the pinned signer runtime was never prepared (or a pre-#1586 npx config).",
+      repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}`
+    });
+  } else {
+    const matches = await installedRuntimeMatches(sidecar.runtime_directory, sidecar.cli_path);
+    const versionOk = sidecar.signer_version === MCP_RUNTIME_MANIFEST.signerVersion;
+    const ok = matches && versionOk;
+    checks.push({
+      id: "signer_runtime",
+      label: "Signer runtime (preinstalled wrapper)",
+      ok,
+      detail: ok ? `Installed ${sidecar.signer_package}@${sidecar.signer_version} at ${sidecar.runtime_directory}` : matches ? `Installed version ${sidecar.signer_version} does not match the connector's pinned ${MCP_RUNTIME_MANIFEST.signerVersion}.` : `Runtime directory is stale or empty (${sidecar.runtime_directory}) \u2014 the CLI or package versions are missing.`,
+      ...ok ? {} : { repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}` }
+    });
+  }
+  const hostedUrl = identity?.hosted_mcp_url ?? (identity?.api_url ? `${identity.api_url}/mcp` : void 0);
+  if (identity?.api_key && hostedUrl) {
+    const probe = await (deps.probeHosted ?? probeHostedMcpTools)(identity.api_key, hostedUrl, deps.fetch);
+    checks.push({
+      id: "hosted_mcp",
+      label: "Hosted Haven MCP",
+      ok: probe.status === "ok",
+      detail: probe.status === "ok" ? `Reachable and authorized (${hostedUrl}).` : `Probe failed: ${probe.status} (${hostedUrl}).`,
+      ...probe.status === "ok" ? {} : {
+        repair: probe.status === "unauthorized" ? `The stored API key was rejected \u2014 re-run the full setup with a fresh token: ${RERUN} --setup <token>.` : "Check network access to the hosted MCP URL, then re-run --doctor."
+      }
+    });
+  } else {
+    checks.push({
+      id: "hosted_mcp",
+      label: "Hosted Haven MCP",
+      ok: false,
+      detail: "No stored API key / hosted MCP URL to probe with.",
+      repair: `Re-run the full setup: ${RERUN} --setup <token>.`
+    });
+  }
+  const localDelegate = typeof signerFile?.delegate_address === "string" ? signerFile.delegate_address : void 0;
+  let hostedDelegateAddress;
+  if (identity?.api_key && identity.api_url) {
+    const probe = await (deps.probeHostedIdentity ?? probeHostedAgentIdentity)(
+      identity.api_key,
+      identity.api_url,
+      deps.fetch
+    );
+    if (probe.status === "ok") hostedDelegateAddress = probe.delegateAddress;
+    if (probe.status !== "ok") {
+      checks.push({
+        id: "identity_match",
+        label: "Hosted identity matches the local signing key",
+        ok: false,
+        detail: probe.status === "unauthorized" ? "The stored API key was rejected, so the agent it authenticates as cannot be compared with the local signing key." : `Could not read the hosted identity (${probe.status}) \u2014 the comparison did not happen, so it cannot be reported as a match.`,
+        repair: probe.status === "unauthorized" ? `Re-run the full setup with a fresh token: ${RERUN} --setup <token>.` : `Restore network access to the Haven API, then re-run: ${RERUN} --doctor --runtime ${input.runtime}`
+      });
+    } else if (!localDelegate) {
+      checks.push({
+        id: "identity_match",
+        label: "Hosted identity matches the local signing key",
+        ok: false,
+        detail: "signer.json holds no delegate_address to compare against the hosted identity.",
+        repair: `Re-run the full setup with a fresh token: ${RERUN} --setup <token>.`
+      });
+    } else {
+      const same = probe.delegateAddress?.toLowerCase() === localDelegate.toLowerCase();
+      checks.push({
+        id: "identity_match",
+        label: "Hosted identity matches the local signing key",
+        ok: same,
+        detail: same ? `The stored API key authenticates as the agent whose signing key is in this directory (${shortAddress(localDelegate)}).` : `MISMATCH: the stored API key authenticates as agent ${probe.agentId ?? "unknown"} with delegate ${shortAddress(probe.delegateAddress ?? "unknown")}, but signer.json here holds ${shortAddress(localDelegate)}. This runtime would quote as one agent and sign as another.`,
+        ...same ? {} : {
+          repair: `Re-run setup for this agent so its API key and signing key come from one run: ${RERUN} --setup <token>. Do not hand-edit either file.`
+        }
+      });
     }
   }
-  if (localRuntimeError) {
-    const errorCode2 = localRuntimePrepareErrorCode(localRuntimeError);
-    return {
-      runtime,
-      runtimeMcpMode: "local_stdio",
-      hostedMcpConfigured: false,
-      localSignerConfigured: false,
-      localMcpConfigured: false,
-      probeResult: errorCode2 === "local_mcp_unsupported_node_version" ? "local_stdio_mcp_unsupported_node_version" : "local_stdio_mcp_runtime_install_failed",
-      restartRequired: true,
-      nextUserAction: nextAction(runtime, profile.restartMode, errorCode2),
-      errorCode: errorCode2,
-      configTarget: profile.label,
-      signerAcknowledged: signerConsent?.acknowledged,
-      localMcpAcknowledged: localMcpConsent?.acknowledged,
-      activationCommand: void 0,
-      messages: [
-        ...consentMessages,
-        `Could not prepare local Haven MCP runtime: ${localRuntimeError instanceof Error ? localRuntimeError.message : String(localRuntimeError)}`
-      ]
-    };
+  const pending = await inspectRekeyPending(directory, deps.now?.() ?? Date.now());
+  if (pending) {
+    checks.push(rekeyPendingCheck(pending, hostedDelegateAddress, input.runtime, sidecar?.server_name));
   }
-  let signerCommand;
-  if (!localRuntime) {
-    progress("Getting the signer ready\u2026");
-    try {
-      const signerRuntime = await prepareSignerForRuntime(input, deps);
-      signerCommand = { command: signerRuntime.command, args: signerRuntime.args };
-      consentMessages.push(...signerRuntime.messages);
-    } catch (err) {
-      return {
-        runtime,
-        runtimeMcpMode: "hosted_plus_signer",
-        hostedMcpConfigured: false,
-        localSignerConfigured: false,
-        localMcpConfigured: false,
-        probeResult: "signer_runtime_install_failed",
-        restartRequired: false,
-        nextUserAction: "The local Haven signer runtime could not be installed, so no configuration was written. Check your network (a cold install downloads the signer package set) and re-run: npx @haven_ai/connect@alpha",
-        errorCode: "signer_runtime_install_failed",
-        configTarget: profile.label,
-        signerAcknowledged: signerConsent?.acknowledged,
-        localMcpAcknowledged: localMcpConsent?.acknowledged,
-        activationCommand: void 0,
-        signerRuntimePrepared: false,
-        messages: [
-          ...consentMessages,
-          `Could not pre-install the local Haven signer: ${err instanceof Error ? err.message : String(err)}`,
-          "No runtime configuration was written (fail-closed): a config pointing at an uninstalled signer looks wired but cannot start.",
-          "Re-run `npx @haven_ai/connect@alpha` to retry the setup."
-        ]
-      };
+  if (sidecar) {
+    const consent = await getLocalSignerConsentStatus(join(directory, "signer.json"));
+    if (!consent.acknowledged) {
+      checks.push({
+        id: "signer_process",
+        label: "Signer stdio handshake",
+        ok: false,
+        detail: "The local-tools consent is not acknowledged, so the signer refuses to start (by design).",
+        repair: `Run: ${RERUN} --ack-local-tools --setup <token>  (or re-run your original setup command with --ack-local-tools).`
+      });
+    } else {
+      const probe = await (deps.probeSignerTools ?? probeLocalMcpTools)(
+        sidecar.wrapper_path,
+        [],
+        MCP_RUNTIME_MANIFEST.requiredSignerTools
+      );
+      const experimental = probe.capabilities?.experimental ?? probe.capabilities;
+      const compat = experimental?.["haven/signer-compatibility"];
+      signerCapabilities = compat ? { "haven/signer-compatibility": compat } : void 0;
+      const compatDetail = compat ? ` Compat: x402 expected-context v${JSON.stringify(compat.x402_expected_context_versions ?? "?")}.` : "";
+      checks.push({
+        id: "signer_process",
+        label: "Signer stdio handshake",
+        ok: probe.status === "ok",
+        detail: probe.status === "ok" ? `Signer started, listed ${probe.toolNames?.length ?? 0} tools${probe.serverInfo?.version ? ` (v${probe.serverInfo.version})` : ""}.${compatDetail}` : `Handshake failed: ${probe.status}.`,
+        ...probe.status === "ok" ? {} : { repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}` }
+      });
     }
+  } else {
+    checks.push({
+      id: "signer_process",
+      label: "Signer stdio handshake",
+      ok: false,
+      detail: "Skipped \u2014 no prepared signer runtime to probe.",
+      repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}`
+    });
   }
-  const signerRuntimePrepared = localRuntime ? void 0 : signerCommand !== void 0;
-  progress("Setting up your Haven tools\u2026");
-  const configResult = runtime === "claude-code" ? localRuntime ? await configureClaudeCode(deps, localRuntimeInstall?.command ?? "") : await configureClaudeCodeHosted(deps, input, signerCommand) : await writeRuntimeConfig({
-    runtime,
-    hostedMcpUrl: input.hostedMcpUrl,
-    apiKey: input.apiKey,
-    identityPath: input.identityPath,
-    signerPath: input.signerPath,
-    credentialDirectory: input.credentialDirectory,
-    localMcpCommand: localRuntimeInstall?.command,
-    signerCommand,
-    homeDir: deps.homeDir,
-    mode: localRuntime ? "local" : "hosted"
-  });
-  if (deps.onRuntimeConfigured) {
-    const signerCredentialOnDisk = await probeLocalSignerCredential(input.signerPath);
-    const earlyLocalMcpOk = configResult.runtimeMcpMode === "local_stdio" && configResult.localMcpConfigured && signerCredentialOnDisk && Boolean(localMcpConsent?.acknowledged);
-    const earlySignerOk = configResult.runtimeMcpMode === "local_stdio" ? earlyLocalMcpOk : configResult.signerConfigured && signerCredentialOnDisk && Boolean(signerConsent?.acknowledged);
+  return { checks, ...signerCapabilities ? { signerCapabilities } : {} };
+}
+async function runDoctor(input, deps = {}) {
+  const homeDir = deps.homeDir ?? homedir();
+  const checks = [];
+  let signerCapabilities;
+  const { directory, others, parkedOnly } = await discoverCredentialDirectory(homeDir, input.credentialsDir);
+  const configPath = runtimeConfigPathFor(input.runtime, homeDir);
+  let configText = null;
+  if (configPath !== null) {
     try {
-      await deps.onRuntimeConfigured({
-        runtime,
-        runtimeMcpMode: configResult.runtimeMcpMode,
-        hostedMcpConfigured: configResult.hostedConfigured,
-        localSignerConfigured: earlySignerOk,
-        localMcpConfigured: earlyLocalMcpOk,
-        signerAcknowledged: signerConsent?.acknowledged,
-        localMcpAcknowledged: localMcpConsent?.acknowledged,
-        restartRequired: configResult.restartRequired || restartRequiredForRuntime(runtime, deps.env),
-        nextUserAction: nextAction(runtime, profile.restartMode, configResult.errorCode),
-        errorCode: configResult.errorCode
-      });
+      configText = await readFile(configPath, "utf8");
     } catch {
+      configText = null;
     }
   }
-  progress("Almost there \u2014 just confirming everything connects\u2026");
-  const localProbePromise = configResult.runtimeMcpMode === "local_stdio" && localRuntimeInstall ? runLocalMcpProbe(localRuntimeInstall, deps) : Promise.resolve(void 0);
-  const signerProbePromise = configResult.runtimeMcpMode !== "local_stdio" && signerCommand ? (deps.probeSignerTools ?? probeLocalMcpTools)(
-    signerCommand.command,
-    signerCommand.args,
-    MCP_RUNTIME_MANIFEST.requiredSignerTools
-  ) : Promise.resolve(void 0);
-  const [hostedProbe, signerCredentialReady, localMcpProbe, signerProbe] = await Promise.all([
-    configResult.hostedConfigured ? probeHostedMcpTools(input.apiKey, input.hostedMcpUrl, deps.fetch) : Promise.resolve({ status: "bad_response" }),
-    probeLocalSignerCredential(input.signerPath),
-    localProbePromise,
-    signerProbePromise
-  ]);
-  const hostedOk = configResult.hostedConfigured && hostedProbe.status === "ok";
-  const localMcpOk = configResult.runtimeMcpMode === "local_stdio" && configResult.localMcpConfigured && signerCredentialReady && Boolean(localMcpConsent?.acknowledged) && localMcpProbe?.status === "ok";
-  const signerOk = configResult.runtimeMcpMode === "local_stdio" ? localMcpOk : configResult.signerConfigured && signerCredentialReady && Boolean(signerConsent?.acknowledged) && // #1587: no handshake, no green. A signer command that was registered
-  // but not probed (manual topology) keeps the old semantics.
-  (signerProbe === void 0 || signerProbe.status === "ok");
-  const restartRequired = configResult.restartRequired || restartRequiredForRuntime(runtime, deps.env);
-  const errorCode = configResult.errorCode ?? (configResult.runtimeMcpMode === "local_stdio" ? localMcpErrorCode(signerCredentialReady, localMcpConsent, localMcpProbe?.status) : hostedMcpErrorCode(configResult.hostedConfigured, hostedProbe.status) ?? signerConsentErrorCode(signerCredentialReady, signerConsent) ?? signerProbeErrorCode(signerProbe));
-  const hostedProbeMessages = configResult.hostedConfigured && hostedProbe.status !== "ok" ? [`Hosted Haven MCP probe failed: ${hostedProbe.status}.`] : configResult.hostedConfigured ? ["Verified hosted Haven MCP tools with a read-only handshake."] : [];
-  const signerProbeMessages = signerProbe ? signerProbe.status === "ok" ? ["Verified local Haven signer with a stdio handshake."] : [
-    `Local Haven signer handshake failed: ${signerProbe.status}.`,
-    "Re-run `npx @haven_ai/connect@alpha` to repair the signer setup."
-  ] : [];
-  const localProbeMessages = localMcpProbe && localMcpProbe.status !== "ok" ? [`Local Haven MCP handshake failed: ${localMcpProbe.status}.`] : localMcpProbe?.status === "ok" ? ["Verified local Haven MCP tools with a stdio handshake."] : [];
-  const skillInstall = !configResult.errorCode ? await installSkillForRuntime(runtime, { homeDir: deps.homeDir, env: deps.env }) : void 0;
-  return {
-    runtime,
-    runtimeMcpMode: configResult.runtimeMcpMode,
-    hostedMcpConfigured: hostedOk,
-    localSignerConfigured: signerOk,
-    localMcpConfigured: localMcpOk,
-    probeResult: buildProbeResult(configResult.runtimeMcpMode, configResult.hostedConfigured, hostedProbe.status, signerOk, localMcpOk, localMcpProbe?.status),
-    restartRequired,
-    nextUserAction: nextAction(runtime, profile.restartMode, errorCode),
-    errorCode,
-    configTarget: configResult.target,
-    signerAcknowledged: signerConsent?.acknowledged,
-    localMcpAcknowledged: localMcpConsent?.acknowledged,
-    activationCommand: configResult.activationCommand,
-    skillInstalled: skillInstall?.installed,
-    signerRuntimePrepared,
-    messages: [...consentMessages, ...localRuntimeInstall?.messages ?? [], ...configResult.messages, ...hostedProbeMessages, ...signerProbeMessages, ...localProbeMessages, ...skillInstall?.messages ?? []]
-  };
-}
-function runtimeInstallCapabilities(runtime, env = process.env) {
-  const profile = runtimeProfile(runtime, env);
+  const allDirectories = directory ? [directory, ...others] : others;
+  let bareOwnerExists = false;
+  for (const dir of allDirectories) {
+    const sidecar = await readRuntimeSidecar(dir);
+    if (!sidecar?.server_name && sidecar?.wrapper_path && configText?.includes(sidecar.wrapper_path)) {
+      bareOwnerExists = true;
+      break;
+    }
+  }
+  const inventory = [];
+  const capabilitiesByDirectory = /* @__PURE__ */ new Map();
+  const primaryChecksById = /* @__PURE__ */ new Map();
+  for (const dir of allDirectories) {
+    const identity = await readIdentity(dir);
+    const sidecar = await readRuntimeSidecar(dir);
+    const tombstone = await readAgentTombstone(dir);
+    const slug = sidecar?.server_name;
+    const names = serverNamesFor(slug);
+    const rekeyPending = await inspectRekeyPending(dir, deps.now?.() ?? Date.now());
+    if (!identity?.api_key) {
+      const agentId = tombstone?.agent_id ?? rekeyPending?.agentId;
+      inventory.push({
+        ...slug ? { slug } : {},
+        ...agentId ? { agentId } : {},
+        directory: dir,
+        // A tombstone is a deliberate record and outranks the discovery tell:
+        // a retired directory that also holds a parked key stays `retired`.
+        classification: tombstone ? "retired" : parkedOnly.has(dir) ? "parked" : "orphaned",
+        checks: rekeyPending ? [rekeyPendingCheck(rekeyPending, void 0, input.runtime, slug)] : [],
+        ...rekeyPending ? { rekeyPending } : {}
+      });
+      continue;
+    }
+    const wired = agentIsWired(configText, names, slug, identity, sidecar, dir === directory, bareOwnerExists);
+    const entry = {
+      ...slug ? { slug } : {},
+      ...identity.agent_id ? { agentId: identity.agent_id } : {},
+      directory: dir,
+      classification: wired ? "wired" : "superseded",
+      checks: [],
+      ...rekeyPending ? { rekeyPending } : {}
+    };
+    if (wired) {
+      const result = await checksForAgent({ directory: dir, identity, sidecar }, input, deps);
+      entry.checks = result.checks;
+      capabilitiesByDirectory.set(dir, result.signerCapabilities);
+    } else if (rekeyPending) {
+      entry.checks = [rekeyPendingCheck(rekeyPending, void 0, input.runtime, slug)];
+    }
+    inventory.push(entry);
+  }
+  const wiredDirectories = inventory.filter((entry) => entry.classification === "wired").map((entry) => entry.directory);
+  const primaryDirectory = input.credentialsDir ? directory : wiredDirectories.includes(directory ?? "") ? directory : wiredDirectories[0] ?? directory;
+  if (primaryDirectory) {
+    const primaryEntry = inventory.find((entry) => entry.directory === primaryDirectory);
+    signerCapabilities = capabilitiesByDirectory.get(primaryDirectory);
+    for (const check of primaryEntry?.checks ?? []) primaryChecksById.set(check.id, check);
+  }
+  if (!primaryDirectory) {
+    checks.push({
+      id: "credentials",
+      label: "Agent credentials",
+      ok: false,
+      detail: "No agent credential directory with an identity.json under ~/.haven/agents.",
+      repair: `Run the full setup once: ${RERUN} --setup <token from the Haven dashboard>.`
+    });
+  } else {
+    const primaryIdentity = await readIdentity(primaryDirectory);
+    const primarySidecar = await readRuntimeSidecar(primaryDirectory);
+    if (!primaryChecksById.has("credentials")) {
+      const result = await checksForAgent(
+        { directory: primaryDirectory, identity: primaryIdentity, sidecar: primarySidecar },
+        input,
+        deps
+      );
+      signerCapabilities = result.signerCapabilities;
+      for (const check of result.checks) primaryChecksById.set(check.id, check);
+    }
+    for (const id of ["credentials", "signer_runtime"]) {
+      const check = primaryChecksById.get(id);
+      if (check) checks.push(check);
+    }
+  }
+  if (configPath === null) {
+    checks.push({
+      id: "runtime_config",
+      label: "Runtime MCP config",
+      ok: true,
+      detail: `Runtime '${input.runtime}' has no file-based config the connector owns (CLI-managed) \u2014 skipping the file check.`
+    });
+  } else if (configText === null) {
+    checks.push({
+      id: "runtime_config",
+      label: "Runtime MCP config",
+      ok: false,
+      detail: `No runtime config at ${configPath}.`,
+      repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}`
+    });
+  } else {
+    const primaryIdentity = await readIdentity(primaryDirectory ?? "");
+    const primarySidecar = primaryDirectory ? await readRuntimeSidecar(primaryDirectory) : null;
+    const hasHaven = primaryIdentity?.hosted_mcp_url ? configText.includes(primaryIdentity.hosted_mcp_url) : configText.includes("haven");
+    const signerViaNpx = configText.includes("@haven_ai/signer");
+    const wrapperReferenced = primarySidecar ? configText.includes(primarySidecar.wrapper_path) : false;
+    const ok = hasHaven && !signerViaNpx && (primarySidecar ? wrapperReferenced : true);
+    checks.push({
+      id: "runtime_config",
+      label: "Runtime MCP config",
+      ok,
+      detail: ok ? `Config at ${configPath} references the hosted server and the prepared signer wrapper.` : signerViaNpx ? `Config at ${configPath} still launches the signer via npx \u2014 the pre-#1586 shape that cannot start under a 120s startup timeout.` : `Config at ${configPath} is missing the Haven entries${primarySidecar && !wrapperReferenced ? " (or references a different signer wrapper)" : ""}.`,
+      ...ok ? {} : { repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}` }
+    });
+  }
+  for (const id of ["hosted_mcp", "identity_match", "rekey_pending"]) {
+    const check = primaryChecksById.get(id);
+    if (check) checks.push(check);
+  }
+  const otherEntries = inventory.filter((entry) => entry.directory !== primaryDirectory);
+  if (otherEntries.length > 0) {
+    const live = [];
+    const revoked = [];
+    const unverifiable = [];
+    const retired = [];
+    for (const entry of otherEntries) {
+      const identity = await readIdentity(entry.directory);
+      const tombstone = await readAgentTombstone(entry.directory);
+      const otherAgent = entry.agentId ?? basename(entry.directory);
+      const otherUrl = identity?.hosted_mcp_url ?? (identity?.api_url ? `${identity.api_url}/mcp` : void 0);
+      if (!identity?.api_key || !otherUrl) {
+        if (tombstone) retired.push(`${otherAgent} (retired ${tombstone.retired_at})`);
+        else unverifiable.push(`${otherAgent} (no stored key/URL to probe)`);
+        continue;
+      }
+      const suffix = tombstone ? " [tombstoned \u2014 key material still present]" : "";
+      const probe = await (deps.probeHosted ?? probeHostedMcpTools)(identity.api_key, otherUrl, deps.fetch);
+      if (probe.status === "ok") live.push({ label: `${otherAgent}${suffix}`, entry });
+      else if (probe.status === "unauthorized") revoked.push(`${otherAgent}${suffix}`);
+      else unverifiable.push(`${otherAgent} (${probe.status})${suffix}`);
+    }
+    const parts = [];
+    if (live.length > 0) parts.push(`STILL SPEND-CAPABLE: ${live.map((item) => item.label).join(", ")}`);
+    if (revoked.length > 0) parts.push(`already revoked: ${revoked.join(", ")}`);
+    if (retired.length > 0) parts.push(`tombstoned (keys removed): ${retired.join(", ")}`);
+    if (unverifiable.length > 0) parts.push(`could not verify: ${unverifiable.join(", ")}`);
+    const supersededLive = live.filter((item) => item.entry.classification !== "wired").map((item) => item.label);
+    checks.push({
+      id: "superseded_agents",
+      label: "Superseded agent credentials",
+      ok: supersededLive.length === 0,
+      detail: supersededLive.length > 0 ? `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}. A host started before your latest setup keeps authenticating (and spending) as the old agent.` : `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}.`,
+      ...supersededLive.length > 0 ? {
+        repair: `Revoke ${supersededLive.join(", ")} on the Haven agent page, then remove the old director(y/ies) under ~/.haven/agents. Connect never revokes or deletes for you.`
+      } : {}
+    });
+  }
+  const parkedElsewhere = inventory.filter((entry) => entry.directory !== primaryDirectory && entry.rekeyPending).map((entry) => ({ entry, pending: entry.rekeyPending }));
+  if (parkedElsewhere.length > 0) {
+    const abandoned = parkedElsewhere.filter((item) => item.pending.state !== "pending");
+    const describe = (item) => `${item.entry.slug ?? item.entry.agentId ?? basename(item.entry.directory)} (${item.pending.state}, ${item.pending.path})`;
+    checks.push({
+      id: "rekey_pending_elsewhere",
+      label: "Parked re-keys in other credential directories",
+      ok: abandoned.length === 0,
+      detail: abandoned.length > 0 ? `ABANDONED re-key key material outside the agent this report describes: ${abandoned.map(describe).join(", ")}. Each holds a private key that was generated for a re-key nobody finished.` : `${parkedElsewhere.length} other director(y/ies) hold an open pending re-key: ${parkedElsewhere.map(describe).join(", ")}.`,
+      ...abandoned.length > 0 ? {
+        repair: "Check the Haven agent page for each before deleting: if its on-chain revoke already ran, the agent has no spend authority until you re-grant it (#1868), and that is not visible from this machine. Connect never deletes key material for you."
+      } : {}
+    });
+  }
+  const signerProcess = primaryChecksById.get("signer_process");
+  if (signerProcess) checks.push(signerProcess);
+  const restart = restartRequiredForRuntime(input.runtime, deps.env);
+  checks.push({
+    id: "restart",
+    label: "Runtime restart",
+    ok: true,
+    detail: restart ? "This runtime loads MCP config at startup \u2014 restart it after any repair before expecting the tools to appear." : "No restart requirement known for this runtime."
+  });
+  const wiredOk = inventory.filter((entry) => entry.classification === "wired").every((entry) => entry.checks.every((check) => check.ok));
   return {
-    canWriteRuntimeConfig: profile.canWriteRuntimeConfig,
-    restartRequired: restartRequiredForRuntime(runtime, env)
+    version: 1,
+    ok: checks.every((check) => check.ok) && wiredOk,
+    runtime: input.runtime,
+    credentialDirectory: primaryDirectory,
+    checks,
+    agents: inventory,
+    ...signerCapabilities ? { signerCapabilities } : {}
   };
 }
-async function configureClaudeCode(deps, localMcpCommand) {
-  const runCommand = deps.runCommand ?? defaultRunCommand;
-  const serverJson = JSON.stringify({
-    type: "stdio",
-    command: localMcpCommand,
-    args: [],
-    env: {}
-  });
-  try {
-    if (!localMcpCommand) throw new Error("local MCP wrapper command is required");
-    await runCommand("claude", ["mcp", "remove", "haven"]).catch(() => void 0);
-    await runCommand("claude", ["mcp", "remove", "haven-signer"]).catch(() => void 0);
-    await runCommand("claude", ["mcp", "add-json", "haven", serverJson, "--scope", "user"]).catch(async () => {
-      await runCommand("claude", ["mcp", "add", "haven", "--scope", "user", "--", localMcpCommand]);
-    });
-    const verified = await runCommand("claude", ["mcp", "get", "haven"]).then(() => true).catch(() => false);
-    return {
-      hostedConfigured: false,
-      signerConfigured: true,
-      localMcpConfigured: true,
-      runtimeMcpMode: "local_stdio",
-      target: "Claude Code MCP config",
-      changed: true,
-      restartRequired: true,
-      messages: [
-        "Updated local Haven MCP entry with Claude Code.",
-        ...verified ? ["Verified Claude Code MCP entry."] : []
-      ]
-    };
-  } catch (err) {
+async function runRepair(input, deps = {}) {
+  const homeDir = deps.homeDir ?? homedir();
+  const messages = [];
+  const { directory, others } = await discoverCredentialDirectory(homeDir, input.credentialsDir);
+  if (others.length > 0) {
+    messages.push(`Note: ${others.length} other agent credential dir(s) exist \u2014 run --doctor for their status.`);
+  }
+  if (!directory) {
     return {
-      hostedConfigured: false,
-      signerConfigured: false,
-      localMcpConfigured: false,
-      runtimeMcpMode: "local_stdio",
-      target: "Claude Code MCP config",
-      changed: false,
-      restartRequired: true,
-      messages: [
-        `Could not update Claude Code MCP config: ${err instanceof Error ? err.message : String(err)}`,
-        "Install Claude Code or rerun the Haven setup command inside a Claude Code terminal."
-      ],
-      errorCode: "claude_code_config_failed"
+      ok: false,
+      messages: [`No agent credentials found to repair \u2014 run the full setup: ${RERUN} --setup <token>.`]
     };
   }
-}
-async function configureClaudeCodeHosted(deps, input, signerCommand) {
-  const runCommand = deps.runCommand ?? defaultRunCommand;
-  const hostedJson = JSON.stringify({
-    type: "http",
-    url: input.hostedMcpUrl,
-    headers: { Authorization: `Bearer ${input.apiKey}` }
-  });
-  const signerJson = JSON.stringify({
-    type: "stdio",
-    command: signerCommand?.command ?? "npx",
-    args: signerCommand?.args ?? ["-y", signerPackageSpec(), "--credentials", input.signerPath],
-    env: {}
-  });
+  let identity;
   try {
-    await runCommand("claude", ["mcp", "remove", "haven"]).catch(() => void 0);
-    await runCommand("claude", ["mcp", "remove", "haven-signer"]).catch(() => void 0);
-    await runCommand("claude", ["mcp", "add-json", "haven", hostedJson, "--scope", "user"]);
-    await runCommand("claude", ["mcp", "add-json", "haven-signer", signerJson, "--scope", "user"]);
-    const verified = await runCommand("claude", ["mcp", "get", "haven"]).then(() => true).catch(() => false);
-    return {
-      hostedConfigured: true,
-      signerConfigured: true,
-      localMcpConfigured: false,
-      runtimeMcpMode: "hosted_plus_signer",
-      target: "Claude Code MCP config",
-      changed: true,
-      restartRequired: true,
-      messages: [
-        "Updated hosted Haven MCP and local signer entries with Claude Code.",
-        ...verified ? ["Verified Claude Code MCP entry."] : []
-      ]
-    };
-  } catch (err) {
-    return {
-      hostedConfigured: false,
-      signerConfigured: false,
-      localMcpConfigured: false,
-      runtimeMcpMode: "hosted_plus_signer",
-      target: "Claude Code MCP config",
-      changed: false,
-      restartRequired: true,
-      messages: [
-        `Could not update Claude Code MCP config: ${err instanceof Error ? err.message : String(err)}`,
-        "Install Claude Code or rerun the Haven setup command inside a Claude Code terminal."
-      ],
-      errorCode: "claude_code_config_failed"
-    };
+    identity = JSON.parse(await readFile(join(directory, "identity.json"), "utf8"));
+  } catch {
+    return { ok: false, messages: ["identity.json is unreadable \u2014 re-run the full setup with a fresh token."] };
   }
-}
-async function defaultRunCommand(command, args) {
-  await execFileAsync3(command, args, { timeout: 1e4 });
-}
-function buildProbeResult(mode, hostedConfigured, hostedStatus, signerReady, localMcpReady, localMcpProbeStatus) {
-  if (mode === "local_stdio") {
-    if (localMcpReady) return "local_stdio_mcp_ready";
-    return localMcpProbeStatus ? `local_stdio_mcp_${localMcpProbeStatus}` : "local_stdio_mcp_unavailable";
+  if (!identity.api_key || !(identity.hosted_mcp_url || identity.api_url)) {
+    return { ok: false, messages: ["identity.json lacks the stored API key / hosted URL \u2014 re-run the full setup."] };
   }
-  const hostedPart = hostedConfigured ? `hosted_${hostedStatus}` : "hosted_not_configured";
-  const signerPart = signerReady ? "local_signer_ready" : "local_signer_unavailable";
-  return `${hostedPart}_${signerPart}`.slice(0, 120);
-}
-async function resolveLocalMcpConsent(input, messages) {
-  if (input.ackLocalTools || input.ackSigner) {
-    const status = await acknowledgeLocalMcpConsent(input.identityPath, input.signerPath, (message) => messages.push(message));
-    if (status.acknowledged) {
-      messages.push("Prepared the local Haven tools acknowledgement.");
-    } else {
-      messages.push("Local Haven tools acknowledgement still needs attention.");
+  const configPath = runtimeConfigPathFor(input.runtime, homeDir);
+  if (configPath) {
+    try {
+      const existing = await readFile(configPath, "utf8");
+      if (existing.includes("bin/haven-mcp") || existing.includes(".haven/mcp-runtime")) {
+        return {
+          ok: false,
+          messages: [
+            `The config at ${configPath} is the LOCAL-stdio topology (--local). Repair currently rewrites only the hosted+signer shape and will not touch it.`,
+            "Re-run your original setup command (with --local) to repair a local-stdio install."
+          ]
+        };
+      }
+    } catch {
     }
-    return status;
   }
-  return getLocalMcpConsentStatus(input.identityPath, input.signerPath);
+  const existingSidecar = await readRuntimeSidecar(directory);
+  const serverName = existingSidecar?.server_name;
+  const signerPath = join(directory, "signer.json");
+  const prepared = await prepareSignerRuntime(
+    { credentialDirectory: directory, signerPath, homeDir, serverName },
+    { runCommand: deps.runCommand }
+  );
+  messages.push(...prepared.messages);
+  const names = serverNamesFor(serverName);
+  messages.push(`Rewriting MCP entries ${names.hosted} / ${names.signer}${serverName ? ` (agent "${serverName}")` : " (unnamed pair)"} \u2014 no other pair is touched.`);
+  const configResult = await writeRuntimeConfig({
+    runtime: input.runtime,
+    hostedMcpUrl: identity.hosted_mcp_url ?? `${identity.api_url}/mcp`,
+    apiKey: identity.api_key,
+    identityPath: join(directory, "identity.json"),
+    signerPath,
+    credentialDirectory: directory,
+    signerCommand: { command: prepared.command, args: prepared.args },
+    homeDir,
+    mode: "hosted",
+    serverName
+  });
+  messages.push(...configResult.messages);
+  messages.push("Repair complete \u2014 restart the runtime, then verify with --doctor.");
+  return { ok: true, messages };
 }
-async function resolveSignerConsent(input, messages) {
-  if (input.ackSigner || input.ackLocalTools) {
-    const status = await acknowledgeLocalSignerConsent(input.signerPath, (message) => messages.push(message));
-    if (status.acknowledged) {
-      messages.push("Prepared the local Haven signer acknowledgement.");
-    } else {
-      messages.push("Local Haven signer acknowledgement still needs attention.");
+var RERUN;
+var init_doctor = __esm({
+  "src/doctor.ts"() {
+    init_runtime_manifest();
+    init_probes();
+    init_signer_runtime();
+    init_config_writers();
+    init_runtime_registry();
+    init_signer_consent();
+    init_tombstone();
+    init_server_names();
+    init_storage();
+    init_redact();
+    RERUN = "npx @haven_ai/connect@alpha";
+  }
+});
+
+// src/runtime.ts
+init_api();
+init_key();
+init_redact();
+init_server_names();
+init_storage();
+init_runtime_install();
+init_runtime_registry();
+init_connect_error();
+
+// src/installed-clients.ts
+init_connect_error();
+init_config_writers();
+init_runtime_registry();
+var SCAN_ORDER = [
+  "claude-code",
+  "codex-cli",
+  "cursor",
+  "vscode",
+  "vscode-insiders",
+  "claude-desktop",
+  "hermes"
+];
+function installedClientTargets(homeDir = homedir(), cwd = process.cwd(), env = process.env) {
+  const targets = [
+    {
+      runtime: "claude-code",
+      label: "Claude Code",
+      // Claude Code is configured through its own CLI (`claude mcp add-json`),
+      // not by writing a file this module owns — so its evidence is the
+      // client directory, never a config path.
+      configPath: null,
+      markers: [join(homeDir, ".claude"), join(homeDir, ".claude.json")]
+    },
+    {
+      runtime: "codex-cli",
+      // Both Codex surfaces write the same ~/.codex/config.toml, so they are
+      // ONE candidate. Splitting them would ask the user to answer a question
+      // whose answers are the same write.
+      label: "Codex (CLI or Desktop)",
+      configPath: runtimeConfigPathFor("codex-cli", homeDir),
+      markers: [join(homeDir, ".codex")]
+    },
+    {
+      runtime: "cursor",
+      label: "Cursor",
+      configPath: runtimeConfigPathFor("cursor", homeDir),
+      markers: [join(homeDir, ".cursor")]
+    },
+    {
+      runtime: "vscode",
+      label: "VS Code",
+      configPath: runtimeConfigPathFor("vscode", homeDir),
+      markers: [resolve(cwd, ".vscode")]
+    },
+    {
+      runtime: "vscode-insiders",
+      label: "VS Code Insiders",
+      configPath: runtimeConfigPathFor("vscode-insiders", homeDir),
+      markers: []
+    },
+    {
+      runtime: "claude-desktop",
+      label: "Claude Desktop",
+      configPath: runtimeConfigPathFor("claude-desktop", homeDir),
+      markers: []
+    },
+    {
+      runtime: "hermes",
+      label: "Hermes Agent",
+      configPath: runtimeConfigPathFor("hermes", homeDir),
+      markers: [env.HERMES_HOME ?? join(homeDir, ".hermes")]
+    }
+  ];
+  return targets.filter((target) => runtimeProfile(target.runtime, {}).canWriteRuntimeConfig);
+}
+async function scanInstalledClients(options = {}) {
+  const exists = options.exists ?? pathExists;
+  const targets = installedClientTargets(options.homeDir, options.cwd, options.env ?? process.env);
+  const found = [];
+  for (const target of targets) {
+    if (target.configPath && await exists(target.configPath)) {
+      found.push({
+        runtime: target.runtime,
+        label: target.label,
+        detail: `MCP config found at ${target.configPath}`,
+        configPath: target.configPath,
+        evidence: "config-file"
+      });
+      continue;
+    }
+    for (const marker of target.markers) {
+      if (!await exists(marker)) continue;
+      found.push({
+        runtime: target.runtime,
+        label: target.label,
+        detail: `installed (${marker})`,
+        configPath: target.configPath,
+        evidence: "client-directory"
+      });
+      break;
     }
-    return status;
   }
-  return getLocalSignerConsentStatus(input.signerPath);
-}
-function signerConsentErrorCode(signerCredentialReady, signerConsent) {
-  if (!signerCredentialReady) return "local_signer_credential_unavailable";
-  if (!signerConsent?.acknowledged) return "local_signer_ack_required";
-  return void 0;
-}
-function signerProbeErrorCode(probe) {
-  if (!probe || probe.status === "ok") return void 0;
-  return `local_signer_probe_${probe.status}`;
-}
-function hostedMcpErrorCode(hostedConfigured, hostedProbeStatus) {
-  if (!hostedConfigured || hostedProbeStatus === "ok") return void 0;
-  return `hosted_mcp_probe_${hostedProbeStatus}`;
-}
-function localMcpErrorCode(signerCredentialReady, localMcpConsent, localMcpProbeStatus) {
-  if (!signerCredentialReady) return "local_signer_credential_unavailable";
-  if (!localMcpConsent?.acknowledged) return "local_mcp_ack_required";
-  if (localMcpProbeStatus && localMcpProbeStatus !== "ok") return `local_mcp_probe_${localMcpProbeStatus}`;
-  return void 0;
-}
-function nextAction(runtime, restartMode, errorCode) {
-  if (errorCode) return "return_to_haven_for_wallet_approval_then_finish_runtime_setup";
-  if (restartMode === "hot-reload") return "return_to_haven_for_wallet_approval";
-  if (runtime === "codex-cli" || runtime === "codex-desktop") return "return_to_haven_for_wallet_approval_then_restart_codex";
-  if (runtime === "claude-code") return "return_to_haven_for_wallet_approval_then_restart_claude_code";
-  if (restartMode === "restart-app") return "return_to_haven_for_wallet_approval_then_restart_app";
-  if (restartMode === "restart-session") return "return_to_haven_for_wallet_approval_then_restart_agent_session";
-  return "return_to_haven_for_wallet_approval_then_configure_runtime";
-}
-function supportsLocalMcp(runtime) {
-  return runtime === "codex-cli" || runtime === "codex-desktop" || runtime === "claude-code";
-}
-async function prepareRuntimeForLocalMcp(input, deps) {
-  const prepare = deps.prepareLocalMcpRuntime ?? ((runtimeInput) => prepareLocalMcpRuntime(runtimeInput, { runCommand: deps.runCommand, onProgress: deps.onProgress }));
-  return prepare({
-    credentialDirectory: input.credentialDirectory,
-    identityPath: input.identityPath,
-    signerPath: input.signerPath,
-    homeDir: deps.homeDir
+  return found.sort((a, b) => {
+    if (a.evidence !== b.evidence) return a.evidence === "config-file" ? -1 : 1;
+    return SCAN_ORDER.indexOf(a.runtime) - SCAN_ORDER.indexOf(b.runtime);
   });
 }
-async function prepareSignerForRuntime(input, deps) {
-  const prepare = deps.prepareSignerRuntime ?? ((runtimeInput) => (
-    // onProgress threaded through on purpose (#1586 review): without it the
-    // install heartbeat was dead code in production and the console still
-    // went silent for the whole cold install — the exact symptom the issue
-    // set out to remove, at a longer timeout.
-    prepareSignerRuntime(runtimeInput, { runCommand: deps.runCommand, onProgress: deps.onProgress })
-  ));
-  return prepare({
-    credentialDirectory: input.credentialDirectory,
-    signerPath: input.signerPath,
-    homeDir: deps.homeDir
+var MAX_PROMPT_ATTEMPTS = 3;
+async function promptForInstalledClient(candidates, io = defaultPromptIo()) {
+  if (candidates.length === 0) throw noInstalledClientsError();
+  io.write("Haven could not detect which agent runtime this is.\n");
+  io.write("These agent clients are installed on this machine:\n");
+  candidates.forEach((candidate, index) => {
+    io.write(`  ${index + 1}) ${candidate.label} \u2014 ${candidate.detail}
+`);
   });
+  io.write("Haven writes an API key and a signing key into the client you pick, so pick the one your agent actually runs in.\n");
+  for (let attempt = 0; attempt < MAX_PROMPT_ATTEMPTS; attempt += 1) {
+    const answer = await io.question(`Which one? [1-${candidates.length}] (default 1 \u2014 ${candidates[0].label}): `);
+    if (answer === null) throw promptAbortedError("the prompt was cancelled");
+    const trimmed = answer.trim();
+    if (trimmed === "") return candidates[0].runtime;
+    const picked = Number.parseInt(trimmed, 10);
+    if (Number.isInteger(picked) && picked >= 1 && picked <= candidates.length) {
+      return candidates[picked - 1].runtime;
+    }
+    io.write(`"${trimmed}" is not one of 1-${candidates.length}.
+`);
+  }
+  throw promptAbortedError(`no valid choice after ${MAX_PROMPT_ATTEMPTS} attempts`);
+}
+async function resolveRuntimeByInstalledClientPrompt(options = {}) {
+  const candidates = await scanInstalledClients(options);
+  if (candidates.length === 0) throw noInstalledClientsError();
+  return promptForInstalledClient(candidates, options.io ?? defaultPromptIo());
+}
+function noInstalledClientsError() {
+  return new ConnectError(
+    "runtime_no_installed_clients",
+    "Could not determine the agent runtime: nothing was detected in this environment, and no agent client Haven can configure is installed on this machine. Re-run with --runtime <name> naming the client you want configured, or --runtime other to store credentials and finish the MCP setup by hand.",
+    "rerun_connect_with_explicit_runtime"
+  );
 }
-async function runLocalMcpProbe(runtimeInstall, deps) {
-  const probe = deps.probeLocalMcpTools ?? probeLocalMcpTools;
+function promptAbortedError(reason) {
+  return new ConnectError(
+    "runtime_prompt_aborted",
+    `Runtime not chosen (${reason}). Nothing was written: no agent was created, no credentials were stored, and the Haven setup token is still unused. Run the setup command again, or pass --runtime <name> to skip the prompt.`,
+    "rerun_connect_and_choose_a_runtime"
+  );
+}
+async function pathExists(path) {
   try {
-    return await probe(runtimeInstall.command, runtimeInstall.args, MCP_RUNTIME_MANIFEST.requiredTools);
+    await access(path);
+    return true;
   } catch {
-    return { status: "process_error" };
+    return false;
   }
 }
-function localRuntimePrepareErrorCode(err) {
-  if (err && typeof err === "object" && "code" in err && err.code === "local_mcp_unsupported_node_version") {
-    return "local_mcp_unsupported_node_version";
-  }
-  return "local_mcp_runtime_install_failed";
+function defaultPromptIo() {
+  return {
+    write: (text) => process.stdout.write(text),
+    question: (query) => new Promise((resolvePromise) => {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      let settled = false;
+      const settle = (value) => {
+        if (settled) return;
+        settled = true;
+        rl.close();
+        resolvePromise(value);
+      };
+      rl.once("SIGINT", () => settle(null));
+      rl.once("close", () => settle(null));
+      rl.question(query, (answer) => settle(answer));
+    })
+  };
 }
 
 // src/runtime.ts
-init_runtime_registry();
+init_local_mcp_runtime();
 init_runtime_manifest();
-var CONNECTOR_VERSION = "0.1.28-alpha.0";
+var CONNECTOR_VERSION = "0.1.30-alpha.0";
 var CONNECT_OUTCOME_SCHEMA_VERSION = 1;
 async function runConnect(options, deps = {}) {
   assertSupportedNodeVersion(deps.nodeVersion, MCP_RUNTIME_MANIFEST.minimumNodeVersion);
@@ -2504,24 +3712,49 @@ async function runConnect(options, deps = {}) {
   const runRuntimeInstall = deps.installRuntime ?? installRuntime;
   const generateKey = deps.generateKey ?? generateDelegateKey;
   const generateLocalApiKey = deps.generateApiKey ?? generateAgentApiKey;
-  const installCapabilities = runtimeInstallCapabilities(options.runtime);
+  const selection = await resolveRuntimeSelection(options.runtime, options.runtimeForce, {
+    env: deps.env ?? process.env,
+    selfReported: options.runtimeSelfReport,
+    promptForRuntime: runtimeSelectionPrompt(options, deps)
+  });
+  if (!selection.runtime) {
+    throw new ConnectError(
+      "runtime_undetermined",
+      `Could not determine the agent runtime: nothing was detected in this environment and no --runtime was given. If you are an AI agent running this command: re-run it once, unchanged except for adding --runtime <name>, naming the harness you are running in \u2014 one of: ${RUNTIME_FLAG_VALUES} (the aliases cowork, codex and openclaw are accepted too). Do not guess: if your harness is not one of those, use --runtime other, which stores the credentials and prints the manual MCP steps. Nothing was written and the Haven setup token is still unused.`,
+      "rerun_connect_with_explicit_runtime"
+    );
+  }
+  const runtime = selection.runtime;
+  const installCapabilities = runtimeInstallCapabilities(runtime);
   if (options.localMcp) {
-    const resolvedRuntime = normalizeRuntime(options.runtime);
-    if (!supportsLocalMcp(resolvedRuntime)) {
+    if (!supportsLocalMcp(runtime)) {
       throw new Error(
-        `--local (fully-local Haven MCP) is only available for Claude Code and Codex. The detected runtime is ${runtimeProfile(resolvedRuntime).label}. Re-run without --local to use the default hosted MCP + local signer setup.`
+        `--local (fully-local Haven MCP) is only available for Claude Code and Codex. The detected runtime is ${runtimeProfile(runtime).label}. Re-run without --local to use the default hosted MCP + local signer setup.`
       );
     }
   }
+  if (selection.overrodeHint) {
+    log(`runtime: ${runtime} (detected; ignoring the ${selection.overrodeHint} hint \u2014 pass --runtime-force ${selection.overrodeHint} to override)`);
+  }
+  if (selection.discardedHint) {
+    log(`runtime: ${runtime} (detected; "${selection.discardedHint}" is not a runtime Haven knows \u2014 valid values: ${RUNTIME_FLAG_VALUES})`);
+  }
+  if (selection.source === "prompted") {
+    log(`runtime: ${runtime} (chosen at the prompt \u2014 nothing was detected in this environment)`);
+  }
   log("Warming up your connection to Haven\u2026");
   const setup = await api.resolveSetup({
     setupToken: options.setupToken,
     connectorVersion,
-    runtime: options.runtime
+    runtime
   });
   assertSetupChallengeIsUsable(setup.challenge.expires_at);
   printSetupSummary(setup, log);
   await preflightStorage({ baseDir: options.credentialsDir, warn: log });
+  if (options.serverName) {
+    assertValidServerSlug(options.serverName);
+    await assertServerSlugAvailable(options.serverName, options.credentialsDir);
+  }
   log("Checked local credential storage \u2014 all clear.");
   const localKey = generateKey();
   const localApiKey = generateLocalApiKey();
@@ -2533,12 +3766,17 @@ async function runConnect(options, deps = {}) {
     registration = await api.registerSetup({
       setupToken: options.setupToken,
       connectorVersion,
-      runtime: options.runtime,
+      runtime,
       challengeId: setup.challenge.id,
       delegateAddress: localKey.address,
       proofSignature,
       apiKeyHash: hashAgentApiKey(localApiKey),
       apiKeyPrefix: agentApiKeyPrefix(localApiKey),
+      // #1878: report the pair we are ACTUALLY wiring, bare pair included, so
+      // the dashboard can name it. Derived here rather than sent as the raw
+      // slug — `serverNamesFor` is the one place the naming rule lives, and
+      // the hosted name is what a user pastes into an MCP config.
+      mcpServerName: serverNamesFor(options.serverName).hosted,
       connectorContext: {
         environment_label: options.environmentLabel ?? "Local workspace",
         config_target: installCapabilities.canWriteRuntimeConfig ? "agent runtime MCP config" : "local credential files"
@@ -2558,6 +3796,7 @@ async function runConnect(options, deps = {}) {
   const credentialPaths = await writeCredentials({
     baseDir: options.credentialsDir,
     agentId: registration.agent_id,
+    serverName: options.serverName,
     apiKey: localApiKey,
     delegateKey: localKey.privateKey,
     delegateAddress: localKey.address,
@@ -2585,7 +3824,7 @@ async function runConnect(options, deps = {}) {
     );
   }
   const runtimeInstall = await runRuntimeInstall({
-    runtime: options.runtime,
+    runtime,
     hostedMcpUrl: registration.hosted_mcp_url,
     apiKey: localApiKey,
     signerPath: credentialPaths.signerPath,
@@ -2594,7 +3833,8 @@ async function runConnect(options, deps = {}) {
     environmentLabel: options.environmentLabel ?? "Local workspace",
     ackSigner: options.ackSigner,
     ackLocalTools: options.ackLocalTools,
-    localMcp: options.localMcp
+    localMcp: options.localMcp,
+    serverName: options.serverName
   }, {
     onProgress: log,
     // #1543: report "runtime configured" the moment the config write settles,
@@ -2630,6 +3870,19 @@ async function runConnect(options, deps = {}) {
   } else {
     log("Haven setup on this machine is complete.");
   }
+  try {
+    const supersededIds = await listOtherAgentIds(options.credentialsDir, credentialPaths.directory);
+    if (supersededIds.length > 0) {
+      log("");
+      log(
+        `Heads-up: this setup created a NEW agent. Your previous agent(s) \u2014 ${supersededIds.join(", ")} \u2014 still exist with their own keys, and any host that was already running keeps acting as them.`
+      );
+      log(
+        `If you meant to replace them: revoke them on the Haven agent page, then restart EVERY long-lived host (gateways, TUI workers, editors) \u2014 each holds the MCP wiring snapshot from its own start time, so after repeated setups each can be stuck on a DIFFERENT old agent. Then remove their directories under ~/.haven/agents (or ${RERUN_HINT} --tombstone <dir> to leave a diagnostic in their place). Run ${RERUN_HINT} --doctor to check whether their keys are still live.`
+      );
+    }
+  } catch {
+  }
   try {
     await api.updateInstallStatus(registration.setup_id, localApiKey, {
       runtime: runtimeInstall.runtime,
@@ -2704,11 +3957,16 @@ function completionOutcome(input) {
   };
   return outcome;
 }
+function runtimeSelectionPrompt(options, deps) {
+  if (options.interactive !== true) return void 0;
+  if (!(deps.isTty ?? Boolean(process.stdin.isTTY))) return void 0;
+  return deps.promptRuntime ?? (() => resolveRuntimeByInstalledClientPrompt());
+}
 function failedConnectOutcome(runtimeHint, error) {
   const message = error instanceof Error ? error.message : "";
-  const code = /Node\.js >=/i.test(message) ? "unsupported_node_version" : /setup challenge.*expired|expired or invalid/i.test(message) ? "setup_challenge_expired_or_invalid" : /only available for Claude Code and Codex/i.test(message) ? "local_mcp_unsupported_runtime" : "connect_failed";
+  const code = error instanceof ConnectError ? error.code : /Node\.js >=/i.test(message) ? "unsupported_node_version" : /setup challenge.*expired|expired or invalid/i.test(message) ? "setup_challenge_expired_or_invalid" : /only available for Claude Code and Codex/i.test(message) ? "local_mcp_unsupported_runtime" : "connect_failed";
   const runtime = normalizeRuntime(runtimeHint);
-  const nextAction2 = code === "setup_challenge_expired_or_invalid" ? "return_to_haven_for_fresh_setup" : code === "unsupported_node_version" ? "install_supported_node_and_rerun_connect" : code === "local_mcp_unsupported_runtime" ? "rerun_without_local_mcp" : "review_the_safe_error_output_and_start_a_fresh_haven_setup_if_needed";
+  const nextAction2 = error instanceof ConnectError ? error.nextAction : code === "setup_challenge_expired_or_invalid" ? "return_to_haven_for_fresh_setup" : code === "unsupported_node_version" ? "install_supported_node_and_rerun_connect" : code === "local_mcp_unsupported_runtime" ? "rerun_without_local_mcp" : "review_the_safe_error_output_and_start_a_fresh_haven_setup_if_needed";
   return {
     schema_version: CONNECT_OUTCOME_SCHEMA_VERSION,
     outcome: "failed",
@@ -2794,7 +4052,7 @@ function describeApprovedBudget(budget) {
 async function waitForBudgetApproval(api, setupId, apiKey, log, options = {}) {
   const intervalMs = options.intervalMs ?? 5e3;
   const timeoutMs = options.timeoutMs ?? 18e4;
-  const sleep = options.sleep ?? ((ms) => new Promise((resolve8) => setTimeout(resolve8, ms)));
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve9) => setTimeout(resolve9, ms)));
   const maxPolls = Math.max(1, Math.floor(timeoutMs / intervalMs));
   const remindEvery = Math.max(1, Math.floor(3e4 / intervalMs));
   let waitingAnnounced = false;
@@ -2880,11 +4138,39 @@ function activationInstructionWithWhy(profile) {
   }
   return profile.activationInstruction;
 }
+var RERUN_HINT = "npx @haven_ai/connect@alpha";
+async function listOtherAgentIds(baseDir, currentDirectory) {
+  const root = defaultCredentialRoot(baseDir);
+  let entries = [];
+  try {
+    entries = await readdir(root);
+  } catch {
+    return [];
+  }
+  const ids = [];
+  for (const entry of entries) {
+    if (join(root, entry) === currentDirectory) continue;
+    const identityPath = join(root, entry, "identity.json");
+    try {
+      await stat(identityPath);
+    } catch {
+      continue;
+    }
+    try {
+      const identity = JSON.parse(await readFile(identityPath, "utf8"));
+      ids.push(identity.agent_id ?? entry);
+    } catch {
+      ids.push(entry);
+    }
+  }
+  return ids;
+}
 function printNextSteps(result, log, approval) {
   for (const line of completionHandoffLines(result, approval)) log(line);
 }
 
 // src/args.ts
+init_server_names();
 function parseArgs(argv, env = process.env) {
   const options = {
     apiBaseUrl: env.HAVEN_API_URL ?? "http://localhost:3001",
@@ -2894,6 +4180,11 @@ function parseArgs(argv, env = process.env) {
   let json = false;
   let doctor = false;
   let repair = false;
+  let rekeyPhase;
+  let newApiKey;
+  let tombstoneDir;
+  let tombstoneReason;
+  let tombstoneReplacedBy;
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
     if (arg === "--help" || arg === "-h") {
@@ -2904,14 +4195,31 @@ function parseArgs(argv, env = process.env) {
       doctor = true;
     } else if (arg === "--repair") {
       repair = true;
+    } else if (arg === "--rekey") {
+      rekeyPhase = "start";
+    } else if (arg === "--rekey-finish") {
+      rekeyPhase = "finish";
+    } else if (arg === "--api-key") {
+      newApiKey = requireValue(argv, ++i, arg);
+    } else if (arg === "--tombstone") {
+      tombstoneDir = requireValue(argv, ++i, arg);
+    } else if (arg === "--reason") {
+      tombstoneReason = requireValue(argv, ++i, arg);
+    } else if (arg === "--replaced-by") {
+      tombstoneReplacedBy = requireValue(argv, ++i, arg);
     } else if (arg === "--setup" || arg === "--setup-token") {
       options.setupToken = requireValue(argv, ++i, arg);
     } else if (arg === "--api" || arg === "--api-url") {
       options.apiBaseUrl = requireValue(argv, ++i, arg);
     } else if (arg === "--runtime") {
       options.runtime = requireValue(argv, ++i, arg);
+    } else if (arg === "--runtime-force") {
+      options.runtimeForce = requireValue(argv, ++i, arg);
     } else if (arg === "--credentials-dir") {
       options.credentialsDir = requireValue(argv, ++i, arg);
+    } else if (arg === "--name") {
+      options.serverName = requireValue(argv, ++i, arg);
+      assertValidServerSlug(options.serverName);
     } else if (arg === "--environment-label") {
       options.environmentLabel = requireValue(argv, ++i, arg);
     } else if (arg === "--ack-local-tools") {
@@ -2929,14 +4237,39 @@ function parseArgs(argv, env = process.env) {
       throw new Error(`Unknown option: ${arg}`);
     }
   }
+  const tombstone = tombstoneDir ? { directory: tombstoneDir, reason: tombstoneReason, replacedBy: tombstoneReplacedBy } : void 0;
+  const rekey = rekeyPhase ? { phase: rekeyPhase, newApiKey } : void 0;
   if (help) {
-    return { options, help, json, doctor, repair };
+    return { options, help, json, doctor, repair, tombstone, rekey };
+  }
+  if (rekey) {
+    if (options.setupToken) {
+      throw new Error("--rekey replaces an existing agent's key; it does not take --setup. Drop one of them.");
+    }
+    if (rekey.phase === "start" && newApiKey !== void 0) {
+      throw new Error(
+        "--api-key belongs to --rekey-finish. --rekey generates the new key here and prints the address to paste into Haven; the API key does not exist yet."
+      );
+    }
+    if (rekey.phase === "finish" && !newApiKey) {
+      throw new Error("--rekey-finish needs --api-key <key> \u2014 the one the Haven agent page showed once.");
+    }
+    return { options, help, json, doctor, repair, tombstone, rekey };
+  }
+  if (newApiKey !== void 0) {
+    throw new Error("--api-key requires --rekey-finish.");
+  }
+  if (!tombstoneDir && (tombstoneReason !== void 0 || tombstoneReplacedBy !== void 0)) {
+    throw new Error("--reason and --replaced-by require --tombstone <dir>.");
+  }
+  if (tombstone) {
+    return { options, help, json, doctor, repair, tombstone, rekey };
   }
   if (doctor || repair) {
     if (!options.runtime) {
       throw new Error("--doctor/--repair need --runtime <runtime> (which config to examine).");
     }
-    return { options, help, json, doctor, repair };
+    return { options, help, json, doctor, repair, tombstone, rekey };
   }
   if (!options.setupToken) {
     throw new Error("Missing --setup <hv_setup_...> setup token.");
@@ -2945,7 +4278,7 @@ function parseArgs(argv, env = process.env) {
     throw new Error("Missing --api <Haven API URL>.");
   }
   options.apiBaseUrl = options.apiBaseUrl.replace(/\/+$/, "");
-  return { options, help, json, doctor, repair };
+  return { options, help, json, doctor, repair, tombstone, rekey };
 }
 function helpText() {
   return [
@@ -2955,14 +4288,23 @@ function helpText() {
     "sends Haven only the public signing address plus a proof signature.",
     "",
     "Usage:",
-    "  npx -y @haven_ai/connect --setup hv_setup_... --api https://api.haven.example --ack-local-tools --runtime claude-code",
+    "  npx -y @haven_ai/connect --setup hv_setup_... --api https://api.haven.example --ack-local-tools",
     "",
     "Options:",
     "  --setup <token>            Short-lived setup token from Haven.",
     "  --api <url>                Haven backend API URL. Defaults to HAVEN_API_URL or http://localhost:3001.",
     "  --runtime <name>           Agent runtime hint, such as claude-code, codex-cli, codex-desktop, cursor, vscode, claude-desktop, or hermes.",
+    "                             Usually unnecessary: the connector detects the runtime it runs inside, and a detection",
+    "                             that contradicts this hint wins (with a printed notice). When nothing is detected, an",
+    "                             interactive terminal is offered the agent clients installed on this machine; this flag is",
+    "                             how an agent, or a non-interactive run, answers instead. An unknown name is refused, never guessed.",
+    "  --runtime-force <name>     Escape hatch: use exactly this runtime, ignoring environment detection.",
     "  --credentials-dir <path>   Credential directory fallback. Defaults to ~/.haven/agents.",
     "  --environment-label <text> Non-sensitive label shown in Haven setup review.",
+    "  --name <slug>              Wiring slug for a NAMED agent: writes haven-<slug> / haven-signer-<slug>",
+    "                             MCP entries and stores credentials at ~/.haven/agents/<slug>/, so several",
+    "                             agents can run side by side in one runtime. 1-32 lowercase letters, digits,",
+    "                             single hyphens; immutable once wired. Omit for the bare haven / haven-signer pair.",
     "  --ack-local-tools          Write the one-time local Haven tools acknowledgement during setup.",
     "  --ack-signer               Backward-compatible alias for --ack-local-tools.",
     "  --local                    Advanced: install the fully-local Haven MCP (no hosted dependency).",
@@ -2973,6 +4315,19 @@ function helpText() {
     "  --repair                   Repair, then re-diagnose (implies --doctor): reinstall the pinned signer",
     "                             runtime, rewrite the wrapper and runtime config from stored credentials.",
     "                             Hosted topology only (refuses to touch a --local config). No keys, no token.",
+    "  --rekey                    Replace this agent's signing key (no token). Generates a fresh keypair HERE and",
+    "                             prints its public address to paste into the Haven agent page. Nothing changes",
+    "                             until you finish; the agent keeps working on its old key throughout.",
+    "                             Add --name <slug> for a named agent. Refuses a legacy-rail or revoked agent.",
+    "  --rekey-finish             Second half of --rekey: writes the new key and the API key the agent page",
+    "                             showed once, in place at the same path, and rewrites only this agent's MCP",
+    "                             config pair. Server names do not change, so wired hosts need only a restart.",
+    "  --api-key <key>            The new API key, for --rekey-finish.",
+    "  --tombstone <dir>          Retire an agent credential directory in place (no token): replaces its signer",
+    "                             wrapper with a diagnostic that names the retirement in MCP stderr logs, and",
+    "                             writes TOMBSTONE.json. Touches NO key material and revokes nothing.",
+    "  --reason <text>            Reason recorded in the tombstone (with --tombstone).",
+    "  --replaced-by <agent-id>   Successor agent recorded in the tombstone (with --tombstone).",
     "  --help                     Show this help.",
     "",
     "The connector never prints the private key and never sends it to Haven. JSON output never includes credential contents or full credential paths."
@@ -2987,6 +4342,7 @@ function requireValue(argv, index, option) {
 }
 
 // src/cli.ts
+init_redact();
 async function runCli(argv, io = {
   stdout: (message) => process.stdout.write(message),
   stderr: (message) => process.stderr.write(message)
@@ -3010,6 +4366,103 @@ async function runCli(argv, io = {
 `);
     return 0;
   }
+  if (parsed.tombstone) {
+    const { writeAgentTombstone: writeAgentTombstone2 } = await Promise.resolve().then(() => (init_tombstone(), tombstone_exports));
+    const { readFile: readFile12 } = await import('fs/promises');
+    const { join: join10 } = await import('path');
+    try {
+      let agentId = "unknown";
+      try {
+        const identity = JSON.parse(
+          await readFile12(join10(parsed.tombstone.directory, "identity.json"), "utf8")
+        );
+        agentId = identity.agent_id ?? "unknown";
+      } catch {
+      }
+      const info = await writeAgentTombstone2({
+        directory: parsed.tombstone.directory,
+        agentId,
+        reason: parsed.tombstone.reason ?? "retired by operator via --tombstone",
+        replacedBy: parsed.tombstone.replacedBy
+      });
+      if (parsed.json) {
+        io.stdout(`${redactSecrets(JSON.stringify({ tombstoned: true, ...info }))}
+`);
+      } else {
+        io.stdout(redactSecrets(`Tombstoned agent ${info.agent_id} at ${parsed.tombstone.directory}.
+`));
+        io.stdout(
+          "Key files were NOT touched and nothing was revoked \u2014 revoke the agent on the Haven agent page if you have not already.\n"
+        );
+        io.stdout(
+          "Restart EVERY long-lived MCP host (gateway, TUI workers, editors): each holds the wiring snapshot from its own start time, and the tombstone only speaks when a stale host next probes the old path.\n"
+        );
+      }
+      return 0;
+    } catch (err) {
+      io.stderr(`${redactSecrets(err instanceof Error ? err.message : String(err))}
+`);
+      return 1;
+    }
+  }
+  if (parsed.rekey) {
+    const { startRekey: startRekey2, finishRekey: finishRekey2 } = await Promise.resolve().then(() => (init_rekey(), rekey_exports));
+    const { restartGuidance: restartGuidance2 } = await Promise.resolve().then(() => (init_rekey_restart(), rekey_restart_exports));
+    const common = {
+      serverName: parsed.options.serverName,
+      credentialsDir: parsed.options.credentialsDir,
+      runtime: parsed.options.runtime
+    };
+    try {
+      if (parsed.rekey.phase === "start") {
+        const result2 = await startRekey2(common);
+        if (parsed.json) {
+          io.stdout(
+            `${redactSecrets(
+              JSON.stringify({
+                rekey: "started",
+                agent_id: result2.agentId,
+                new_delegate_address: result2.newDelegateAddress,
+                expires_at: result2.expiresAt
+              })
+            )}
+`
+          );
+        } else {
+          for (const line of result2.messages) io.stdout(redactSecrets(`${line}
+`));
+        }
+        return 0;
+      }
+      const result = await finishRekey2({ ...common, newApiKey: parsed.rekey.newApiKey });
+      const restart = restartGuidance2(parsed.options.runtime);
+      if (parsed.json) {
+        io.stdout(
+          `${redactSecrets(
+            JSON.stringify({
+              rekey: "finished",
+              agent_id: result.agentId,
+              new_delegate_address: result.newDelegateAddress,
+              mcp_servers: result.serverNames,
+              restart_commands: restart.commands
+            })
+          )}
+`
+        );
+      } else {
+        for (const line of result.messages) io.stdout(redactSecrets(`${line}
+`));
+        io.stdout("\n");
+        for (const line of restart.lines) io.stdout(redactSecrets(`${line}
+`));
+      }
+      return 0;
+    } catch (err) {
+      io.stderr(`${redactSecrets(err instanceof Error ? err.message : String(err))}
+`);
+      return 1;
+    }
+  }
   if (parsed.doctor || parsed.repair) {
     const { runDoctor: runDoctor2, runRepair: runRepair2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
     const runtime = parsed.options.runtime ?? "";
@@ -3032,6 +4485,23 @@ async function runCli(argv, io = {
           if (check.repair) io.stdout(redactSecrets(`    \u21B3 repair: ${check.repair}
 `));
         }
+        const otherAgents = report.agents.filter((agent) => agent.directory !== report.credentialDirectory);
+        if (otherAgents.length > 0) {
+          io.stdout("\nOther agents on this machine:\n");
+          for (const agent of otherAgents) {
+            const name = agent.slug ? `${agent.slug} (${agent.agentId ?? "unknown"})` : agent.agentId ?? "unknown";
+            const failed = agent.checks.filter((check) => !check.ok);
+            const verdict = agent.classification === "wired" ? failed.length === 0 ? "wired, all checks passed" : `wired, ${failed.length} check(s) FAILED` : agent.classification === "parked" ? "parked re-key only \u2014 no identity.json in this directory, but key material is still there" : agent.classification;
+            io.stdout(redactSecrets(`  ${failed.length > 0 ? "\u2717" : "\u2022"} ${name}: ${verdict}
+`));
+            for (const check of failed) {
+              io.stdout(redactSecrets(`      \u2717 ${check.label}: ${check.detail}
+`));
+              if (check.repair) io.stdout(redactSecrets(`        \u21B3 repair: ${check.repair}
+`));
+            }
+          }
+        }
         io.stdout(report.ok ? "All checks passed.\n" : "One or more checks FAILED \u2014 see repairs above.\n");
       }
       return report.ok ? 0 : 1;
@@ -3043,7 +4513,15 @@ async function runCli(argv, io = {
   }
   try {
     const result = await runConnect(
-      { ...parsed.options, waitForApproval: !parsed.json },
+      {
+        ...parsed.options,
+        waitForApproval: !parsed.json,
+        // #1719: only a human-facing run may be asked which installed client to
+        // configure. --json is the automation contract — it must fail with a
+        // machine-readable code, never block on stdin. runConnect additionally
+        // requires a real TTY before it prompts.
+        interactive: !parsed.json
+      },
       {
         log: (message) => (parsed.json ? io.stderr : io.stdout)(`${message}
 `),