@haven_ai/connect 0.0.0-dev.202609250737.3bd5a51 → 0.0.0-dev.202609251409.98ed67a

package/dist/cli.js

@@ -4,15 +4,15 @@ import { Wallet } from 'ethers';
 import { mkdir, rm, stat, readdir, readFile, writeFile, chmod, access, unlink, realpath, 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 { connectorRerunCommand, isSupportedNodeVersion, SKILL_FOLDER_NAME, resolveTokenFromAddress, HAVEN_SKILL_MD, HAVEN_SKILL_BODY_MD, HAVEN_MINIMUM_NODE_VERSION, unsupportedNodeVersionMessage } from '@haven_ai/sdk';
+import { MCP_VERSION, registeredToolNames, ensureConsent, computeConsentHash, loadCredentials, consentInputFromClient } from '@haven_ai/mcp';
+import { toolSchemas, ensureSignerConsent, computeSignerConsentHash, loadSignerCredentials, createEdgeSigner } from '@haven_ai/signer';
+import { connectorRerunCommand, HAVEN_MINIMUM_NODE_VERSION, isSupportedNodeVersion, SKILL_FOLDER_NAME, resolveTokenFromAddress, HAVEN_SKILL_MD, HAVEN_SKILL_BODY_MD, unsupportedNodeVersionMessage } from '@haven_ai/sdk';
 import { parseDocument, isMap, stringify } from 'yaml';
-import { spawn, execFile } from 'child_process';
+import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
+import { createInterface } from 'readline';
 import { realpathSync } from 'fs';
 import { fileURLToPath, pathToFileURL } from 'url';
-import { createInterface } from 'readline';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -25,10 +25,11 @@ var __export = (target, all) => {
 };
 
 // src/api.ts
-function createConnectApiClient(baseUrl, fetchImpl = fetch) {
+function createConnectApiClient(baseUrl, fetchImpl = fetch, clientIdentity) {
   const root = baseUrl.replace(/\/+$/, "");
+  const send = (url, init) => request(fetchImpl, url, clientIdentity ? { ...init, headers: { ...init.headers, "X-Haven-Client": clientIdentity } } : init);
   return {
-    resolveSetup: (input) => request(fetchImpl, `${root}/agent-connection-setups/resolve`, {
+    resolveSetup: (input) => send(`${root}/agent-connection-setups/resolve`, {
       method: "POST",
       body: JSON.stringify({
         setup_token: input.setupToken,
@@ -36,7 +37,7 @@ function createConnectApiClient(baseUrl, fetchImpl = fetch) {
         runtime: input.runtime
       })
     }),
-    registerSetup: (input) => request(fetchImpl, `${root}/agent-connection-setups/register`, {
+    registerSetup: (input) => send(`${root}/agent-connection-setups/register`, {
       method: "POST",
       body: JSON.stringify({
         setup_token: input.setupToken,
@@ -56,16 +57,16 @@ function createConnectApiClient(baseUrl, fetchImpl = fetch) {
         }
       })
     }),
-    getAgentIdentity: (apiKey) => request(fetchImpl, `${root}/machine-payments/agent`, {
+    getAgentIdentity: (apiKey) => send(`${root}/machine-payments/agent`, {
       method: "GET",
       headers: { Authorization: `Bearer ${apiKey}` }
     }),
-    getConnectorStatus: (setupId, apiKey) => request(fetchImpl, `${root}/agent-connection-setups/${encodeURIComponent(setupId)}/connector-status`, {
+    getConnectorStatus: (setupId, apiKey) => send(`${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`, {
+      await send(`${root}/agent-connection-setups/${encodeURIComponent(setupId)}/install-status`, {
         method: "POST",
         headers: { Authorization: `Bearer ${apiKey}` },
         body: JSON.stringify({
@@ -612,9 +613,9 @@ var init_runtime_manifest = __esm({
       mcpPackage: "@haven_ai/mcp",
       mcpVersion: MCP_VERSION,
       sdkPackage: "@haven_ai/sdk",
-      sdkVersion: "0.0.0-dev.202609250737.3bd5a51",
+      sdkVersion: "0.0.0-dev.202609251409.98ed67a",
       signerPackage: "@haven_ai/signer",
-      signerVersion: "0.0.0-dev.202609250737.3bd5a51",
+      signerVersion: "0.0.0-dev.202609251409.98ed67a",
       // 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
@@ -2989,6 +2990,185 @@ var init_runtime_install = __esm({
     execFileAsync3 = promisify(execFile);
   }
 });
+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 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);
+  });
+}
+function installedClientHint(candidates) {
+  const installedClients = candidates.map((candidate) => candidate.runtime);
+  if (candidates.length === 1) {
+    return { installedClients, suggestedRuntime: candidates[0].runtime };
+  }
+  const configured = candidates.filter((candidate) => candidate.evidence === "config-file");
+  return configured.length === 1 ? { installedClients, suggestedRuntime: configured[0].runtime } : { installedClients };
+}
+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"
+  );
+}
+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 connector command again, or pass --runtime <name> to skip the prompt.`,
+    "rerun_connect_and_choose_a_runtime"
+  );
+}
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+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));
+    })
+  };
+}
+var SCAN_ORDER, MAX_PROMPT_ATTEMPTS;
+var init_installed_clients = __esm({
+  "src/installed-clients.ts"() {
+    init_connect_error();
+    init_config_writers();
+    init_runtime_registry();
+    SCAN_ORDER = [
+      "claude-code",
+      "codex-cli",
+      "cursor",
+      "vscode",
+      "vscode-insiders",
+      "claude-desktop",
+      "hermes"
+    ];
+    MAX_PROMPT_ATTEMPTS = 3;
+  }
+});
 
 // src/tombstone.ts
 var tombstone_exports = {};
@@ -3121,47 +3301,158 @@ var init_tombstone = __esm({
     TOMBSTONE_MARKER = "HAVEN-TOMBSTONE";
   }
 });
-
-// src/unwire.ts
-var unwire_exports = {};
-__export(unwire_exports, {
-  readIdentityFile: () => readIdentityFile,
-  teardownLocalKeyMaterial: () => teardownLocalKeyMaterial,
-  tombstoneDirectoryIfAbsent: () => tombstoneDirectoryIfAbsent,
-  unwireAgent: () => unwireAgent
-});
-function identityAt(directory) {
-  return readFile(join(directory, "identity.json"), "utf8").then((raw) => JSON.parse(raw)).catch(() => null);
-}
-function removeForModel(text, model, names, path) {
-  switch (model.kind) {
-    case "yaml":
-      return removeHermesYaml(text, names, path);
-    case "toml":
-      return removeCodexToml(text, names);
-    case "json":
-      return removeJsonMcpConfig(text, model.serverRoot ?? "mcpServers", names, path);
+async function detectWiringCollision(input) {
+  const root = defaultCredentialRoot(input.credentialsDir);
+  let entries = [];
+  try {
+    entries = await readdir(root);
+  } catch {
+    return null;
+  }
+  const superseded = [];
+  const taken = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const directory = join(root, entry);
+    let identityRaw;
+    try {
+      identityRaw = await readFile(join(directory, "identity.json"), "utf8");
+    } catch {
+      continue;
+    }
+    taken.add(entry);
+    let identity;
+    try {
+      identity = JSON.parse(identityRaw);
+    } catch {
+      identity = void 0;
+    }
+    if (!identity?.api_key) continue;
+    if (await pathExists2(join(directory, TOMBSTONE_FILENAME))) continue;
+    const sidecar = await readRuntimeSidecar(directory);
+    if (sidecar?.server_name) continue;
+    superseded.push({ directory, agentId: identity.agent_id ?? entry });
   }
+  if (superseded.length === 0) return null;
+  return {
+    superseded,
+    suggestedServerName: proposeServerSlug(input.agentName, taken)
+  };
 }
-function envLineValue(envText, envKey) {
-  const line = envText.split(/\r?\n/).find((candidate) => new RegExp(`^\\s*(?:export[ \\t]+)?${envKey}[ \\t]*=`).test(candidate));
-  if (!line) return void 0;
-  let value = line.slice(line.indexOf("=") + 1);
-  value = value.trim();
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    value = value.slice(1, -1);
+function proposeServerSlug(agentName, taken) {
+  let base = agentName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").slice(0, 32).replace(/-+$/g, "");
+  if (!slugIsValid(base)) base = "agent";
+  if (!taken.has(base)) return base;
+  for (let n = 2; n < 1e3; n += 1) {
+    const suffix = `-${n}`;
+    const candidate = `${base.slice(0, 32 - suffix.length).replace(/-+$/g, "")}${suffix}`;
+    if (slugIsValid(candidate) && !taken.has(candidate)) return candidate;
   }
-  return value;
+  throw new Error(`Could not propose an unused server name for ${JSON.stringify(agentName)}.`);
 }
-async function readOptionalText(path) {
+function slugIsValid(slug) {
   try {
-    return await readFile(path, "utf8");
+    assertValidServerSlug(slug);
+    return true;
   } catch {
-    return null;
+    return false;
   }
 }
-async function unwireAgent(input) {
-  const homeDir = input.homeDir ?? homedir();
+async function promptWiringCollisionResolution(collision, agentName, io) {
+  const ids = collision.superseded.map((entry) => entry.agentId).join(", ");
+  io.write(`This machine is already wired to a Haven agent with a live key: ${ids}.
+`);
+  io.write(`Setting up "${agentName}" on the bare haven / haven-signer pair would replace that wiring.
+`);
+  io.write("  r) replace \u2014 re-point haven / haven-signer at the new agent and retire the previous directory locally\n");
+  io.write("     (tombstoned, local key files removed; you still revoke it on the Haven agent page)\n");
+  io.write(`  a) alongside \u2014 install as a named agent (suggested: ${collision.suggestedServerName}) with its own
+`);
+  io.write(`     haven-<name> / haven-signer-<name> pair, leaving the current wiring untouched
+`);
+  io.write("  q) quit \u2014 nothing is written and the setup token stays unused\n");
+  for (let attempt = 0; attempt < MAX_PROMPT_ATTEMPTS2; attempt += 1) {
+    const answer = await io.question("Replace, install alongside, or quit? [r/a/q]: ");
+    if (answer === null) return { action: "abort" };
+    const trimmed = answer.trim().toLowerCase();
+    if (trimmed === "r" || trimmed === "replace") return { action: "replace" };
+    if (trimmed === "q" || trimmed === "quit") return { action: "abort" };
+    if (trimmed === "a" || trimmed === "alongside") {
+      const typed = await io.question(`Server name [${collision.suggestedServerName}]: `);
+      if (typed === null) return { action: "abort" };
+      const serverName = typed.trim() === "" ? collision.suggestedServerName : typed.trim();
+      try {
+        assertValidServerSlug(serverName);
+      } catch (err) {
+        io.write(`${err instanceof Error ? err.message : String(err)}
+`);
+        continue;
+      }
+      return { action: "alongside", serverName };
+    }
+    io.write(`"${trimmed}" is not one of r, a, q.
+`);
+  }
+  return { action: "abort" };
+}
+async function pathExists2(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var MAX_PROMPT_ATTEMPTS2;
+var init_wiring_collision = __esm({
+  "src/wiring-collision.ts"() {
+    init_server_names();
+    init_signer_runtime();
+    init_storage();
+    init_tombstone();
+    MAX_PROMPT_ATTEMPTS2 = 3;
+  }
+});
+
+// src/unwire.ts
+var unwire_exports = {};
+__export(unwire_exports, {
+  readIdentityFile: () => readIdentityFile,
+  teardownLocalKeyMaterial: () => teardownLocalKeyMaterial,
+  tombstoneDirectoryIfAbsent: () => tombstoneDirectoryIfAbsent,
+  unwireAgent: () => unwireAgent
+});
+function identityAt(directory) {
+  return readFile(join(directory, "identity.json"), "utf8").then((raw) => JSON.parse(raw)).catch(() => null);
+}
+function removeForModel(text, model, names, path) {
+  switch (model.kind) {
+    case "yaml":
+      return removeHermesYaml(text, names, path);
+    case "toml":
+      return removeCodexToml(text, names);
+    case "json":
+      return removeJsonMcpConfig(text, model.serverRoot ?? "mcpServers", names, path);
+  }
+}
+function envLineValue(envText, envKey) {
+  const line = envText.split(/\r?\n/).find((candidate) => new RegExp(`^\\s*(?:export[ \\t]+)?${envKey}[ \\t]*=`).test(candidate));
+  if (!line) return void 0;
+  let value = line.slice(line.indexOf("=") + 1);
+  value = value.trim();
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    value = value.slice(1, -1);
+  }
+  return value;
+}
+async function readOptionalText(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function unwireAgent(input) {
+  const homeDir = input.homeDir ?? homedir();
   const [identity, sidecar] = await Promise.all([identityAt(input.directory), readRuntimeSidecar(input.directory)]);
   const agentId = identity?.agent_id ?? "unknown";
   const slug = input.slug ?? sidecar?.server_name;
@@ -3353,2294 +3644,2016 @@ var init_unwire = __esm({
     DESTROY_FLAG = "--destroy-key-material";
   }
 });
-
-// src/rekey-messages.ts
-var REKEY_FINISH_NEEDS_API_KEY;
-var init_rekey_messages = __esm({
-  "src/rekey-messages.ts"() {
-    REKEY_FINISH_NEEDS_API_KEY = "--rekey-finish needs --api-key <key> \u2014 the one the Haven agent page showed once.";
+function failureOutcomeFor(runtimeHint, error) {
+  if (error !== null && typeof error === "object") {
+    const recorded = failureOutcomesByError.get(error);
+    if (recorded) return recorded;
   }
-});
-
-// src/prune-runtimes.ts
-var prune_runtimes_exports = {};
-__export(prune_runtimes_exports, {
-  normalizeRuntimePath: () => normalizeRuntimePath,
-  pruneSignerRuntimes: () => pruneSignerRuntimes,
-  referencedRuntimeDirectories: () => referencedRuntimeDirectories,
-  rollUpPruneLevel: () => rollUpPruneLevel,
-  signerRuntimeRoot: () => signerRuntimeRoot
-});
-function signerRuntimeRoot(homeDir) {
-  return join(homeDir, ".haven", "signer-runtime");
-}
-function classifyKey(key) {
-  if (key.startsWith("override-")) return "override";
-  if (key === MCP_RUNTIME_MANIFEST.signerVersion || /^\d+\.\d+\.\d+/.test(key)) return "version";
-  return "unknown";
+  return failedConnectOutcome(runtimeHint, error);
 }
-async function directoryBytes(directory) {
-  let total = 0;
-  const walk = async (dir) => {
-    let entries = [];
-    try {
-      entries = await readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const path = join(dir, entry.name);
-      if (entry.isDirectory()) await walk(path);
-      else if (entry.isFile()) {
-        try {
-          total += (await stat(path)).size;
-        } catch {
-        }
-      }
-    }
-  };
-  await walk(directory);
-  return total;
+async function runConnect(options, deps = {}) {
+  const trace = {};
+  try {
+    return await executeConnect(options, deps, trace);
+  } catch (err) {
+    const outcome = failedConnectOutcome(trace.runtime ?? options.runtime, err);
+    if (err !== null && typeof err === "object") failureOutcomesByError.set(err, outcome);
+    if (trace.directory) await recordConnectOutcome(deps, trace.directory, outcome);
+    throw err;
+  }
 }
-async function normalizeRuntimePath(path) {
-  const resolved = resolve(path).replace(/[\\/]+$/, "");
+async function recordConnectOutcome(deps, directory, outcome) {
   try {
-    return await realpath(resolved);
+    return await (deps.writeOutcomeRecord ?? writeConnectOutcomeRecord)(directory, outcome);
   } catch {
-    return resolved;
+    return void 0;
   }
 }
-function escapeRegExp(text) {
-  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-async function referencedRuntimeDirectories(homeDir, credentialsDir) {
-  const roots = /* @__PURE__ */ new Set([join(homeDir, ".haven", "agents")]);
-  if (credentialsDir) roots.add(dirname(resolve(credentialsDir)));
-  const referenced = /* @__PURE__ */ new Map();
-  const runtimeRoot = await normalizeRuntimePath(signerRuntimeRoot(homeDir));
-  const rootSpellings = [.../* @__PURE__ */ new Set([resolve(signerRuntimeRoot(homeDir)), runtimeRoot])];
-  const wrapperRe = new RegExp(`(?:${rootSpellings.map(escapeRegExp).join("|")})[\\/]+([^\\/'"\\s]+)`, "g");
-  const add = async (runtimeDirectory, by) => {
-    const key = await normalizeRuntimePath(runtimeDirectory);
-    const list = referenced.get(key) ?? [];
-    if (!list.includes(by)) list.push(by);
-    referenced.set(key, list);
-  };
-  for (const root of roots) {
-    let entries = [];
-    try {
-      entries = await readdir(root);
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const directory = join(root, entry);
-      try {
-        const sidecar = JSON.parse(await readFile(join(directory, "signer-runtime.json"), "utf8"));
-        if (typeof sidecar.runtime_directory === "string" && sidecar.runtime_directory.length > 0) {
-          await add(sidecar.runtime_directory, directory);
-        }
-      } catch {
-      }
-      try {
-        const wrapper = await readFile(join(directory, "bin", "haven-signer.mjs"), "utf8");
-        for (const match of wrapper.matchAll(wrapperRe)) await add(join(runtimeRoot, match[1]), directory);
-      } catch {
-      }
+async function executeConnect(options, deps, trace) {
+  assertSupportedNodeVersion(deps.nodeVersion, MCP_RUNTIME_MANIFEST.minimumNodeVersion);
+  const connectorVersion = options.connectorVersion ?? CONNECTOR_VERSION;
+  const api = deps.api ?? createConnectApiClient(options.apiBaseUrl, void 0, CONNECTOR_CLIENT_IDENTITY);
+  const log = secureLogger(
+    deps.log ?? ((message) => process.stdout.write(`${message}
+`)),
+    deps.redactPaths === true
+  );
+  const writeCredentials = deps.writeCredentials ?? writeCredentialFiles;
+  const preflightStorage = deps.preflightStorage ?? preflightCredentialStorage;
+  const runRuntimeInstall = deps.installRuntime ?? installRuntime;
+  const generateKey = deps.generateKey ?? generateDelegateKey;
+  const generateLocalApiKey = deps.generateApiKey ?? generateAgentApiKey;
+  const selection = await resolveRuntimeSelection(options.runtime, options.runtimeForce, {
+    env: deps.env ?? process.env,
+    selfReported: options.runtimeSelfReport,
+    promptForRuntime: runtimeSelectionPrompt(options, deps)
+  });
+  if (!selection.runtime) {
+    const hint = await installedClientHintFor(deps);
+    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. ` + installedClientProse(hint) + "Nothing was written and the Haven setup token is still unused.",
+      "rerun_connect_with_explicit_runtime",
+      // #2091: the values must ride structurally too. The backend's setup
+      // prompt permits a retry only with "one of the values that refusal
+      // lists" — and --json discards prose, so a prose-only list deadlocked
+      // every automation run in an undetected runtime (Codex in the field:
+      // npx needs network, Codex runs network commands unsandboxed, and the
+      // unsandboxed path carries none of the CODEX_* detection vars).
+      //
+      // #2174: the list alone still leaves the retry a nine-value guess. The
+      // scan below narrows it to what is actually on this machine — as a
+      // HINT. It does not select, and this stays a refusal: see
+      // `installedClientHint`.
+      { allowedRuntimes: RUNTIME_FLAG_VALUE_LIST, ...hint }
+    );
+  }
+  const runtime = selection.runtime;
+  trace.runtime = runtime;
+  const installCapabilities = runtimeInstallCapabilities(runtime);
+  if (options.localMcp) {
+    if (!supportsLocalMcp(runtime)) {
+      throw new Error(
+        `--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.`
+      );
     }
   }
-  return referenced;
-}
-function rollUpPruneLevel(entries) {
-  if (entries.some((e) => e.level === "failed")) return "failed";
-  if (entries.some((e) => e.level === "advisory")) return "advisory";
-  return "ok";
-}
-async function pruneSignerRuntimes(input, deps = {}) {
-  const homeDir = deps.homeDir ?? homedir();
-  const root = signerRuntimeRoot(homeDir);
-  const measure = input.measure ?? true;
-  const referenced = await referencedRuntimeDirectories(homeDir, deps.credentialsDir);
-  const pin = await normalizeRuntimePath(join(root, MCP_RUNTIME_MANIFEST.signerVersion));
-  const remove = deps.rm ?? (async (directory) => rm(directory, { recursive: true, force: false }));
-  const entries = [];
-  let keys = [];
-  try {
-    keys = (await readdir(root, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name).sort();
-  } catch {
-    return { version: 1, root, dryRun: input.dryRun, entries, removed: 0, reclaimedBytes: 0, level: "ok" };
+  if (selection.overrodeHint) {
+    log(`runtime: ${runtime} (detected; ignoring the ${selection.overrodeHint} hint \u2014 pass --runtime-force ${selection.overrodeHint} to override)`);
   }
-  let removed = 0;
-  let reclaimedBytes = 0;
-  for (const key of keys) {
-    const directory = join(root, key);
-    const normalized = await normalizeRuntimePath(directory);
-    const referencedBy = referenced.get(normalized) ?? [];
-    const kind = classifyKey(key);
-    if (referencedBy.length > 0 || normalized === pin) {
-      entries.push({
-        directory,
-        key,
-        kind,
-        bytes: 0,
-        referencedBy,
-        action: "kept",
-        level: "ok",
-        detail: referencedBy.length > 0 ? `kept \u2014 named by ${referencedBy.length} credential director${referencedBy.length === 1 ? "y" : "ies"} (sidecar or wrapper)` : "kept \u2014 the connector's current pinned version (what --repair installs)"
-      });
-      continue;
-    }
-    const bytes = measure ? await directoryBytes(directory) : 0;
-    if (input.dryRun) {
-      entries.push({
-        directory,
-        key,
-        kind,
-        bytes,
-        referencedBy,
-        action: "would_remove",
-        level: "advisory",
-        detail: `would remove \u2014 no credential directory names it (${kind}-keyed)`
-      });
-      continue;
-    }
-    try {
-      await remove(directory);
-      removed += 1;
-      reclaimedBytes += bytes;
-      entries.push({ directory, key, kind, bytes, referencedBy, action: "removed", level: "ok", detail: `removed \u2014 no credential directory named it (${kind}-keyed)` });
-    } catch (err) {
-      entries.push({
-        directory,
-        key,
-        kind,
-        bytes,
-        referencedBy,
-        action: "failed",
-        level: "failed",
-        detail: `removal failed: ${err instanceof Error ? err.message : String(err)} \u2014 a signer process may still hold it open; stop it and re-run`
-      });
-    }
+  if (selection.discardedHint) {
+    log(`runtime: ${runtime} (detected; "${selection.discardedHint}" is not a runtime Haven knows \u2014 valid values: ${RUNTIME_FLAG_VALUES})`);
   }
-  return { version: 1, root, dryRun: input.dryRun, entries, removed, reclaimedBytes, level: rollUpPruneLevel(entries) };
-}
-var init_prune_runtimes = __esm({
-  "src/prune-runtimes.ts"() {
-    init_runtime_manifest();
+  if (selection.source === "prompted") {
+    log(`runtime: ${runtime} (chosen at the prompt \u2014 nothing was detected in this environment)`);
   }
-});
-
-// 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 = [
-    connectorRerunCommand("--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);
+  log("Warming up your connection to Haven\u2026");
+  let setup;
+  try {
+    setup = await api.resolveSetup({
+      setupToken: options.setupToken,
+      connectorVersion,
+      runtime
+    });
+  } catch (err) {
+    throw deadSetupTokenError(err) ?? err;
   }
-  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.`
-    );
+  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);
   }
-  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.`
+  log("Checked local credential storage \u2014 all clear.");
+  let serverName = options.serverName;
+  let replacing;
+  if (!serverName) {
+    const collision = await detectWiringCollision({
+      credentialsDir: options.credentialsDir,
+      agentName: setup.agent.name
+    });
+    if (collision) {
+      const resolution = await resolveWiringCollision(collision, setup.agent.name, options, deps);
+      if (resolution.action === "replace") {
+        replacing = collision;
+        log(
+          `Replacing the existing haven / haven-signer wiring (previous agent(s): ${supersededIds(collision)}). The previous directory is retired locally once the new wiring is written; nothing is revoked.`
+        );
+      } else {
+        serverName = resolution.serverName;
+        assertValidServerSlug(serverName);
+        await assertServerSlugAvailable(serverName, options.credentialsDir);
+        log(`Installing alongside the existing wiring as a named agent: ${serverNamesFor(serverName).hosted} / ${serverNamesFor(serverName).signer}.`);
+      }
+    }
+  }
+  const existingAgents = await listExistingKeyedAgents(options.credentialsDir);
+  if (existingAgents.length > 0) {
+    log("");
+    log(
+      `Heads-up (before anything is written to this machine): it already carries ${existingAgents.length} agent director${existingAgents.length === 1 ? "y" : "ies"} with stored keys \u2014 ` + existingAgents.map((a) => `${a.agentId}${a.accountAddress ? ` (spends from ${shortAddress(a.accountAddress)})` : ""}`).join(", ") + ". This setup creates a NEW agent alongside them and revokes nothing."
     );
   }
-  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.`
+  const hostedNameForRun = serverNamesFor(serverName).hosted;
+  let reboundFrom;
+  const holders = (await listMcpServerBindings(options.credentialsDir)).filter(({ binding }) => binding.server_name === hostedNameForRun).sort((a, b) => a.binding.bound_at < b.binding.bound_at ? 1 : a.binding.bound_at > b.binding.bound_at ? -1 : 0);
+  const newest = holders[0];
+  if (newest) {
+    const { binding, directory } = newest;
+    const backendChanged = withoutUserinfo(binding.api_url) !== withoutUserinfo(options.apiBaseUrl);
+    const previousApiUrl = withoutUserinfo(binding.api_url);
+    reboundFrom = { server_name: binding.server_name, agent_id: binding.agent_id, api_url: previousApiUrl, bound_at: binding.bound_at, backend_changed: backendChanged };
+    const beingReplaced = replacing?.superseded.some((entry) => entry.directory === directory) ?? false;
+    log(
+      `Heads-up: the MCP server name '${binding.server_name}' was bound to agent ${binding.agent_id} on ${previousApiUrl} at ${binding.bound_at} (locally recorded${holders.length > 1 ? `; ${holders.length - 1} older record${holders.length > 2 ? "s" : ""} also claim${holders.length > 2 ? "" : "s"} it` : ""}). ` + (beingReplaced ? `This run replaces that wiring, as you chose, with a new agent on ${withoutUserinfo(options.apiBaseUrl)}` : `This run rebinds it to a new agent on ${withoutUserinfo(options.apiBaseUrl)}`) + (backendChanged ? " \u2014 a DIFFERENT backend: any saved session, script or document naming this MCP server now resolves to a different backend and agent." : ".")
     );
   }
-  await rewriteCredentialFiles({
+  const localKey = generateKey();
+  const localApiKey = generateLocalApiKey();
+  log("Minting a fresh signing key and API key \u2014 both stay on this machine.");
+  const proofSignature = await localKey.signChallenge(setup.challenge.message);
+  log("Introducing your agent to Haven\u2026");
+  let registration;
+  try {
+    registration = await api.registerSetup({
+      setupToken: options.setupToken,
+      connectorVersion,
+      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(serverName).hosted,
+      // #2528: 'prose' is the default because it is what a caller who says
+      // nothing is doing — the library entry point is not a --json run.
+      runMode: options.runMode ?? "prose",
+      connectorContext: {
+        environment_label: options.environmentLabel ?? "Local workspace",
+        config_target: installCapabilities.canWriteRuntimeConfig ? "agent runtime MCP config" : "local credential files"
+      },
+      installCapabilities
+    });
+  } catch (err) {
+    const dead = deadSetupTokenError(err);
+    if (dead) throw dead;
+    if (isExpiredSetupChallenge(err)) {
+      throw new Error(
+        "The Haven setup challenge expired while connecting. Return to Haven, start a fresh connection, and run its new connector command. Do not reuse or paste credentials."
+      );
+    }
+    throw err;
+  }
+  log(`Registered signing address with Haven: ${shortAddress(registration.delegate_address)}.`);
+  log("Tucking your credentials away safely on disk\u2026");
+  const credentialPaths = await writeCredentials({
     baseDir: options.credentialsDir,
-    agentId: stored.agentId,
-    serverName: options.serverName,
-    apiKey: options.newApiKey,
-    delegateKey: pending.new_delegate_key,
-    delegateAddress: pending.new_delegate_address,
-    // The stored value (already new-name-first, from the credential-FILE
-    // permanent fallback) wins; the hosted identity's `account_address` is a
-    // LIVE server read, which as of #2914 emits only that name.
-    accountAddress: stored.accountAddress ?? identity.account_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
+    agentId: registration.agent_id,
+    serverName,
+    apiKey: localApiKey,
+    delegateKey: localKey.privateKey,
+    delegateAddress: localKey.address,
+    accountAddress: setup.haven_wallet.address,
+    chainId: setup.haven_wallet.chain_id,
+    network: setup.haven_wallet.network,
+    agentBudget: setup.agent_budget.map((budget) => ({
+      token_symbol: budget.token_symbol,
+      allowance_amount: budget.allowance_amount,
+      reset_period_min: budget.reset_period_min
+    })),
+    apiUrl: options.apiBaseUrl,
+    hostedMcpUrl: registration.hosted_mcp_url,
+    x402BindingSigner: setup.x402_binding_signer ?? void 0,
+    warn: 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, env: deps.env }
-    );
-    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 }
+  trace.directory = credentialPaths.directory;
+  try {
+    const bindingRecord = {
+      version: 1,
+      server_name: hostedNameForRun,
+      signer_name: serverNamesFor(serverName).signer,
+      agent_id: registration.agent_id,
+      api_url: withoutUserinfo(options.apiBaseUrl),
+      // never persist `user:pass@` (#3154 doc review r2)
+      ...registration.hosted_mcp_url ? { hosted_mcp_url: registration.hosted_mcp_url } : {},
+      bound_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeMcpServerBinding(credentialPaths.directory, bindingRecord);
+  } catch {
+    log("Could not record the MCP server-name binding locally (non-fatal; the next setup cannot see this binding).");
+  }
+  log(`Stored Haven identity credential locally: ${credentialPaths.identityPath}`);
+  log(`Stored local signer credential locally: ${credentialPaths.signerPath}`);
+  log(`Stored non-secret agent orientation locally: ${credentialPaths.agentPath}`);
+  if (setup.x402_binding_signer) {
+    log("Configured x402 binding signer for the local signer.");
+  } else {
+    log(
+      "Warning: Haven did not provide an x402 binding signer, so x402 payments will not sign until HAVEN_X402_BINDING_SIGNER is set for the signer. Non-x402 payments are unaffected."
     );
-    configRewritten = result.hostedConfigured;
-    if (prepared.runtimeSpecOverride) {
-      messages.push(
-        `  Signer runtime:   RUNTIME SPEC OVERRIDE ACTIVE \u2014 ${describeRuntimeSpecOverride(prepared.runtimeSpecOverride.specs)} (NOT the pinned manifest; installed into ${prepared.runtimeDirectory})`
-      );
+  }
+  const runtimeInstall = await runRuntimeInstall({
+    runtime,
+    hostedMcpUrl: registration.hosted_mcp_url,
+    apiKey: localApiKey,
+    signerPath: credentialPaths.signerPath,
+    identityPath: credentialPaths.identityPath,
+    credentialDirectory: credentialPaths.directory,
+    environmentLabel: options.environmentLabel ?? "Local workspace",
+    ackSigner: options.ackSigner,
+    ackLocalTools: options.ackLocalTools,
+    localMcp: options.localMcp,
+    serverName
+  }, {
+    onProgress: log,
+    // #1543: report "runtime configured" the moment the config write settles,
+    // so the dashboard can expose its budget-approval controls without
+    // waiting on the probes and skill install — a tail that approval does not
+    // depend on. Silent and best-effort: the complete report below remains
+    // authoritative (it overwrites these keys, adding the probe verdicts and
+    // skill state), so an early failure costs nothing but the head start.
+    onRuntimeConfigured: async (early) => {
+      try {
+        await api.updateInstallStatus(registration.setup_id, localApiKey, {
+          runtime: early.runtime,
+          connectorVersion,
+          runtimeMcpMode: early.runtimeMcpMode,
+          hostedMcpConfigured: early.hostedMcpConfigured,
+          localSignerConfigured: early.localSignerConfigured,
+          localMcpConfigured: early.localMcpConfigured,
+          credentialFilesWritten: true,
+          signerAcknowledged: early.signerAcknowledged,
+          localMcpAcknowledged: early.localMcpAcknowledged,
+          restartRequired: early.restartRequired,
+          nextUserAction: early.nextUserAction,
+          errorCode: early.errorCode ?? null,
+          environmentLabel: options.environmentLabel ?? "Local workspace"
+        });
+        if (!early.errorCode || early.errorCode === "manual_runtime_setup_required") {
+          log(approveBudgetCta(setup, registration.approval_url));
+        }
+      } catch {
+      }
     }
-    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."
+  });
+  printRuntimeInstall(runtimeInstall, log);
+  if (runtimeInstall.errorCode) {
+    log("Haven setup needs a couple more steps on this machine \u2014 see the notes above.");
+  } else {
+    log("Haven setup on this machine is complete.");
+  }
+  let supersededAgentsRetiredLocally;
+  const retiredAgentIds = [];
+  const retirementMirrorErrors = {};
+  if (replacing) {
+    if (runtimeInstall.errorCode) {
+      supersededAgentsRetiredLocally = false;
+      log(
+        `Previous agent(s) ${supersededIds(replacing)} were NOT retired: the runtime install did not complete, so their wiring may still be the only working one. Resolve the install, then retire them with ${RERUN_HINT} --unwire <dir>.`
       );
+    } else {
+      supersededAgentsRetiredLocally = true;
+      for (const entry of replacing.superseded) {
+        try {
+          const { mirrorError } = await tombstoneDirectoryIfAbsent({
+            directory: entry.directory,
+            agentId: entry.agentId,
+            reason: "replaced by a new setup (--replace)",
+            replacedBy: registration.agent_id,
+            // #3251: the ledger follows this run's credential root (default
+            // root → ~/.haven/tombstones, as before; any other → <root>/.tombstones).
+            tombstonesDir: tombstonesDirForCredentialRoot(options.credentialsDir)
+          });
+          if (mirrorError !== void 0) {
+            retirementMirrorErrors[entry.agentId] = mirrorError;
+            log(
+              `Warning: the surviving tombstone record for ${entry.agentId} could not be written to ${tombstonesDirForCredentialRoot(options.credentialsDir)} (${mirrorError}). The in-place TOMBSTONE.json stands; --doctor will not list this retirement once the directory is deleted.`
+            );
+          }
+          await teardownLocalKeyMaterial(entry.directory, await readIdentityFile(entry.directory));
+          await clearMcpServerBinding(entry.directory);
+          retiredAgentIds.push(entry.agentId);
+          log(`Retired previous agent ${entry.agentId} locally: tombstoned, local key files removed.`);
+        } catch (err) {
+          supersededAgentsRetiredLocally = false;
+          log(`Could not retire previous agent ${entry.agentId} locally: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
     }
-  } 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 probeIdentity(api, apiKey, which) {
+  let supersededScan = null;
+  let supersededAgentIds = [];
   try {
-    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."
+    supersededScan = await listOtherAgentIds(options.credentialsDir, credentialPaths.directory);
+    supersededAgentIds = supersededScan ?? [];
+    if (supersededAgentsRetiredLocally === true) {
+      log("");
+      log(
+        `Replaced: previous agent(s) ${supersededIds(replacing)} are retired on this machine but NOT revoked \u2014 revoke them on the Haven agent page, then restart EVERY long-lived host (gateways, TUI workers, editors): each holds the MCP wiring snapshot from its own start time, and the tombstone speaks only when a stale host next probes the old path.`
+      );
+    } else if (supersededAgentIds.length > 0) {
+      log("");
+      log(
+        `Heads-up: this setup created a NEW agent. Your previous agent(s) \u2014 ${supersededAgentIds.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.`
       );
     }
-    throw new Error(
-      `Could not reach Haven to check this agent (${redactSecrets(
-        err instanceof Error ? err.message : String(err)
-      )}). Nothing was changed.`
-    );
+  } catch {
   }
-}
-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.`
-    );
+  try {
+    await api.updateInstallStatus(registration.setup_id, localApiKey, {
+      runtime: runtimeInstall.runtime,
+      connectorVersion,
+      runtimeMcpMode: runtimeInstall.runtimeMcpMode,
+      hostedMcpConfigured: runtimeInstall.hostedMcpConfigured,
+      localSignerConfigured: runtimeInstall.localSignerConfigured,
+      localMcpConfigured: runtimeInstall.localMcpConfigured,
+      credentialFilesWritten: true,
+      signerAcknowledged: runtimeInstall.signerAcknowledged,
+      localMcpAcknowledged: runtimeInstall.localMcpAcknowledged,
+      activationCommandAvailable: Boolean(runtimeInstall.activationCommand),
+      skillInstalled: runtimeInstall.skillInstalled,
+      probeResult: runtimeInstall.probeResult,
+      restartRequired: runtimeInstall.restartRequired,
+      nextUserAction: runtimeInstall.nextUserAction,
+      errorCode: runtimeInstall.errorCode,
+      environmentLabel: options.environmentLabel ?? "Local workspace",
+      // The raw scan result, `null` and all — NOT the flattened
+      // `supersededAgentIds` the outcome carries. Flattening here would hand
+      // the dashboard the same ambiguity this field exists to remove (#2561).
+      supersededAgentIds: supersededScan
+    });
+  } catch (err) {
+    log(`Could not report install status to Haven: ${err instanceof Error ? err.message : String(err)}`);
   }
-  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.`
-    );
+  let approval;
+  const narrateApprovalWait = options.waitForApproval === true || options.waitForApproval === void 0 && (deps.isStdoutTty ?? Boolean(process.stdout.isTTY));
+  if (narrateApprovalWait && !runtimeInstall.errorCode) {
+    approval = await waitForBudgetApproval(api, registration.setup_id, localApiKey, log, options.approvalWait);
   }
-  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.`
-    );
+  printNextSteps(runtimeInstall, log, approval, registration.approval_url);
+  const outcome = completionOutcome({
+    runtimeInstall,
+    delegateAddress: registration.delegate_address,
+    hostedMcpUrl: registration.hosted_mcp_url,
+    supersededAgentIds,
+    supersededAgentsRetiredLocally,
+    ...replacing ? { retiredAgentIds } : {},
+    ...Object.keys(retirementMirrorErrors).length > 0 ? { retirementMirrorErrors } : {},
+    existingAgentsBeforeWrite: existingAgents.map((a) => ({ agent_id: a.agentId, account_address: a.accountAddress })),
+    ...reboundFrom ? { serverNameReboundFrom: reboundFrom } : {},
+    setupChallengeExpiresAt: setup.challenge.expires_at,
+    approvalRequired: registration.agent_status === "pending_approval",
+    approvalUrl: registration.approval_url
+  });
+  if (await recordConnectOutcome(deps, credentialPaths.directory, outcome)) {
+    log(`Saved this run's outcome to ${CONNECT_OUTCOME_FILENAME} in the agent's credential directory.`);
   }
+  return {
+    setupId: registration.setup_id,
+    agentId: registration.agent_id,
+    delegateAddress: registration.delegate_address,
+    credentialPaths,
+    outcome
+  };
 }
-var init_rekey = __esm({
-  "src/rekey.ts"() {
-    init_api();
-    init_runtime_install();
-    init_signer_runtime();
-    init_runtime_spec_override();
-    init_key();
-    init_redact();
-    init_rekey_messages();
-    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 };
+function completionOutcome(input) {
+  const { runtimeInstall } = input;
+  const manualSetup = runtimeInstall.errorCode === "manual_runtime_setup_required";
+  const nextAction2 = runtimeInstall.nextUserAction;
+  const outcome = {
+    schema_version: CONNECT_OUTCOME_SCHEMA_VERSION,
+    outcome: runtimeInstall.errorCode ? "action_required" : "complete",
+    runtime: runtimeInstall.runtime,
+    topology: runtimeInstall.runtimeMcpMode,
+    configuration: {
+      hosted_mcp: runtimeInstall.hostedMcpConfigured,
+      local_signer: runtimeInstall.localSignerConfigured,
+      local_mcp: runtimeInstall.localMcpConfigured
+    },
+    probe: { result: runtimeInstall.probeResult },
+    activation: {
+      restart_required: runtimeInstall.restartRequired,
+      instruction: manualSetup ? "Finish the manual MCP setup using the secret-free references shown in normal Connect output, then start a fresh session." : runtimeProfile(runtimeInstall.runtime).activationInstruction
+    },
+    next_action: nextAction2,
+    approval: {
+      required: input.approvalRequired,
+      expires_at: null,
+      // Only when there is something to approve AND the backend supplied a
+      // link. Never synthesised here: the connector does not know the
+      // dashboard's origin, and a guessed URL is worse than none — it is the
+      // "do not invent one" rule the agent runbook states, applied to the
+      // tool rather than the agent.
+      ...input.approvalRequired && input.approvalUrl ? { url: input.approvalUrl } : {}
+    },
+    verification: {
+      tools: ["haven_get_agent", "haven_get_allowances"],
+      instruction: runtimeVerificationInstruction(runtimeInstall.runtime)
+    },
+    // The backend contract supplies a 20-byte address. If an unexpected
+    // malformed value arrives, do not echo it into an automation-facing
+    // record; the human log has already been redacted separately.
+    delegate_address: /^0x[0-9a-fA-F]{40}$/.test(input.delegateAddress) ? shortAddress(input.delegateAddress) : "[delegate-address-redacted]",
+    // The endpoint Connect wrote into the runtime's MCP config, verbatim — the
+    // same string that already sits in the user's own config file. Passed
+    // through the secret filter anyway: this is the automation contract, the
+    // value is server-supplied, and belts are cheap (the #1589 stance).
+    ...input.hostedMcpUrl ? { hosted_mcp_url: redactSecrets(input.hostedMcpUrl) } : {},
+    // Always emitted on a completed run, empty list included: "no superseded
+    // agents" is a fact a caller needs, and an omitted key would be
+    // indistinguishable from an older connector that never reported it.
+    superseded_agent_ids: input.supersededAgentIds ?? [],
+    ...input.supersededAgentsRetiredLocally !== void 0 ? { superseded_agents_retired_locally: input.supersededAgentsRetiredLocally } : {},
+    ...input.retiredAgentIds ? { retired_agent_ids: input.retiredAgentIds } : {},
+    ...input.retirementMirrorErrors ? { retirement_mirror_errors: input.retirementMirrorErrors } : {},
+    // #3122: always emitted on a completed run (empty list included), for the
+    // same reason as superseded_agent_ids above.
+    existing_agents_before_write: input.existingAgentsBeforeWrite ?? [],
+    ...input.serverNameReboundFrom ? { server_name_rebound_from: input.serverNameReboundFrom } : {},
+    ...input.setupChallengeExpiresAt ? { setup_challenge_expires_at: input.setupChallengeExpiresAt } : {},
+    ...runtimeInstall.errorCode ? { error: { code: runtimeInstall.errorCode, next_action: nextAction2 } } : {}
+  };
+  return outcome;
 }
-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").'
-      }
-    };
+async function installedClientHintFor(deps) {
+  try {
+    const candidates = await (deps.scanInstalledClients ?? scanInstalledClients)({ env: deps.env });
+    const hint = installedClientHint(candidates);
+    return hint.installedClients.length > 0 ? hint : {};
+  } catch {
+    return {};
   }
-});
-
-// src/doctor.ts
-var doctor_exports = {};
-__export(doctor_exports, {
-  describeAccountAddressKey: () => describeAccountAddressKey,
-  rollUpLevel: () => rollUpLevel,
-  runDoctor: () => runDoctor,
-  runRepair: () => runRepair
-});
-function finalizeCheck(check) {
-  return { ...check, ok: check.level !== "failed" };
 }
-function rollUpLevel(checks) {
-  if (checks.some((check) => check.level === "failed")) return "failed";
-  if (checks.some((check) => check.level === "advisory")) return "advisory";
-  return "ok";
+function installedClientProse(hint) {
+  const found = hint.installedClients ?? [];
+  if (found.length === 0) return "";
+  const suggestion = hint.suggestedRuntime ? ` The likeliest is ${hint.suggestedRuntime}, but Haven will not choose for you \u2014 pass it yourself if it is right.` : " Haven will not choose between them for you.";
+  return `Haven can see these agent clients installed here, likeliest first: ${found.join(", ")}.${suggestion} `;
 }
-function runtimeFlagFor(runtime) {
-  return normalizeRuntimeName(runtime) ? ` --runtime ${runtime}` : "";
+function runtimeSelectionPrompt(options, deps) {
+  if (!interactivePromptAllowed(options, deps)) return void 0;
+  return deps.promptRuntime ?? (() => resolveRuntimeByInstalledClientPrompt());
 }
-function repairCommandFor(runtime, suffix = "") {
-  if (normalizeRuntimeName(runtime)) return `Run: ${RERUN} --doctor --repair --runtime ${runtime}${suffix}`;
-  return `Run: ${RERUN} --doctor --repair --runtime <runtime>${suffix.replace(/\.$/, "")} \u2014 --repair needs the runtime named; one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`;
+function interactivePromptAllowed(options, deps) {
+  if (options.interactive !== true) return false;
+  return deps.isTty ?? Boolean(process.stdin.isTTY);
 }
-async function resolveDoctorRuntime(input, directory) {
-  const explicit = input.runtime.trim();
-  if (explicit) return { runtime: explicit, origin: "flag" };
-  if (directory) {
-    const recorded = await readConnectOutcomeRuntime(directory);
-    if (recorded !== null && normalizeRuntimeName(recorded)) {
-      return { runtime: recorded, origin: "record" };
-    }
-  }
-  return { runtime: "", origin: "unknown" };
+function supersededIds(collision) {
+  return collision.superseded.map((entry) => entry.agentId).join(", ");
 }
-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 {
-        }
-      }
+async function resolveWiringCollision(collision, agentName, options, deps) {
+  if (options.replaceExistingWiring) return { action: "replace" };
+  if (interactivePromptAllowed(options, deps)) {
+    const prompt = deps.promptWiringCollision ?? ((c, name) => promptWiringCollisionResolution(c, name, defaultPromptIo()));
+    const resolution = await prompt(collision, agentName);
+    if (resolution.action === "abort") {
+      throw new ConnectError(
+        "wiring_collision_declined",
+        `Setup stopped at your request: this machine is already wired to ${supersededIds(collision)} and you chose neither to replace that wiring nor to install alongside it. Nothing was written: no agent was created, no credentials were stored, and the Haven setup token is still unused. Run the connector command again with --replace to re-point haven / haven-signer at the new agent, or with --name <slug> (e.g. --name ${collision.suggestedServerName}) to install alongside.`,
+        "rerun_connect_with_replace_or_name",
+        { supersededAgentIds: collision.superseded.map((e) => e.agentId), suggestedServerName: collision.suggestedServerName }
+      );
     }
+    return resolution;
   }
-  const parkedOnlySet = new Set(parkedOnly);
-  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  if (explicit) {
-    return {
-      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 };
-  }
+  throw new ConnectError(
+    "wiring_collision",
+    `This machine is already wired to a Haven agent with a live key (${supersededIds(collision)}), and setting up "${agentName}" on the bare haven / haven-signer pair would replace that wiring. Nothing was written and the Haven setup token is still unused. If you are an AI agent running this command: do NOT add a flag yourself \u2014 relay this to your user and stop. Your user decides: REPLACE the existing wiring (re-run the same command with --replace added, which re-points the pair at the new agent and retires the previous directory locally \u2014 they still revoke the old agent on the Haven agent page), or install ALONGSIDE it (re-run with --name <slug> added, e.g. --name ${collision.suggestedServerName}, which gives the new agent its own haven-<slug> / haven-signer-<slug> pair). Re-run only with the flag your user chooses.`,
+    "relay_wiring_collision_to_user",
+    { supersededAgentIds: collision.superseded.map((e) => e.agentId), suggestedServerName: collision.suggestedServerName }
+  );
+}
+function failedConnectOutcome(runtimeHint, error) {
+  const message = error instanceof Error ? error.message : "";
+  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 = 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 {
-    directory: candidates[0]?.directory,
-    others: [...candidates.slice(1).map((c) => c.directory), ...tombstonedOnly, ...parkedOnly],
-    parkedOnly: parkedOnlySet
+    schema_version: CONNECT_OUTCOME_SCHEMA_VERSION,
+    outcome: "failed",
+    runtime,
+    topology: "unknown",
+    configuration: { hosted_mcp: false, local_signer: false, local_mcp: false },
+    probe: { result: "not_run" },
+    activation: { restart_required: false, instruction: "Resolve the reported problem before activating Haven tools." },
+    next_action: nextAction2,
+    approval: { required: false, expires_at: null },
+    verification: {
+      tools: ["haven_get_agent", "haven_get_allowances"],
+      instruction: "After a successful setup and activation, verify only with haven_get_agent and haven_get_allowances."
+    },
+    error: {
+      code,
+      next_action: nextAction2,
+      // Only a ConnectError's message enters the JSON record: the vocabulary's
+      // prose is connector-authored and safe to serialize, while a plain
+      // Error can carry arbitrary server or filesystem detail (that stance is
+      // pinned by test). Redaction stays on as belt-and-braces; plain-Error
+      // runs still get their redacted message on stderr via the CLI mirror.
+      ...error instanceof ConnectError && message ? { message: redactForAutomation(message) } : {},
+      ...error instanceof ConnectError && error.details.allowedRuntimes ? { allowed_runtimes: error.details.allowedRuntimes } : {},
+      ...error instanceof ConnectError && error.details.installedClients?.length ? { installed_clients: error.details.installedClients } : {},
+      ...error instanceof ConnectError && error.details.suggestedRuntime ? { suggested_runtime: error.details.suggestedRuntime } : {},
+      ...error instanceof ConnectError && error.details.supersededAgentIds ? { superseded_agent_ids: error.details.supersededAgentIds } : {},
+      ...error instanceof ConnectError && error.details.suggestedServerName ? { suggested_name: error.details.suggestedServerName } : {}
+    }
   };
 }
-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;
+function printSetupSummary(setup, log) {
+  log(`Fetched Haven setup for ${setup.agent.name}.`);
+  log(`Haven wallet: ${setup.haven_wallet.name} on ${setup.haven_wallet.network}.`);
+  if (setup.agent_budget.length > 0) {
+    for (const budget of setup.agent_budget) {
+      log(
+        `Agent budget: ${budget.allowance_amount} atomic ${budget.token_symbol} / ${budget.reset_period_min} minute reset.`
+      );
     }
-    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) {
-  return finalizeCheck(rekeyPendingVerdict(status, hostedDelegateAddress, runtime, slug));
+  log(`Setup challenge expires at ${setup.challenge.expires_at}. If it expires, return to Haven for a fresh setup and rerun Connect \u2014 do not reuse or paste credentials.`);
 }
-function rekeyPendingVerdict(status, hostedDelegateAddress, runtime, slug) {
-  const label = "Pending re-key";
-  const nameFlag = slug ? ` --name ${slug}` : "";
-  if (status.state === "unreadable") {
-    return {
-      id: "rekey_pending",
-      label,
-      level: "failed",
-      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}`
-    };
-  }
-  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 {
-      id: "rekey_pending",
-      label,
-      level: "failed",
-      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>${runtimeFlagFor(runtime)}`
-    };
-  }
-  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,
-      level: "failed",
-      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.`
-    };
+function approveBudgetCta(setup, approvalUrl) {
+  const where = approvalUrl ? `at ${approvalUrl}` : "in the Haven dashboard";
+  const budgetPhrase = setup.agent_budget.length > 0 ? setup.agent_budget.map((budget) => `up to ${describeSetupBudget(budget)}`).join(", ") : void 0;
+  if (budgetPhrase) {
+    return `\u2192 Action needed: approve this agent's budget \u2014 ${budgetPhrase} from ${setup.haven_wallet.name} on ${setup.haven_wallet.network} \u2014 ${where}. The approval button is live now; setup continues here in the meantime.`;
   }
-  return {
-    id: "rekey_pending",
-    label,
-    level: "ok",
-    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
-  };
+  return `\u2192 Action needed: approve this agent's budget ${where} \u2014 the approval button is live now. Setup continues here in the meantime.`;
 }
-async function runtimeSpecOverrideCheck(directory, sidecar, env) {
-  const facts = [];
-  const installed = sidecar?.runtime_spec_override;
-  if (installed) {
-    facts.push(
-      `signer runtime installed under ${describeRuntimeSpecOverride(installed.specs)} (resolved: ${installed.resolved_specs.join(" ")}; directory key ${installed.directory_key})`
-    );
-  }
-  const mcpInstalled = await readMcpSidecarOverride(directory);
-  if (mcpInstalled) {
-    facts.push(
-      `local MCP runtime installed under ${describeRuntimeSpecOverride(mcpInstalled.specs)} (resolved: ${mcpInstalled.resolved_specs.join(" ")}; directory key ${mcpInstalled.directory_key})`
-    );
-  }
-  let shell;
-  try {
-    const active = resolveRuntimeSpecOverride(env);
-    if (active) shell = `set in this shell: ${describeRuntimeSpecOverride(active)} \u2014 a --repair from here installs these, not the pin`;
-  } catch (err) {
-    shell = err instanceof RuntimeSpecOverrideError ? `set in this shell but REFUSED: ${err.message}` : `set in this shell but unreadable: ${err instanceof Error ? err.message : String(err)}`;
-  }
-  if (shell) facts.push(shell);
-  if (facts.length === 0) return void 0;
-  const variables = Object.values(RUNTIME_SPEC_ENV).join(" / ");
-  return finalizeCheck({
-    id: "runtime_spec_override",
-    label: "Runtime spec override",
-    level: "failed",
-    detail: `runtime spec overridden \u2014 not the pinned manifest (${MCP_RUNTIME_MANIFEST.signerPackage}@${MCP_RUNTIME_MANIFEST.signerVersion}, ${MCP_RUNTIME_MANIFEST.sdkPackage}@${MCP_RUNTIME_MANIFEST.sdkVersion}). ${facts.join(". ")}.`,
-    repair: `Developer override (#2424). To return to the pinned manifest: unset ${variables}, then run ${RERUN} --doctor --repair --runtime <runtime>. If the override is intentional, this finding is the record of it.`
+function describeSetupBudget(budget) {
+  return describeApprovedBudget({
+    token_symbol: budget.token_symbol,
+    token_address: budget.token_address,
+    amount: budget.allowance_amount,
+    reset_period_min: budget.reset_period_min
   });
 }
-async function readMcpSidecarOverride(directory) {
-  try {
-    const parsed = JSON.parse(await readFile(join(directory, "mcp-runtime.json"), "utf8"));
-    return parsed.runtime_spec_override;
-  } catch {
-    return void 0;
-  }
+function assertSetupChallengeIsUsable(expiresAt) {
+  const expiresAtMs = Date.parse(expiresAt);
+  if (!Number.isNaN(expiresAtMs) && expiresAtMs > Date.now()) return;
+  throw new Error(
+    "This Haven setup challenge is expired or invalid. Return to Haven, start a fresh connection, and rerun Connect. No local credentials were written."
+  );
 }
-async function readIdentity(directory) {
-  try {
-    return JSON.parse(await readFile(join(directory, "identity.json"), "utf8"));
-  } catch {
-    return void 0;
-  }
+function deadSetupTokenError(err) {
+  if (!(err instanceof ConnectRequestError) || err.status !== 410 && err.status !== 401) return null;
+  return new ConnectError(
+    "setup_challenge_expired_or_invalid",
+    "This Haven setup token is expired or invalid \u2014 tokens are single-use and expire 30 minutes after the dashboard issues them, and a mistyped token reads the same way. Return to Haven, start a fresh connection, and run its new connector command. No local credentials were written.",
+    "return_to_haven_for_fresh_setup"
+  );
 }
-function describeAccountAddressKey(identity, signerFile) {
-  const files = [identity, signerFile];
-  const has = (key) => files.some((f) => typeof f?.[key] === "string" && f[key].trim() !== "");
-  if (has("account_address")) return "account address stored as account_address";
-  if (has("safe_address")) {
-    return "account address stored under the pre-#2908 name safe_address \u2014 still read; the next --rekey or setup rewrites it as account_address";
-  }
-  return "no account address stored";
+function isExpiredSetupChallenge(err) {
+  return err instanceof Error && /(?:setup )?challenge.*expir|expir.*(?:setup )?challenge/i.test(err.message);
 }
-async function checksForAgent(entry, input, deps) {
-  const verdicts = await verdictsForAgent(entry, input, deps);
-  return {
-    checks: verdicts.checks.map(finalizeCheck),
-    ...verdicts.signerCapabilities ? { signerCapabilities: verdicts.signerCapabilities } : {}
+function secureLogger(log, redactPaths = false) {
+  return (message) => {
+    log(redactPaths ? redactForAutomation(message) : redactSecrets(message));
   };
 }
-async function verdictsForAgent(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;
+function printRuntimeInstall(result, log) {
+  for (const message of result.messages) log(message);
+  if (result.localMcpConfigured) {
+    log("Configured local Haven MCP tools.");
+  } else if (result.hostedMcpConfigured) {
+    log("Configured hosted Haven MCP identity.");
+  } else {
+    log("Haven MCP tools still need runtime setup.");
   }
-  const credentialsOk = Boolean(identity?.api_key) && signerFile !== void 0;
-  checks.push({
-    id: "credentials",
-    label: "Agent credentials",
-    level: credentialsOk ? "ok" : "failed",
-    detail: credentialsOk ? `identity.json and signer.json parse (agent ${identity?.agent_id ?? "unknown"}; ${describeAccountAddressKey(identity, signerFile)})` : "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)",
-      level: "failed",
-      detail: "No signer-runtime.json sidecar \u2014 the pinned signer runtime was never prepared (or a pre-#1586 npx config).",
-      repair: repairCommandFor(input.runtime)
-    });
-  } else if (sidecar.runtime_spec_override) {
-    const matches = await installedRuntimeMatchesVersions(sidecar.runtime_directory, sidecar.cli_path, {
-      signerVersion: sidecar.signer_version,
-      sdkVersion: sidecar.sdk_version
-    });
-    checks.push({
-      id: "signer_runtime",
-      label: "Signer runtime (preinstalled wrapper)",
-      level: matches ? "ok" : "failed",
-      detail: matches ? `Installed ${sidecar.signer_package}@${sidecar.signer_version} at ${sidecar.runtime_directory} (override install \u2014 see runtime_spec_override)` : `Override runtime directory is stale or empty (${sidecar.runtime_directory}) \u2014 the CLI or package versions are missing.`,
-      ...matches ? {} : { repair: repairCommandFor(input.runtime, " with the same HAVEN_*_SPEC variables set.") }
-    });
+  if (result.localSignerConfigured) {
+    log("Configured local Haven signer.");
   } else {
-    const intact = await installedRuntimeMatchesVersions(sidecar.runtime_directory, sidecar.cli_path, {
-      signerVersion: sidecar.signer_version,
-      sdkVersion: sidecar.sdk_version
-    });
-    const versionOk = sidecar.signer_version === MCP_RUNTIME_MANIFEST.signerVersion;
-    const ok = intact && versionOk;
-    checks.push({
-      id: "signer_runtime",
-      label: "Signer runtime (preinstalled wrapper)",
-      level: ok ? "ok" : intact ? "advisory" : "failed",
-      detail: ok ? `Installed ${sidecar.signer_package}@${sidecar.signer_version} at ${sidecar.runtime_directory}` : intact ? `Installed version ${sidecar.signer_version} does not match the connector's pinned ${MCP_RUNTIME_MANIFEST.signerVersion} \u2014 intact, but outdated.` : `Runtime directory is stale or empty (${sidecar.runtime_directory}) \u2014 the CLI or package versions are missing.`,
-      ...ok ? {} : { repair: repairCommandFor(input.runtime) }
-    });
+    log("Local Haven signer still needs runtime setup.");
   }
-  const overrideCheck = await runtimeSpecOverrideCheck(directory, sidecar, deps.env ?? process.env);
-  if (overrideCheck) checks.push(overrideCheck);
-  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",
-      level: probe.status === "ok" ? "ok" : "failed",
-      detail: probe.status === "ok" ? `MCP tools endpoint is reachable (${hostedUrl}).` : `MCP tools endpoint probe failed: ${probe.status} (${hostedUrl}).`,
-      ...probe.status === "ok" ? {} : {
-        repair: "Check network access and runtime configuration for the hosted MCP URL, then re-run --doctor."
-      }
-    });
-  } else {
-    checks.push({
-      id: "hosted_mcp",
-      label: "Hosted Haven MCP",
-      level: "failed",
-      detail: "No stored API key / hosted MCP URL to probe with.",
-      repair: `Re-run the full setup: ${RERUN} --setup <token>.`
-    });
+}
+function formatAtomicAmount(atomic, decimals) {
+  const s = atomic.toString().padStart(decimals + 1, "0");
+  const intPart = s.slice(0, s.length - decimals) || "0";
+  const fracPart = s.slice(s.length - decimals).replace(/0+$/, "");
+  return fracPart ? `${intPart}.${fracPart}` : intPart;
+}
+function describeResetPeriod(resetPeriodMin) {
+  if (resetPeriodMin === 1440) return "per day";
+  if (resetPeriodMin === 10080) return "per week";
+  if (resetPeriodMin === 43200) return "per month";
+  if (resetPeriodMin === 60) return "per hour";
+  if (resetPeriodMin === 0) return "in total";
+  return `every ${resetPeriodMin} minutes`;
+}
+function describeApprovedBudget(budget) {
+  const token = resolveTokenFromAddress(budget.token_address);
+  const amount = token ? `${formatAtomicAmount(BigInt(budget.amount), token.decimals)} ${budget.token_symbol}` : `${budget.amount} ${budget.token_symbol} (atomic units)`;
+  return `${amount} ${describeResetPeriod(budget.reset_period_min)}`;
+}
+function describeWaitBound(timeoutMs) {
+  if (timeoutMs >= 12e4) {
+    const minutes = Math.round(timeoutMs / 6e4);
+    return `${minutes} minutes`;
   }
-  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",
-        level: "failed",
-        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${runtimeFlagFor(input.runtime)}`
-      });
-    } else if (!localDelegate) {
-      checks.push({
-        id: "identity_match",
-        label: "Hosted identity matches the local signing key",
-        level: "failed",
-        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",
-        level: same ? "ok" : "failed",
-        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.`
-        }
-      });
+  return `${Math.round(timeoutMs / 1e3)}s`;
+}
+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((resolve11) => setTimeout(resolve11, ms)));
+  const maxPolls = Math.max(1, Math.floor(timeoutMs / intervalMs));
+  const remindEvery = Math.max(1, Math.floor(3e4 / intervalMs));
+  let waitingAnnounced = false;
+  const announceWaiting = () => {
+    if (waitingAnnounced) return;
+    waitingAnnounced = true;
+    log("Now waiting for you to approve the budget in the Haven dashboard \u2014 approval is what unlocks the agent's Haven tools\u2026");
+  };
+  for (let i = 0; i < maxPolls; i++) {
+    if (i > 0) await sleep(intervalMs);
+    let status;
+    try {
+      status = await api.getConnectorStatus(setupId, apiKey);
+    } catch (err) {
+      if (err instanceof ConnectRequestError && (err.status === 401 || err.status === 404)) {
+        log("This setup ended in Haven \u2014 start a fresh connection from the dashboard when ready.");
+        return "ended";
+      }
+      announceWaiting();
+      continue;
     }
-  }
-  const pending = await inspectRekeyPending(directory, deps.now?.() ?? Date.now());
-  if (pending) {
-    checks.push(rekeyPendingCheck(pending, hostedDelegateAddress, input.runtime, sidecar?.server_name));
-  }
-  if (sidecar) {
-    const consent = await getLocalSignerConsentStatus(join(directory, "signer.json"));
-    if (!consent.acknowledged) {
-      checks.push({
-        id: "signer_process",
-        label: "Signer stdio handshake",
-        level: "failed",
-        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 connector command with --ack-local-tools).`
-      });
-    } else {
-      const probe = await (deps.probeSignerTools ?? probeLocalMcpTools)(
-        sidecar.wrapper_path,
-        [],
-        MCP_RUNTIME_MANIFEST.requiredSignerTools
+    if (status.status === "active") {
+      log(
+        status.approved_budget ? `Budget approved \u{1F389} \u2014 I can now spend up to ${describeApprovedBudget(status.approved_budget)} from your Haven wallet.` : "Budget approved \u{1F389} \u2014 the agent can now spend within its Haven rules."
+      );
+      return "approved";
+    }
+    if (status.status === "cancelled" || status.status === "expired" || status.status === "failed") {
+      log(`This setup ended in Haven (${status.status}) \u2014 start a fresh connection from the dashboard when ready.`);
+      return "ended";
+    }
+    announceWaiting();
+    if (i > 0 && i % remindEvery === 0) {
+      const elapsedSeconds = Math.round(i * intervalMs / 1e3);
+      log(
+        `Still waiting for budget approval in Haven \u2014 ${elapsedSeconds}s elapsed, checking every ${Math.round(intervalMs / 1e3)}s. I'll stop waiting after ${describeWaitBound(timeoutMs)}; you can approve later and the tools unlock then.`
       );
-      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",
-        level: probe.status === "ok" ? "ok" : "failed",
-        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: repairCommandFor(input.runtime) }
-      });
     }
-  } else {
-    checks.push({
-      id: "signer_process",
-      label: "Signer stdio handshake",
-      level: "failed",
-      detail: "Skipped \u2014 no prepared signer runtime to probe.",
-      repair: repairCommandFor(input.runtime)
-    });
   }
-  return { checks, ...signerCapabilities ? { signerCapabilities } : {} };
+  log(
+    "Budget approval is still pending in Haven. Approve it in the dashboard whenever you are ready \u2014 the agent tools unlock the moment you do. Verify later with the read-only haven_get_agent tool."
+  );
+  return "pending";
 }
-async function runDoctor(input, deps = {}) {
-  const homeDir = deps.homeDir ?? homedir();
-  const checks = [];
-  let signerCapabilities;
-  const { directory, others, parkedOnly } = await discoverCredentialDirectory(homeDir, input.credentialsDir);
-  const resolution = await resolveDoctorRuntime(input, directory);
-  const runtime = resolution.runtime;
-  const input2 = { ...input, runtime };
-  const normalizedRuntime = normalizeRuntimeName(input2.runtime);
-  const configPath = runtimeConfigPathFor(normalizedRuntime ?? input2.runtime, homeDir);
-  let configText = null;
-  if (configPath !== null) {
+function completionHandoffLines(result, approval, approvalUrl) {
+  const approveStep = approvalUrl ? `Approve the budget at ${approvalUrl}. Approval \u2014 not restarting \u2014 unlocks Haven tools.` : "Return to Haven and approve the budget. Approval \u2014 not restarting \u2014 unlocks Haven tools.";
+  if (result.errorCode === "manual_runtime_setup_required") {
+    return [
+      "Next steps:",
+      `1. ${approveStep}`,
+      "2. Finish the manual MCP setup using the secret-free file references printed above, then start a fresh session in your runtime.",
+      `3. ${runtimeVerificationInstruction(result.runtime)}`
+    ];
+  }
+  if (result.errorCode) {
+    return [
+      "Recovery: runtime setup is not complete. Resolve the reported problem, then return to Haven for a fresh connection and run its new connector command. Do not manually edit runtime config or paste credentials into prompts, logs, or config."
+    ];
+  }
+  if (approval === "ended") {
+    return [
+      "Next step: this setup ended in Haven before the budget was approved, so there is nothing left to approve on it \u2014 start a fresh connection from the dashboard when ready."
+    ];
+  }
+  const profile = runtimeProfile(result.runtime);
+  const activation = activationInstructionWithWhy(profile);
+  if (approval === "approved") {
+    return [
+      "Next steps \u2014 the budget is already approved, so there is nothing more to do in Haven:",
+      `1. ${activation}`,
+      `2. ${runtimeVerificationInstruction(result.runtime)}`
+    ];
+  }
+  return [
+    "Next steps:",
+    `1. ${approveStep}`,
+    `2. ${activation}`,
+    `3. ${runtimeVerificationInstruction(result.runtime)}`
+  ];
+}
+function activationInstructionWithWhy(profile) {
+  if (profile.restartMode === "restart-session") {
+    return `${profile.activationInstruction} (The entries are already written and verified \u2014 ${profile.label} only reads MCP config when a session starts, which is why this step is still needed.)`;
+  }
+  if (profile.restartMode === "restart-app") {
+    return `${profile.activationInstruction} (The entries are already written and verified \u2014 ${profile.label} only reads MCP config at app launch, which is why this step is still needed.)`;
+  }
+  return profile.activationInstruction;
+}
+async function listExistingKeyedAgents(baseDir) {
+  const root = defaultCredentialRoot(baseDir);
+  let entries = [];
+  try {
+    entries = await readdir(root);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of entries) {
+    const directory = join(root, entry);
     try {
-      configText = await readFile(configPath, "utf8");
+      const identity = JSON.parse(await readFile(join(directory, "identity.json"), "utf8"));
+      if (typeof identity.api_key !== "string" || identity.api_key.length === 0) continue;
+      let agent = {};
+      try {
+        agent = JSON.parse(await readFile(join(directory, "agent.json"), "utf8"));
+      } catch {
+      }
+      const { accountAddress } = readStoredAccountAddress(identity, agent);
+      out.push({ agentId: typeof identity.agent_id === "string" ? identity.agent_id : entry, directory, accountAddress: accountAddress ?? null });
     } catch {
-      configText = null;
     }
   }
-  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;
-    }
+  return out;
+}
+async function listOtherAgentIds(baseDir, currentDirectory) {
+  const root = defaultCredentialRoot(baseDir);
+  let entries = [];
+  try {
+    entries = await readdir(root);
+  } catch {
+    return null;
   }
-  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, input2.runtime, slug)] : [],
-        ...rekeyPending ? { rekeyPending } : {}
-      });
+  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;
     }
-    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 }, input2, deps);
-      entry.checks = result.checks;
-      capabilitiesByDirectory.set(dir, result.signerCapabilities);
-    } else if (rekeyPending) {
-      entry.checks = [rekeyPendingCheck(rekeyPending, void 0, input2.runtime, slug)];
+    try {
+      const identity = JSON.parse(await readFile(identityPath, "utf8"));
+      ids.push(identity.agent_id ?? entry);
+    } catch {
+      ids.push(entry);
     }
-    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);
+  return ids;
+}
+function printNextSteps(result, log, approval, approvalUrl) {
+  for (const line of completionHandoffLines(result, approval, approvalUrl)) log(line);
+}
+var CONNECTOR_VERSION, CONNECTOR_CLIENT_IDENTITY, CONNECT_OUTCOME_SCHEMA_VERSION, failureOutcomesByError, RERUN_HINT;
+var init_runtime = __esm({
+  "src/runtime.ts"() {
+    init_api();
+    init_key();
+    init_redact();
+    init_server_names();
+    init_storage();
+    init_runtime_install();
+    init_runtime_registry();
+    init_connect_error();
+    init_installed_clients();
+    init_wiring_collision();
+    init_unwire();
+    init_tombstone();
+    init_local_mcp_runtime();
+    init_runtime_manifest();
+    CONNECTOR_VERSION = "0.0.0-dev.202609251409.98ed67a";
+    CONNECTOR_CLIENT_IDENTITY = `@haven_ai/connect/${CONNECTOR_VERSION}`;
+    CONNECT_OUTCOME_SCHEMA_VERSION = 1;
+    failureOutcomesByError = /* @__PURE__ */ new WeakMap();
+    RERUN_HINT = connectorRerunCommand();
   }
-  if (!primaryDirectory) {
-    checks.push({
-      id: "credentials",
-      label: "Agent credentials",
-      level: "failed",
-      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 },
-        input2,
-        deps
-      );
-      signerCapabilities = result.signerCapabilities;
-      for (const check of result.checks) primaryChecksById.set(check.id, check);
+});
+
+// src/rekey-messages.ts
+var REKEY_FINISH_NEEDS_API_KEY;
+var init_rekey_messages = __esm({
+  "src/rekey-messages.ts"() {
+    REKEY_FINISH_NEEDS_API_KEY = "--rekey-finish needs --api-key <key> \u2014 the one the Haven agent page showed once.";
+  }
+});
+
+// src/prune-runtimes.ts
+var prune_runtimes_exports = {};
+__export(prune_runtimes_exports, {
+  normalizeRuntimePath: () => normalizeRuntimePath,
+  pruneSignerRuntimes: () => pruneSignerRuntimes,
+  referencedRuntimeDirectories: () => referencedRuntimeDirectories,
+  rollUpPruneLevel: () => rollUpPruneLevel,
+  signerRuntimeRoot: () => signerRuntimeRoot
+});
+function signerRuntimeRoot(homeDir) {
+  return join(homeDir, ".haven", "signer-runtime");
+}
+function classifyKey(key) {
+  if (key.startsWith("override-")) return "override";
+  if (key === MCP_RUNTIME_MANIFEST.signerVersion || /^\d+\.\d+\.\d+/.test(key)) return "version";
+  return "unknown";
+}
+async function directoryBytes(directory) {
+  let total = 0;
+  const walk = async (dir) => {
+    let entries = [];
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
     }
-    for (const id of ["credentials", "signer_runtime", "runtime_spec_override"]) {
-      const check = primaryChecksById.get(id);
-      if (check) checks.push(check);
+    for (const entry of entries) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) await walk(path);
+      else if (entry.isFile()) {
+        try {
+          total += (await stat(path)).size;
+        } catch {
+        }
+      }
     }
+  };
+  await walk(directory);
+  return total;
+}
+async function normalizeRuntimePath(path) {
+  const resolved = resolve(path).replace(/[\\/]+$/, "");
+  try {
+    return await realpath(resolved);
+  } catch {
+    return resolved;
   }
-  const runtimeOwnsNoConfig = normalizedRuntime !== null && configPath === null;
-  if (configPath === null && input2.runtime !== "" && normalizedRuntime === null) {
-    checks.push({
-      id: "runtime_config",
-      label: "Runtime MCP config",
-      level: "failed",
-      detail: `Runtime '${input2.runtime}' is not one the connector recognises. The runtime config was NOT checked. Re-run the doctor naming the runtime \u2014 one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`,
-      repair: `Re-run the doctor naming the runtime \u2014 one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`
-    });
-  } else if (configPath === null && input2.runtime === "") {
-    checks.push({
-      id: "runtime_config",
-      label: "Runtime MCP config",
-      level: "failed",
-      detail: `Runtime is unknown \u2014 no runtime flag was given and the connector's record in ${primaryDirectory ?? input.credentialsDir ?? "~/.haven/agents"} carries no resolvable ${CONNECT_OUTCOME_FILENAME} runtime. The runtime config was NOT checked. Re-run the doctor naming the runtime \u2014 one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`,
-      repair: `Re-run the doctor naming the runtime \u2014 one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`
-    });
-  } else if (configPath === null) {
-    checks.push({
-      id: "runtime_config",
-      label: "Runtime MCP config",
-      level: "ok",
-      detail: `Runtime '${input2.runtime}' is configured through its own CLI or by hand (${input2.runtime === "other" ? "manual runtime" : "CLI-managed"}) and has no file-based config the connector owns \u2014 skipping the file check.`
-    });
-  } else if (configText === null) {
-    checks.push({
-      id: "runtime_config",
-      label: "Runtime MCP config",
-      level: "failed",
-      detail: `No runtime config at ${configPath}.`,
-      repair: repairCommandFor(input2.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",
-      level: ok ? "ok" : "failed",
-      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: repairCommandFor(input2.runtime) }
-    });
-  }
-  for (const id of ["hosted_mcp", "identity_match", "rekey_pending"]) {
-    const check = primaryChecksById.get(id);
-    if (check) checks.push(check);
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function referencedRuntimeDirectories(homeDir, credentialsDir) {
+  const roots = /* @__PURE__ */ new Set([join(homeDir, ".haven", "agents")]);
+  if (credentialsDir) roots.add(dirname(resolve(credentialsDir)));
+  const referenced = /* @__PURE__ */ new Map();
+  const runtimeRoot = await normalizeRuntimePath(signerRuntimeRoot(homeDir));
+  const rootSpellings = [.../* @__PURE__ */ new Set([resolve(signerRuntimeRoot(homeDir)), runtimeRoot])];
+  const wrapperRe = new RegExp(`(?:${rootSpellings.map(escapeRegExp).join("|")})[\\/]+([^\\/'"\\s]+)`, "g");
+  const add = async (runtimeDirectory, by) => {
+    const key = await normalizeRuntimePath(runtimeDirectory);
+    const list = referenced.get(key) ?? [];
+    if (!list.includes(by)) list.push(by);
+    referenced.set(key, list);
+  };
+  for (const root of roots) {
+    let entries = [];
+    try {
+      entries = await readdir(root);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const directory = join(root, entry);
+      try {
+        const sidecar = JSON.parse(await readFile(join(directory, "signer-runtime.json"), "utf8"));
+        if (typeof sidecar.runtime_directory === "string" && sidecar.runtime_directory.length > 0) {
+          await add(sidecar.runtime_directory, directory);
+        }
+      } catch {
+      }
+      try {
+        const wrapper = await readFile(join(directory, "bin", "haven-signer.mjs"), "utf8");
+        for (const match of wrapper.matchAll(wrapperRe)) await add(join(runtimeRoot, match[1]), directory);
+      } catch {
+      }
+    }
   }
-  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);
-      if (!identity?.api_key || !identity.api_url) {
-        if (tombstone) retired.push(`${otherAgent} (retired ${tombstone.retired_at})`);
-        else unverifiable.push(`${otherAgent} (no stored key/API URL to probe)`);
-        continue;
-      }
-      const suffix = tombstone ? " [tombstoned \u2014 key material still present]" : "";
-      const probe = await (deps.probeHostedIdentity ?? probeHostedAgentIdentity)(
-        identity.api_key,
-        identity.api_url,
-        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 knownIds = new Set([...inventory].map((e) => e.agentId ?? basename(e.directory)));
-    const ledgerDir = input.credentialsDir ? tombstonesDirForAgentDirectory(input.credentialsDir, homeDir) : join(homeDir, ".haven", "tombstones");
-    const ghostRecords = (await readTombstoneRecords(ledgerDir)).filter(
-      (rec) => !knownIds.has(rec.agent_id)
-    );
-    if (ghostRecords.length > 0) {
-      parts.push(
-        `retired records (dir removed): ${ghostRecords.map((rec) => `${rec.agent_id} (${rec.reason})`).join(", ")}`
-      );
-    }
-    const supersededLive = live.filter((item) => item.entry.classification !== "wired").map((item) => item.label);
-    const classificationUnreliable = configText === null && runtimeOwnsNoConfig;
-    const supersededLevel = supersededLive.length === 0 ? "ok" : classificationUnreliable ? "advisory" : "failed";
-    checks.push({
-      id: "superseded_agents",
-      label: "Superseded agent credentials",
-      level: supersededLevel,
-      detail: supersededLevel === "failed" ? `${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.` : supersededLevel === "advisory" ? `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}. Runtime '${input2.runtime}' has no config file the connector can read, so which of these agents are wired cannot be verified from this machine: a live key here may be an agent you use deliberately, or one a host started before your latest setup is still spending as.` : `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}.`,
-      ...supersededLevel === "failed" ? {
-        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.`
-      } : supersededLevel === "advisory" ? {
-        repair: `Check ${supersededLive.join(", ")} on the Haven agent page: revoke the ones you no longer use, then remove their director(y/ies) under ~/.haven/agents. Connect never revokes or deletes for you.`
-      } : {}
-    });
-  }
-  const bindings = (await Promise.all(
-    inventory.filter((entry) => entry.classification !== "retired").map(async (entry) => ({ entry, binding: await readMcpServerBinding(entry.directory) }))
-  )).filter((item) => item.binding !== null);
-  const byName = /* @__PURE__ */ new Map();
-  for (const item of bindings) {
-    const list = byName.get(item.binding.server_name) ?? [];
-    list.push(item);
-    byName.set(item.binding.server_name, list);
-  }
-  const rebound = [...byName.entries()].filter(([, items]) => items.length > 1);
-  if (rebound.length > 0) {
-    const parts = rebound.map(([name, items]) => {
-      const ordered = [...items].sort((a, b) => a.binding.bound_at < b.binding.bound_at ? -1 : a.binding.bound_at > b.binding.bound_at ? 1 : 0);
-      const backends = new Set(ordered.map((i) => withoutUserinfo(i.binding.api_url)));
-      return `'${name}': ` + ordered.map((i) => `${i.binding.agent_id} on ${withoutUserinfo(i.binding.api_url)} at ${i.binding.bound_at} [${i.entry.classification}]`).join(" \u2192 ") + (backends.size > 1 ? " (BACKEND CHANGED)" : "");
-    });
-    checks.push({
-      id: "mcp_server_name_rebound",
-      label: "MCP server names bound more than once",
-      level: "advisory",
-      detail: `${rebound.length} MCP server name${rebound.length === 1 ? "" : "s"} changed hands on this machine (locally recorded bindings; the backend's own record is the authority for the same backend): ${parts.join("; ")}. A saved session, script or document naming the server may still mean the earlier agent.`,
-      repair: `Retire the earlier director(y/ies) with ${RERUN} --unwire <dir> to release the name, or keep both and address them by --name.`
-    });
-  }
-  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",
-      level: abandoned.length === 0 ? "ok" : "failed",
-      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 prune = await (deps.pruneSignerRuntimes ?? pruneSignerRuntimes)({ dryRun: true, measure: false }, { homeDir, credentialsDir: input.credentialsDir });
-  const unused = prune.entries.filter((entry) => entry.action === "would_remove");
-  if (unused.length > 0) {
-    checks.push({
-      id: "signer_runtime_unused",
-      label: "Unused signer-runtime directories",
-      level: "advisory",
-      detail: `${unused.length} signer-runtime director${unused.length === 1 ? "y" : "ies"} under ${prune.root} that no credential directory names: ${unused.map((entry) => entry.key).join(", ")}. Nothing is broken; they are left over from earlier pins or overrides (sizes: --prune-signer-runtimes --dry-run).`,
-      repair: `Run: ${RERUN} --prune-signer-runtimes (add --dry-run to list only).`
-    });
-  }
-  if (resolution.origin === "record") {
-    const rc = checks.find((check) => check.id === "runtime_config");
-    if (rc) {
-      rc.detail += ` (Resolved '${resolution.runtime}' from ${join(directory ?? "", CONNECT_OUTCOME_FILENAME)}; pass --runtime to check a different one.)`;
-    }
-  }
-  const restart = normalizedRuntime === null ? false : restartRequiredForRuntime(input2.runtime, deps.env);
-  checks.push({
-    id: "restart",
-    label: "Runtime restart",
-    level: "ok",
-    detail: restart ? "This runtime loads MCP config at startup \u2014 restart it after any repair before expecting the tools to appear." : input2.runtime === "" ? "Runtime is unknown \u2014 whether a restart is needed cannot be determined. Re-run the doctor naming the runtime for a definitive answer." : "No restart requirement known for this runtime."
-  });
-  const wiredChecks = inventory.filter((entry) => entry.classification === "wired").flatMap((entry) => entry.checks);
-  const finalChecks = checks.map(finalizeCheck);
-  const level = rollUpLevel([...finalChecks, ...wiredChecks]);
-  return {
-    version: 1,
-    ok: level !== "failed",
-    level,
-    runtime: input2.runtime,
-    credentialDirectory: primaryDirectory,
-    checks: finalChecks,
-    agents: inventory,
-    ...signerCapabilities ? { signerCapabilities } : {}
-  };
+  return referenced;
 }
-async function runRepair(input, deps = {}) {
+function rollUpPruneLevel(entries) {
+  if (entries.some((e) => e.level === "failed")) return "failed";
+  if (entries.some((e) => e.level === "advisory")) return "advisory";
+  return "ok";
+}
+async function pruneSignerRuntimes(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 {
-      ok: false,
-      messages: [`No agent credentials found to repair \u2014 run the full setup: ${RERUN} --setup <token>.`]
-    };
-  }
-  const resolution = await resolveDoctorRuntime(input, directory);
-  if (resolution.origin === "record") {
-    messages.push(`Runtime not given \u2014 resolved '${resolution.runtime}' from ${join(directory, CONNECT_OUTCOME_FILENAME)}.`);
-  }
-  const runtime = resolution.runtime;
-  const input2 = { ...input, runtime };
-  if (runtime === "") {
-    return {
-      ok: false,
-      messages: [
-        "Runtime is unknown \u2014 no runtime flag was given and the connector record carries no resolvable runtime.",
-        `Repair rewrites the runtime config, so it will not guess. Re-run repair naming the runtime \u2014 one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`
-      ]
-    };
-  }
-  let identity;
+  const root = signerRuntimeRoot(homeDir);
+  const measure = input.measure ?? true;
+  const referenced = await referencedRuntimeDirectories(homeDir, deps.credentialsDir);
+  const pin = await normalizeRuntimePath(join(root, MCP_RUNTIME_MANIFEST.signerVersion));
+  const remove = deps.rm ?? (async (directory) => rm(directory, { recursive: true, force: false }));
+  const entries = [];
+  let keys = [];
   try {
-    identity = JSON.parse(await readFile(join(directory, "identity.json"), "utf8"));
+    keys = (await readdir(root, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name).sort();
   } 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."] };
+    return { version: 1, root, dryRun: input.dryRun, entries, removed: 0, reclaimedBytes: 0, level: "ok" };
   }
-  const configPath = runtimeConfigPathFor(normalizeRuntimeName(input2.runtime) ?? input2.runtime, homeDir);
-  if (configPath) {
+  let removed = 0;
+  let reclaimedBytes = 0;
+  for (const key of keys) {
+    const directory = join(root, key);
+    const normalized = await normalizeRuntimePath(directory);
+    const referencedBy = referenced.get(normalized) ?? [];
+    const kind = classifyKey(key);
+    if (referencedBy.length > 0 || normalized === pin) {
+      entries.push({
+        directory,
+        key,
+        kind,
+        bytes: 0,
+        referencedBy,
+        action: "kept",
+        level: "ok",
+        detail: referencedBy.length > 0 ? `kept \u2014 named by ${referencedBy.length} credential director${referencedBy.length === 1 ? "y" : "ies"} (sidecar or wrapper)` : "kept \u2014 the connector's current pinned version (what --repair installs)"
+      });
+      continue;
+    }
+    const bytes = measure ? await directoryBytes(directory) : 0;
+    if (input.dryRun) {
+      entries.push({
+        directory,
+        key,
+        kind,
+        bytes,
+        referencedBy,
+        action: "would_remove",
+        level: "advisory",
+        detail: `would remove \u2014 no credential directory names it (${kind}-keyed)`
+      });
+      continue;
+    }
     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 connector command (with --local) to repair a local-stdio install."
-          ]
-        };
-      }
-    } catch {
+      await remove(directory);
+      removed += 1;
+      reclaimedBytes += bytes;
+      entries.push({ directory, key, kind, bytes, referencedBy, action: "removed", level: "ok", detail: `removed \u2014 no credential directory named it (${kind}-keyed)` });
+    } catch (err) {
+      entries.push({
+        directory,
+        key,
+        kind,
+        bytes,
+        referencedBy,
+        action: "failed",
+        level: "failed",
+        detail: `removal failed: ${err instanceof Error ? err.message : String(err)} \u2014 a signer process may still hold it open; stop it and re-run`
+      });
     }
   }
-  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, env: deps.env }
-  );
-  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({
-    // Normalized for the WRITE too (#3145 review round 3): `writeRuntimeConfig`
-    // switches on the id, and the raw alias fell to its "manual runtime" arm
-    // — a repair that reported success while writing nothing.
-    runtime: normalizeRuntimeName(input2.runtime) ?? input2.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 };
+  return { version: 1, root, dryRun: input.dryRun, entries, removed, reclaimedBytes, level: rollUpPruneLevel(entries) };
 }
-var RERUN;
-var init_doctor = __esm({
-  "src/doctor.ts"() {
-    init_prune_runtimes();
+var init_prune_runtimes = __esm({
+  "src/prune-runtimes.ts"() {
     init_runtime_manifest();
-    init_probes();
-    init_signer_runtime();
-    init_runtime_spec_override();
-    init_config_writers();
-    init_runtime_registry();
-    init_signer_consent();
-    init_tombstone();
-    init_server_names();
-    init_storage();
-    init_redact();
-    RERUN = connectorRerunCommand();
   }
 });
 
-// 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 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);
-  });
-}
-function installedClientHint(candidates) {
-  const installedClients = candidates.map((candidate) => candidate.runtime);
-  if (candidates.length === 1) {
-    return { installedClients, suggestedRuntime: candidates[0].runtime };
-  }
-  const configured = candidates.filter((candidate) => candidate.evidence === "config-file");
-  return configured.length === 1 ? { installedClients, suggestedRuntime: configured[0].runtime } : { installedClients };
-}
-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"
-  );
-}
-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 connector command again, or pass --runtime <name> to skip the prompt.`,
-    "rerun_connect_and_choose_a_runtime"
+// 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
   );
-}
-async function pathExists(path) {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function defaultPromptIo() {
+  const api = (deps.createApi ?? ((url) => createConnectApiClient(url, void 0, CONNECTOR_CLIENT_IDENTITY)))(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 = [
+    connectorRerunCommand("--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 {
-    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));
-    })
+    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}.`
+    ]
   };
 }
-
-// src/wiring-collision.ts
-init_server_names();
-init_signer_runtime();
-init_storage();
-init_tombstone();
-async function detectWiringCollision(input) {
-  const root = defaultCredentialRoot(input.credentialsDir);
-  let entries = [];
-  try {
-    entries = await readdir(root);
-  } catch {
-    return null;
+async function finishRekey(options, deps = {}) {
+  const now = deps.now ?? (() => Date.now());
+  if (!options.newApiKey) {
+    throw new Error(REKEY_FINISH_NEEDS_API_KEY);
   }
-  const superseded = [];
-  const taken = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    const directory = join(root, entry);
-    let identityRaw;
-    try {
-      identityRaw = await readFile(join(directory, "identity.json"), "utf8");
-    } catch {
-      continue;
+  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, void 0, CONNECTOR_CLIENT_IDENTITY)))(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,
+    // The stored value (already new-name-first, from the credential-FILE
+    // permanent fallback) wins; the hosted identity's `account_address` is a
+    // LIVE server read, which as of #2914 emits only that name.
+    accountAddress: stored.accountAddress ?? identity.account_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, env: deps.env }
+    );
+    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;
+    if (prepared.runtimeSpecOverride) {
+      messages.push(
+        `  Signer runtime:   RUNTIME SPEC OVERRIDE ACTIVE \u2014 ${describeRuntimeSpecOverride(prepared.runtimeSpecOverride.specs)} (NOT the pinned manifest; installed into ${prepared.runtimeDirectory})`
+      );
     }
-    taken.add(entry);
-    let identity;
-    try {
-      identity = JSON.parse(identityRaw);
-    } catch {
-      identity = void 0;
+    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."
+      );
     }
-    if (!identity?.api_key) continue;
-    if (await pathExists2(join(directory, TOMBSTONE_FILENAME))) continue;
-    const sidecar = await readRuntimeSidecar(directory);
-    if (sidecar?.server_name) continue;
-    superseded.push({ directory, agentId: identity.agent_id ?? entry });
+  } 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."
+    );
   }
-  if (superseded.length === 0) return null;
   return {
-    superseded,
-    suggestedServerName: proposeServerSlug(input.agentName, taken)
+    finished: true,
+    agentId: stored.agentId,
+    directory: stored.directory,
+    newDelegateAddress: pending.new_delegate_address,
+    serverNames: { hosted: names.hosted, signer: names.signer },
+    configRewritten,
+    messages
   };
 }
-function proposeServerSlug(agentName, taken) {
-  let base = agentName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").slice(0, 32).replace(/-+$/g, "");
-  if (!slugIsValid(base)) base = "agent";
-  if (!taken.has(base)) return base;
-  for (let n = 2; n < 1e3; n += 1) {
-    const suffix = `-${n}`;
-    const candidate = `${base.slice(0, 32 - suffix.length).replace(/-+$/g, "")}${suffix}`;
-    if (slugIsValid(candidate) && !taken.has(candidate)) return candidate;
-  }
-  throw new Error(`Could not propose an unused server name for ${JSON.stringify(agentName)}.`);
-}
-function slugIsValid(slug) {
+async function probeIdentity(api, apiKey, which) {
   try {
-    assertValidServerSlug(slug);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var MAX_PROMPT_ATTEMPTS2 = 3;
-async function promptWiringCollisionResolution(collision, agentName, io) {
-  const ids = collision.superseded.map((entry) => entry.agentId).join(", ");
-  io.write(`This machine is already wired to a Haven agent with a live key: ${ids}.
-`);
-  io.write(`Setting up "${agentName}" on the bare haven / haven-signer pair would replace that wiring.
-`);
-  io.write("  r) replace \u2014 re-point haven / haven-signer at the new agent and retire the previous directory locally\n");
-  io.write("     (tombstoned, local key files removed; you still revoke it on the Haven agent page)\n");
-  io.write(`  a) alongside \u2014 install as a named agent (suggested: ${collision.suggestedServerName}) with its own
-`);
-  io.write(`     haven-<name> / haven-signer-<name> pair, leaving the current wiring untouched
-`);
-  io.write("  q) quit \u2014 nothing is written and the setup token stays unused\n");
-  for (let attempt = 0; attempt < MAX_PROMPT_ATTEMPTS2; attempt += 1) {
-    const answer = await io.question("Replace, install alongside, or quit? [r/a/q]: ");
-    if (answer === null) return { action: "abort" };
-    const trimmed = answer.trim().toLowerCase();
-    if (trimmed === "r" || trimmed === "replace") return { action: "replace" };
-    if (trimmed === "q" || trimmed === "quit") return { action: "abort" };
-    if (trimmed === "a" || trimmed === "alongside") {
-      const typed = await io.question(`Server name [${collision.suggestedServerName}]: `);
-      if (typed === null) return { action: "abort" };
-      const serverName = typed.trim() === "" ? collision.suggestedServerName : typed.trim();
-      try {
-        assertValidServerSlug(serverName);
-      } catch (err) {
-        io.write(`${err instanceof Error ? err.message : String(err)}
-`);
-        continue;
-      }
-      return { action: "alongside", serverName };
+    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."
+      );
     }
-    io.write(`"${trimmed}" is not one of r, a, q.
-`);
+    throw new Error(
+      `Could not reach Haven to check this agent (${redactSecrets(
+        err instanceof Error ? err.message : String(err)
+      )}). Nothing was changed.`
+    );
   }
-  return { action: "abort" };
 }
-async function pathExists2(path) {
-  try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
+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.`
+    );
   }
-}
-
-// src/runtime.ts
-init_unwire();
-init_tombstone();
-init_local_mcp_runtime();
-init_runtime_manifest();
-var CONNECTOR_VERSION = "0.0.0-dev.202609250737.3bd5a51";
-var CONNECT_OUTCOME_SCHEMA_VERSION = 1;
-var failureOutcomesByError = /* @__PURE__ */ new WeakMap();
-function failureOutcomeFor(runtimeHint, error) {
-  if (error !== null && typeof error === "object") {
-    const recorded = failureOutcomesByError.get(error);
-    if (recorded) return recorded;
+  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.`
+    );
   }
-  return failedConnectOutcome(runtimeHint, error);
-}
-async function runConnect(options, deps = {}) {
-  const trace = {};
-  try {
-    return await executeConnect(options, deps, trace);
-  } catch (err) {
-    const outcome = failedConnectOutcome(trace.runtime ?? options.runtime, err);
-    if (err !== null && typeof err === "object") failureOutcomesByError.set(err, outcome);
-    if (trace.directory) await recordConnectOutcome(deps, trace.directory, outcome);
-    throw err;
+  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.`
+    );
   }
 }
-async function recordConnectOutcome(deps, directory, outcome) {
-  try {
-    return await (deps.writeOutcomeRecord ?? writeConnectOutcomeRecord)(directory, outcome);
-  } catch {
-    return void 0;
+var init_rekey = __esm({
+  "src/rekey.ts"() {
+    init_api();
+    init_runtime_install();
+    init_signer_runtime();
+    init_runtime_spec_override();
+    init_key();
+    init_redact();
+    init_rekey_messages();
+    init_runtime();
+    init_server_names();
+    init_storage();
   }
-}
-async function executeConnect(options, deps, trace) {
-  assertSupportedNodeVersion(deps.nodeVersion, MCP_RUNTIME_MANIFEST.minimumNodeVersion);
-  const connectorVersion = options.connectorVersion ?? CONNECTOR_VERSION;
-  const api = deps.api ?? createConnectApiClient(options.apiBaseUrl);
-  const log = secureLogger(
-    deps.log ?? ((message) => process.stdout.write(`${message}
-`)),
-    deps.redactPaths === true
-  );
-  const writeCredentials = deps.writeCredentials ?? writeCredentialFiles;
-  const preflightStorage = deps.preflightStorage ?? preflightCredentialStorage;
-  const runRuntimeInstall = deps.installRuntime ?? installRuntime;
-  const generateKey = deps.generateKey ?? generateDelegateKey;
-  const generateLocalApiKey = deps.generateApiKey ?? generateAgentApiKey;
-  const selection = await resolveRuntimeSelection(options.runtime, options.runtimeForce, {
-    env: deps.env ?? process.env,
-    selfReported: options.runtimeSelfReport,
-    promptForRuntime: runtimeSelectionPrompt(options, deps)
-  });
-  if (!selection.runtime) {
-    const hint = await installedClientHintFor(deps);
-    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. ` + installedClientProse(hint) + "Nothing was written and the Haven setup token is still unused.",
-      "rerun_connect_with_explicit_runtime",
-      // #2091: the values must ride structurally too. The backend's setup
-      // prompt permits a retry only with "one of the values that refusal
-      // lists" — and --json discards prose, so a prose-only list deadlocked
-      // every automation run in an undetected runtime (Codex in the field:
-      // npx needs network, Codex runs network commands unsandboxed, and the
-      // unsandboxed path carries none of the CODEX_* detection vars).
-      //
-      // #2174: the list alone still leaves the retry a nine-value guess. The
-      // scan below narrows it to what is actually on this machine — as a
-      // HINT. It does not select, and this stays a refusal: see
-      // `installedClientHint`.
-      { allowedRuntimes: RUNTIME_FLAG_VALUE_LIST, ...hint }
+});
+
+// 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("");
   }
-  const runtime = selection.runtime;
-  trace.runtime = runtime;
-  const installCapabilities = runtimeInstallCapabilities(runtime);
-  if (options.localMcp) {
-    if (!supportsLocalMcp(runtime)) {
-      throw new Error(
-        `--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})`);
+  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").'
+      }
+    };
   }
-  if (selection.source === "prompted") {
-    log(`runtime: ${runtime} (chosen at the prompt \u2014 nothing was detected in this environment)`);
+});
+
+// src/doctor.ts
+var doctor_exports = {};
+__export(doctor_exports, {
+  describeAccountAddressKey: () => describeAccountAddressKey,
+  rollUpLevel: () => rollUpLevel,
+  runDoctor: () => runDoctor,
+  runRepair: () => runRepair
+});
+function finalizeCheck(check) {
+  return { ...check, ok: check.level !== "failed" };
+}
+function rollUpLevel(checks) {
+  if (checks.some((check) => check.level === "failed")) return "failed";
+  if (checks.some((check) => check.level === "advisory")) return "advisory";
+  return "ok";
+}
+function runtimeFlagFor(runtime) {
+  return normalizeRuntimeName(runtime) ? ` --runtime ${runtime}` : "";
+}
+function repairCommandFor(runtime, suffix = "") {
+  if (normalizeRuntimeName(runtime)) return `Run: ${RERUN} --doctor --repair --runtime ${runtime}${suffix}`;
+  return `Run: ${RERUN} --doctor --repair --runtime <runtime>${suffix.replace(/\.$/, "")} \u2014 --repair needs the runtime named; one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`;
+}
+async function resolveDoctorRuntime(input, directory) {
+  const explicit = input.runtime.trim();
+  if (explicit) return { runtime: explicit, origin: "flag" };
+  if (directory) {
+    const recorded = await readConnectOutcomeRuntime(directory);
+    if (recorded !== null && normalizeRuntimeName(recorded)) {
+      return { runtime: recorded, origin: "record" };
+    }
   }
-  log("Warming up your connection to Haven\u2026");
-  let setup;
+  return { runtime: "", origin: "unknown" };
+}
+async function discoverCredentialDirectory(homeDir, explicit) {
+  const root = explicit ? dirname(explicit) : join(homeDir, ".haven", "agents");
+  let entries = [];
   try {
-    setup = await api.resolveSetup({
-      setupToken: options.setupToken,
-      connectorVersion,
-      runtime
-    });
-  } catch (err) {
-    throw deadSetupTokenError(err) ?? err;
-  }
-  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);
+    entries = await readdir(root);
+  } catch {
+    return explicit ? { directory: explicit, others: [], parkedOnly: /* @__PURE__ */ new Set() } : { others: [], parkedOnly: /* @__PURE__ */ new Set() };
   }
-  log("Checked local credential storage \u2014 all clear.");
-  let serverName = options.serverName;
-  let replacing;
-  if (!serverName) {
-    const collision = await detectWiringCollision({
-      credentialsDir: options.credentialsDir,
-      agentName: setup.agent.name
-    });
-    if (collision) {
-      const resolution = await resolveWiringCollision(collision, setup.agent.name, options, deps);
-      if (resolution.action === "replace") {
-        replacing = collision;
-        log(
-          `Replacing the existing haven / haven-signer wiring (previous agent(s): ${supersededIds(collision)}). The previous directory is retired locally once the new wiring is written; nothing is revoked.`
-        );
-      } else {
-        serverName = resolution.serverName;
-        assertValidServerSlug(serverName);
-        await assertServerSlugAvailable(serverName, options.credentialsDir);
-        log(`Installing alongside the existing wiring as a named agent: ${serverNamesFor(serverName).hosted} / ${serverNamesFor(serverName).signer}.`);
+  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 existingAgents = await listExistingKeyedAgents(options.credentialsDir);
-  if (existingAgents.length > 0) {
-    log("");
-    log(
-      `Heads-up (before anything is written to this machine): it already carries ${existingAgents.length} agent director${existingAgents.length === 1 ? "y" : "ies"} with stored keys \u2014 ` + existingAgents.map((a) => `${a.agentId}${a.accountAddress ? ` (spends from ${shortAddress(a.accountAddress)})` : ""}`).join(", ") + ". This setup creates a NEW agent alongside them and revokes nothing."
-    );
+  const parkedOnlySet = new Set(parkedOnly);
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  if (explicit) {
+    return {
+      directory: explicit,
+      others: [...candidates.map((c) => c.directory), ...tombstonedOnly, ...parkedOnly].filter((d) => d !== explicit),
+      parkedOnly: parkedOnlySet
+    };
   }
-  const hostedNameForRun = serverNamesFor(serverName).hosted;
-  let reboundFrom;
-  const holders = (await listMcpServerBindings(options.credentialsDir)).filter(({ binding }) => binding.server_name === hostedNameForRun).sort((a, b) => a.binding.bound_at < b.binding.bound_at ? 1 : a.binding.bound_at > b.binding.bound_at ? -1 : 0);
-  const newest = holders[0];
-  if (newest) {
-    const { binding, directory } = newest;
-    const backendChanged = withoutUserinfo(binding.api_url) !== withoutUserinfo(options.apiBaseUrl);
-    const previousApiUrl = withoutUserinfo(binding.api_url);
-    reboundFrom = { server_name: binding.server_name, agent_id: binding.agent_id, api_url: previousApiUrl, bound_at: binding.bound_at, backend_changed: backendChanged };
-    const beingReplaced = replacing?.superseded.some((entry) => entry.directory === directory) ?? false;
-    log(
-      `Heads-up: the MCP server name '${binding.server_name}' was bound to agent ${binding.agent_id} on ${previousApiUrl} at ${binding.bound_at} (locally recorded${holders.length > 1 ? `; ${holders.length - 1} older record${holders.length > 2 ? "s" : ""} also claim${holders.length > 2 ? "" : "s"} it` : ""}). ` + (beingReplaced ? `This run replaces that wiring, as you chose, with a new agent on ${withoutUserinfo(options.apiBaseUrl)}` : `This run rebinds it to a new agent on ${withoutUserinfo(options.apiBaseUrl)}`) + (backendChanged ? " \u2014 a DIFFERENT backend: any saved session, script or document naming this MCP server now resolves to a different backend and agent." : ".")
-    );
+  if (candidates.length === 0 && tombstonedOnly.length === 0 && parkedOnly.length === 0) {
+    return { others: [], parkedOnly: parkedOnlySet };
   }
-  const localKey = generateKey();
-  const localApiKey = generateLocalApiKey();
-  log("Minting a fresh signing key and API key \u2014 both stay on this machine.");
-  const proofSignature = await localKey.signChallenge(setup.challenge.message);
-  log("Introducing your agent to Haven\u2026");
-  let registration;
-  try {
-    registration = await api.registerSetup({
-      setupToken: options.setupToken,
-      connectorVersion,
-      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(serverName).hosted,
-      // #2528: 'prose' is the default because it is what a caller who says
-      // nothing is doing — the library entry point is not a --json run.
-      runMode: options.runMode ?? "prose",
-      connectorContext: {
-        environment_label: options.environmentLabel ?? "Local workspace",
-        config_target: installCapabilities.canWriteRuntimeConfig ? "agent runtime MCP config" : "local credential files"
-      },
-      installCapabilities
-    });
-  } catch (err) {
-    const dead = deadSetupTokenError(err);
-    if (dead) throw dead;
-    if (isExpiredSetupChallenge(err)) {
-      throw new Error(
-        "The Haven setup challenge expired while connecting. Return to Haven, start a fresh connection, and run its new connector command. Do not reuse or paste credentials."
-      );
+  return {
+    directory: candidates[0]?.directory,
+    others: [...candidates.slice(1).map((c) => c.directory), ...tombstonedOnly, ...parkedOnly],
+    parkedOnly: parkedOnlySet
+  };
+}
+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;
     }
-    throw err;
+    return false;
   }
-  log(`Registered signing address with Haven: ${shortAddress(registration.delegate_address)}.`);
-  log("Tucking your credentials away safely on disk\u2026");
-  const credentialPaths = await writeCredentials({
-    baseDir: options.credentialsDir,
-    agentId: registration.agent_id,
-    serverName,
-    apiKey: localApiKey,
-    delegateKey: localKey.privateKey,
-    delegateAddress: localKey.address,
-    accountAddress: setup.haven_wallet.address,
-    chainId: setup.haven_wallet.chain_id,
-    network: setup.haven_wallet.network,
-    agentBudget: setup.agent_budget.map((budget) => ({
-      token_symbol: budget.token_symbol,
-      allowance_amount: budget.allowance_amount,
-      reset_period_min: budget.reset_period_min
-    })),
-    apiUrl: options.apiBaseUrl,
-    hostedMcpUrl: registration.hosted_mcp_url,
-    x402BindingSigner: setup.x402_binding_signer ?? void 0,
-    warn: log
-  });
-  trace.directory = credentialPaths.directory;
-  try {
-    const bindingRecord = {
-      version: 1,
-      server_name: hostedNameForRun,
-      signer_name: serverNamesFor(serverName).signer,
-      agent_id: registration.agent_id,
-      api_url: withoutUserinfo(options.apiBaseUrl),
-      // never persist `user:pass@` (#3154 doc review r2)
-      ...registration.hosted_mcp_url ? { hosted_mcp_url: registration.hosted_mcp_url } : {},
-      bound_at: (/* @__PURE__ */ new Date()).toISOString()
+  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) {
+  return finalizeCheck(rekeyPendingVerdict(status, hostedDelegateAddress, runtime, slug));
+}
+function rekeyPendingVerdict(status, hostedDelegateAddress, runtime, slug) {
+  const label = "Pending re-key";
+  const nameFlag = slug ? ` --name ${slug}` : "";
+  if (status.state === "unreadable") {
+    return {
+      id: "rekey_pending",
+      label,
+      level: "failed",
+      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}`
     };
-    await writeMcpServerBinding(credentialPaths.directory, bindingRecord);
-  } catch {
-    log("Could not record the MCP server-name binding locally (non-fatal; the next setup cannot see this binding).");
   }
-  log(`Stored Haven identity credential locally: ${credentialPaths.identityPath}`);
-  log(`Stored local signer credential locally: ${credentialPaths.signerPath}`);
-  log(`Stored non-secret agent orientation locally: ${credentialPaths.agentPath}`);
-  if (setup.x402_binding_signer) {
-    log("Configured x402 binding signer for the local signer.");
-  } else {
-    log(
-      "Warning: Haven did not provide an x402 binding signer, so x402 payments will not sign until HAVEN_X402_BINDING_SIGNER is set for the signer. Non-x402 payments are unaffected."
+  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 {
+      id: "rekey_pending",
+      label,
+      level: "failed",
+      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>${runtimeFlagFor(runtime)}`
+    };
+  }
+  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,
+      level: "failed",
+      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 {
+    id: "rekey_pending",
+    label,
+    level: "ok",
+    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
+  };
+}
+async function runtimeSpecOverrideCheck(directory, sidecar, env) {
+  const facts = [];
+  const installed = sidecar?.runtime_spec_override;
+  if (installed) {
+    facts.push(
+      `signer runtime installed under ${describeRuntimeSpecOverride(installed.specs)} (resolved: ${installed.resolved_specs.join(" ")}; directory key ${installed.directory_key})`
     );
   }
-  const runtimeInstall = await runRuntimeInstall({
-    runtime,
-    hostedMcpUrl: registration.hosted_mcp_url,
-    apiKey: localApiKey,
-    signerPath: credentialPaths.signerPath,
-    identityPath: credentialPaths.identityPath,
-    credentialDirectory: credentialPaths.directory,
-    environmentLabel: options.environmentLabel ?? "Local workspace",
-    ackSigner: options.ackSigner,
-    ackLocalTools: options.ackLocalTools,
-    localMcp: options.localMcp,
-    serverName
-  }, {
-    onProgress: log,
-    // #1543: report "runtime configured" the moment the config write settles,
-    // so the dashboard can expose its budget-approval controls without
-    // waiting on the probes and skill install — a tail that approval does not
-    // depend on. Silent and best-effort: the complete report below remains
-    // authoritative (it overwrites these keys, adding the probe verdicts and
-    // skill state), so an early failure costs nothing but the head start.
-    onRuntimeConfigured: async (early) => {
-      try {
-        await api.updateInstallStatus(registration.setup_id, localApiKey, {
-          runtime: early.runtime,
-          connectorVersion,
-          runtimeMcpMode: early.runtimeMcpMode,
-          hostedMcpConfigured: early.hostedMcpConfigured,
-          localSignerConfigured: early.localSignerConfigured,
-          localMcpConfigured: early.localMcpConfigured,
-          credentialFilesWritten: true,
-          signerAcknowledged: early.signerAcknowledged,
-          localMcpAcknowledged: early.localMcpAcknowledged,
-          restartRequired: early.restartRequired,
-          nextUserAction: early.nextUserAction,
-          errorCode: early.errorCode ?? null,
-          environmentLabel: options.environmentLabel ?? "Local workspace"
-        });
-        if (!early.errorCode || early.errorCode === "manual_runtime_setup_required") {
-          log(approveBudgetCta(setup, registration.approval_url));
-        }
-      } catch {
-      }
-    }
-  });
-  printRuntimeInstall(runtimeInstall, log);
-  if (runtimeInstall.errorCode) {
-    log("Haven setup needs a couple more steps on this machine \u2014 see the notes above.");
-  } else {
-    log("Haven setup on this machine is complete.");
+  const mcpInstalled = await readMcpSidecarOverride(directory);
+  if (mcpInstalled) {
+    facts.push(
+      `local MCP runtime installed under ${describeRuntimeSpecOverride(mcpInstalled.specs)} (resolved: ${mcpInstalled.resolved_specs.join(" ")}; directory key ${mcpInstalled.directory_key})`
+    );
   }
-  let supersededAgentsRetiredLocally;
-  const retiredAgentIds = [];
-  const retirementMirrorErrors = {};
-  if (replacing) {
-    if (runtimeInstall.errorCode) {
-      supersededAgentsRetiredLocally = false;
-      log(
-        `Previous agent(s) ${supersededIds(replacing)} were NOT retired: the runtime install did not complete, so their wiring may still be the only working one. Resolve the install, then retire them with ${RERUN_HINT} --unwire <dir>.`
-      );
-    } else {
-      supersededAgentsRetiredLocally = true;
-      for (const entry of replacing.superseded) {
-        try {
-          const { mirrorError } = await tombstoneDirectoryIfAbsent({
-            directory: entry.directory,
-            agentId: entry.agentId,
-            reason: "replaced by a new setup (--replace)",
-            replacedBy: registration.agent_id,
-            // #3251: the ledger follows this run's credential root (default
-            // root → ~/.haven/tombstones, as before; any other → <root>/.tombstones).
-            tombstonesDir: tombstonesDirForCredentialRoot(options.credentialsDir)
-          });
-          if (mirrorError !== void 0) {
-            retirementMirrorErrors[entry.agentId] = mirrorError;
-            log(
-              `Warning: the surviving tombstone record for ${entry.agentId} could not be written to ${tombstonesDirForCredentialRoot(options.credentialsDir)} (${mirrorError}). The in-place TOMBSTONE.json stands; --doctor will not list this retirement once the directory is deleted.`
-            );
-          }
-          await teardownLocalKeyMaterial(entry.directory, await readIdentityFile(entry.directory));
-          await clearMcpServerBinding(entry.directory);
-          retiredAgentIds.push(entry.agentId);
-          log(`Retired previous agent ${entry.agentId} locally: tombstoned, local key files removed.`);
-        } catch (err) {
-          supersededAgentsRetiredLocally = false;
-          log(`Could not retire previous agent ${entry.agentId} locally: ${err instanceof Error ? err.message : String(err)}`);
-        }
-      }
-    }
+  let shell;
+  try {
+    const active = resolveRuntimeSpecOverride(env);
+    if (active) shell = `set in this shell: ${describeRuntimeSpecOverride(active)} \u2014 a --repair from here installs these, not the pin`;
+  } catch (err) {
+    shell = err instanceof RuntimeSpecOverrideError ? `set in this shell but REFUSED: ${err.message}` : `set in this shell but unreadable: ${err instanceof Error ? err.message : String(err)}`;
   }
-  let supersededScan = null;
-  let supersededAgentIds = [];
+  if (shell) facts.push(shell);
+  if (facts.length === 0) return void 0;
+  const variables = Object.values(RUNTIME_SPEC_ENV).join(" / ");
+  return finalizeCheck({
+    id: "runtime_spec_override",
+    label: "Runtime spec override",
+    level: "failed",
+    detail: `runtime spec overridden \u2014 not the pinned manifest (${MCP_RUNTIME_MANIFEST.signerPackage}@${MCP_RUNTIME_MANIFEST.signerVersion}, ${MCP_RUNTIME_MANIFEST.sdkPackage}@${MCP_RUNTIME_MANIFEST.sdkVersion}). ${facts.join(". ")}.`,
+    repair: `Developer override (#2424). To return to the pinned manifest: unset ${variables}, then run ${RERUN} --doctor --repair --runtime <runtime>. If the override is intentional, this finding is the record of it.`
+  });
+}
+async function readMcpSidecarOverride(directory) {
   try {
-    supersededScan = await listOtherAgentIds(options.credentialsDir, credentialPaths.directory);
-    supersededAgentIds = supersededScan ?? [];
-    if (supersededAgentsRetiredLocally === true) {
-      log("");
-      log(
-        `Replaced: previous agent(s) ${supersededIds(replacing)} are retired on this machine but NOT revoked \u2014 revoke them on the Haven agent page, then restart EVERY long-lived host (gateways, TUI workers, editors): each holds the MCP wiring snapshot from its own start time, and the tombstone speaks only when a stale host next probes the old path.`
-      );
-    } else if (supersededAgentIds.length > 0) {
-      log("");
-      log(
-        `Heads-up: this setup created a NEW agent. Your previous agent(s) \u2014 ${supersededAgentIds.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.`
-      );
-    }
+    const parsed = JSON.parse(await readFile(join(directory, "mcp-runtime.json"), "utf8"));
+    return parsed.runtime_spec_override;
   } catch {
+    return void 0;
   }
+}
+async function readIdentity(directory) {
   try {
-    await api.updateInstallStatus(registration.setup_id, localApiKey, {
-      runtime: runtimeInstall.runtime,
-      connectorVersion,
-      runtimeMcpMode: runtimeInstall.runtimeMcpMode,
-      hostedMcpConfigured: runtimeInstall.hostedMcpConfigured,
-      localSignerConfigured: runtimeInstall.localSignerConfigured,
-      localMcpConfigured: runtimeInstall.localMcpConfigured,
-      credentialFilesWritten: true,
-      signerAcknowledged: runtimeInstall.signerAcknowledged,
-      localMcpAcknowledged: runtimeInstall.localMcpAcknowledged,
-      activationCommandAvailable: Boolean(runtimeInstall.activationCommand),
-      skillInstalled: runtimeInstall.skillInstalled,
-      probeResult: runtimeInstall.probeResult,
-      restartRequired: runtimeInstall.restartRequired,
-      nextUserAction: runtimeInstall.nextUserAction,
-      errorCode: runtimeInstall.errorCode,
-      environmentLabel: options.environmentLabel ?? "Local workspace",
-      // The raw scan result, `null` and all — NOT the flattened
-      // `supersededAgentIds` the outcome carries. Flattening here would hand
-      // the dashboard the same ambiguity this field exists to remove (#2561).
-      supersededAgentIds: supersededScan
-    });
-  } catch (err) {
-    log(`Could not report install status to Haven: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  let approval;
-  const narrateApprovalWait = options.waitForApproval === true || options.waitForApproval === void 0 && (deps.isStdoutTty ?? Boolean(process.stdout.isTTY));
-  if (narrateApprovalWait && !runtimeInstall.errorCode) {
-    approval = await waitForBudgetApproval(api, registration.setup_id, localApiKey, log, options.approvalWait);
+    return JSON.parse(await readFile(join(directory, "identity.json"), "utf8"));
+  } catch {
+    return void 0;
   }
-  printNextSteps(runtimeInstall, log, approval, registration.approval_url);
-  const outcome = completionOutcome({
-    runtimeInstall,
-    delegateAddress: registration.delegate_address,
-    hostedMcpUrl: registration.hosted_mcp_url,
-    supersededAgentIds,
-    supersededAgentsRetiredLocally,
-    ...replacing ? { retiredAgentIds } : {},
-    ...Object.keys(retirementMirrorErrors).length > 0 ? { retirementMirrorErrors } : {},
-    existingAgentsBeforeWrite: existingAgents.map((a) => ({ agent_id: a.agentId, account_address: a.accountAddress })),
-    ...reboundFrom ? { serverNameReboundFrom: reboundFrom } : {},
-    setupChallengeExpiresAt: setup.challenge.expires_at,
-    approvalRequired: registration.agent_status === "pending_approval",
-    approvalUrl: registration.approval_url
-  });
-  if (await recordConnectOutcome(deps, credentialPaths.directory, outcome)) {
-    log(`Saved this run's outcome to ${CONNECT_OUTCOME_FILENAME} in the agent's credential directory.`);
+}
+function describeAccountAddressKey(identity, signerFile) {
+  const files = [identity, signerFile];
+  const has = (key) => files.some((f) => typeof f?.[key] === "string" && f[key].trim() !== "");
+  if (has("account_address")) return "account address stored as account_address";
+  if (has("safe_address")) {
+    return "account address stored under the pre-#2908 name safe_address \u2014 still read; the next --rekey or setup rewrites it as account_address";
   }
-  return {
-    setupId: registration.setup_id,
-    agentId: registration.agent_id,
-    delegateAddress: registration.delegate_address,
-    credentialPaths,
-    outcome
-  };
+  return "no account address stored";
 }
-function completionOutcome(input) {
-  const { runtimeInstall } = input;
-  const manualSetup = runtimeInstall.errorCode === "manual_runtime_setup_required";
-  const nextAction2 = runtimeInstall.nextUserAction;
-  const outcome = {
-    schema_version: CONNECT_OUTCOME_SCHEMA_VERSION,
-    outcome: runtimeInstall.errorCode ? "action_required" : "complete",
-    runtime: runtimeInstall.runtime,
-    topology: runtimeInstall.runtimeMcpMode,
-    configuration: {
-      hosted_mcp: runtimeInstall.hostedMcpConfigured,
-      local_signer: runtimeInstall.localSignerConfigured,
-      local_mcp: runtimeInstall.localMcpConfigured
-    },
-    probe: { result: runtimeInstall.probeResult },
-    activation: {
-      restart_required: runtimeInstall.restartRequired,
-      instruction: manualSetup ? "Finish the manual MCP setup using the secret-free references shown in normal Connect output, then start a fresh session." : runtimeProfile(runtimeInstall.runtime).activationInstruction
-    },
-    next_action: nextAction2,
-    approval: {
-      required: input.approvalRequired,
-      expires_at: null,
-      // Only when there is something to approve AND the backend supplied a
-      // link. Never synthesised here: the connector does not know the
-      // dashboard's origin, and a guessed URL is worse than none — it is the
-      // "do not invent one" rule the agent runbook states, applied to the
-      // tool rather than the agent.
-      ...input.approvalRequired && input.approvalUrl ? { url: input.approvalUrl } : {}
-    },
-    verification: {
-      tools: ["haven_get_agent", "haven_get_allowances"],
-      instruction: runtimeVerificationInstruction(runtimeInstall.runtime)
-    },
-    // The backend contract supplies a 20-byte address. If an unexpected
-    // malformed value arrives, do not echo it into an automation-facing
-    // record; the human log has already been redacted separately.
-    delegate_address: /^0x[0-9a-fA-F]{40}$/.test(input.delegateAddress) ? shortAddress(input.delegateAddress) : "[delegate-address-redacted]",
-    // The endpoint Connect wrote into the runtime's MCP config, verbatim — the
-    // same string that already sits in the user's own config file. Passed
-    // through the secret filter anyway: this is the automation contract, the
-    // value is server-supplied, and belts are cheap (the #1589 stance).
-    ...input.hostedMcpUrl ? { hosted_mcp_url: redactSecrets(input.hostedMcpUrl) } : {},
-    // Always emitted on a completed run, empty list included: "no superseded
-    // agents" is a fact a caller needs, and an omitted key would be
-    // indistinguishable from an older connector that never reported it.
-    superseded_agent_ids: input.supersededAgentIds ?? [],
-    ...input.supersededAgentsRetiredLocally !== void 0 ? { superseded_agents_retired_locally: input.supersededAgentsRetiredLocally } : {},
-    ...input.retiredAgentIds ? { retired_agent_ids: input.retiredAgentIds } : {},
-    ...input.retirementMirrorErrors ? { retirement_mirror_errors: input.retirementMirrorErrors } : {},
-    // #3122: always emitted on a completed run (empty list included), for the
-    // same reason as superseded_agent_ids above.
-    existing_agents_before_write: input.existingAgentsBeforeWrite ?? [],
-    ...input.serverNameReboundFrom ? { server_name_rebound_from: input.serverNameReboundFrom } : {},
-    ...input.setupChallengeExpiresAt ? { setup_challenge_expires_at: input.setupChallengeExpiresAt } : {},
-    ...runtimeInstall.errorCode ? { error: { code: runtimeInstall.errorCode, next_action: nextAction2 } } : {}
+async function checksForAgent(entry, input, deps) {
+  const verdicts = await verdictsForAgent(entry, input, deps);
+  return {
+    checks: verdicts.checks.map(finalizeCheck),
+    ...verdicts.signerCapabilities ? { signerCapabilities: verdicts.signerCapabilities } : {}
   };
-  return outcome;
 }
-async function installedClientHintFor(deps) {
+async function verdictsForAgent(entry, input, deps) {
+  const { directory, identity, sidecar } = entry;
+  const checks = [];
+  let signerCapabilities;
+  let signerFile;
   try {
-    const candidates = await (deps.scanInstalledClients ?? scanInstalledClients)({ env: deps.env });
-    const hint = installedClientHint(candidates);
-    return hint.installedClients.length > 0 ? hint : {};
+    const parsed = JSON.parse(await readFile(join(directory, "signer.json"), "utf8"));
+    signerFile = typeof parsed === "object" && parsed !== null ? parsed : void 0;
   } catch {
-    return {};
+    signerFile = void 0;
   }
-}
-function installedClientProse(hint) {
-  const found = hint.installedClients ?? [];
-  if (found.length === 0) return "";
-  const suggestion = hint.suggestedRuntime ? ` The likeliest is ${hint.suggestedRuntime}, but Haven will not choose for you \u2014 pass it yourself if it is right.` : " Haven will not choose between them for you.";
-  return `Haven can see these agent clients installed here, likeliest first: ${found.join(", ")}.${suggestion} `;
-}
-function runtimeSelectionPrompt(options, deps) {
-  if (!interactivePromptAllowed(options, deps)) return void 0;
-  return deps.promptRuntime ?? (() => resolveRuntimeByInstalledClientPrompt());
-}
-function interactivePromptAllowed(options, deps) {
-  if (options.interactive !== true) return false;
-  return deps.isTty ?? Boolean(process.stdin.isTTY);
-}
-function supersededIds(collision) {
-  return collision.superseded.map((entry) => entry.agentId).join(", ");
-}
-async function resolveWiringCollision(collision, agentName, options, deps) {
-  if (options.replaceExistingWiring) return { action: "replace" };
-  if (interactivePromptAllowed(options, deps)) {
-    const prompt = deps.promptWiringCollision ?? ((c, name) => promptWiringCollisionResolution(c, name, defaultPromptIo()));
-    const resolution = await prompt(collision, agentName);
-    if (resolution.action === "abort") {
-      throw new ConnectError(
-        "wiring_collision_declined",
-        `Setup stopped at your request: this machine is already wired to ${supersededIds(collision)} and you chose neither to replace that wiring nor to install alongside it. Nothing was written: no agent was created, no credentials were stored, and the Haven setup token is still unused. Run the connector command again with --replace to re-point haven / haven-signer at the new agent, or with --name <slug> (e.g. --name ${collision.suggestedServerName}) to install alongside.`,
-        "rerun_connect_with_replace_or_name",
-        { supersededAgentIds: collision.superseded.map((e) => e.agentId), suggestedServerName: collision.suggestedServerName }
+  const credentialsOk = Boolean(identity?.api_key) && signerFile !== void 0;
+  checks.push({
+    id: "credentials",
+    label: "Agent credentials",
+    level: credentialsOk ? "ok" : "failed",
+    detail: credentialsOk ? `identity.json and signer.json parse (agent ${identity?.agent_id ?? "unknown"}; ${describeAccountAddressKey(identity, signerFile)})` : "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)",
+      level: "failed",
+      detail: "No signer-runtime.json sidecar \u2014 the pinned signer runtime was never prepared (or a pre-#1586 npx config).",
+      repair: repairCommandFor(input.runtime)
+    });
+  } else if (sidecar.runtime_spec_override) {
+    const matches = await installedRuntimeMatchesVersions(sidecar.runtime_directory, sidecar.cli_path, {
+      signerVersion: sidecar.signer_version,
+      sdkVersion: sidecar.sdk_version
+    });
+    checks.push({
+      id: "signer_runtime",
+      label: "Signer runtime (preinstalled wrapper)",
+      level: matches ? "ok" : "failed",
+      detail: matches ? `Installed ${sidecar.signer_package}@${sidecar.signer_version} at ${sidecar.runtime_directory} (override install \u2014 see runtime_spec_override)` : `Override runtime directory is stale or empty (${sidecar.runtime_directory}) \u2014 the CLI or package versions are missing.`,
+      ...matches ? {} : { repair: repairCommandFor(input.runtime, " with the same HAVEN_*_SPEC variables set.") }
+    });
+  } else {
+    const intact = await installedRuntimeMatchesVersions(sidecar.runtime_directory, sidecar.cli_path, {
+      signerVersion: sidecar.signer_version,
+      sdkVersion: sidecar.sdk_version
+    });
+    const versionOk = sidecar.signer_version === MCP_RUNTIME_MANIFEST.signerVersion;
+    const ok = intact && versionOk;
+    checks.push({
+      id: "signer_runtime",
+      label: "Signer runtime (preinstalled wrapper)",
+      level: ok ? "ok" : intact ? "advisory" : "failed",
+      detail: ok ? `Installed ${sidecar.signer_package}@${sidecar.signer_version} at ${sidecar.runtime_directory}` : intact ? `Installed version ${sidecar.signer_version} does not match the connector's pinned ${MCP_RUNTIME_MANIFEST.signerVersion} \u2014 intact, but outdated.` : `Runtime directory is stale or empty (${sidecar.runtime_directory}) \u2014 the CLI or package versions are missing.`,
+      ...ok ? {} : { repair: repairCommandFor(input.runtime) }
+    });
+  }
+  const overrideCheck = await runtimeSpecOverrideCheck(directory, sidecar, deps.env ?? process.env);
+  if (overrideCheck) checks.push(overrideCheck);
+  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",
+      level: probe.status === "ok" ? "ok" : "failed",
+      detail: probe.status === "ok" ? `MCP tools endpoint is reachable (${hostedUrl}).` : `MCP tools endpoint probe failed: ${probe.status} (${hostedUrl}).`,
+      ...probe.status === "ok" ? {} : {
+        repair: "Check network access and runtime configuration for the hosted MCP URL, then re-run --doctor."
+      }
+    });
+  } else {
+    checks.push({
+      id: "hosted_mcp",
+      label: "Hosted Haven MCP",
+      level: "failed",
+      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",
+        level: "failed",
+        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${runtimeFlagFor(input.runtime)}`
+      });
+    } else if (!localDelegate) {
+      checks.push({
+        id: "identity_match",
+        label: "Hosted identity matches the local signing key",
+        level: "failed",
+        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",
+        level: same ? "ok" : "failed",
+        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.`
+        }
+      });
+    }
+  }
+  const pending = await inspectRekeyPending(directory, deps.now?.() ?? Date.now());
+  if (pending) {
+    checks.push(rekeyPendingCheck(pending, hostedDelegateAddress, input.runtime, sidecar?.server_name));
+  }
+  if (sidecar) {
+    const consent = await getLocalSignerConsentStatus(join(directory, "signer.json"));
+    if (!consent.acknowledged) {
+      checks.push({
+        id: "signer_process",
+        label: "Signer stdio handshake",
+        level: "failed",
+        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 connector 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",
+        level: probe.status === "ok" ? "ok" : "failed",
+        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: repairCommandFor(input.runtime) }
+      });
     }
-    return resolution;
+  } else {
+    checks.push({
+      id: "signer_process",
+      label: "Signer stdio handshake",
+      level: "failed",
+      detail: "Skipped \u2014 no prepared signer runtime to probe.",
+      repair: repairCommandFor(input.runtime)
+    });
   }
-  throw new ConnectError(
-    "wiring_collision",
-    `This machine is already wired to a Haven agent with a live key (${supersededIds(collision)}), and setting up "${agentName}" on the bare haven / haven-signer pair would replace that wiring. Nothing was written and the Haven setup token is still unused. If you are an AI agent running this command: do NOT add a flag yourself \u2014 relay this to your user and stop. Your user decides: REPLACE the existing wiring (re-run the same command with --replace added, which re-points the pair at the new agent and retires the previous directory locally \u2014 they still revoke the old agent on the Haven agent page), or install ALONGSIDE it (re-run with --name <slug> added, e.g. --name ${collision.suggestedServerName}, which gives the new agent its own haven-<slug> / haven-signer-<slug> pair). Re-run only with the flag your user chooses.`,
-    "relay_wiring_collision_to_user",
-    { supersededAgentIds: collision.superseded.map((e) => e.agentId), suggestedServerName: collision.suggestedServerName }
-  );
+  return { checks, ...signerCapabilities ? { signerCapabilities } : {} };
 }
-function failedConnectOutcome(runtimeHint, error) {
-  const message = error instanceof Error ? error.message : "";
-  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 = 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",
-    runtime,
-    topology: "unknown",
-    configuration: { hosted_mcp: false, local_signer: false, local_mcp: false },
-    probe: { result: "not_run" },
-    activation: { restart_required: false, instruction: "Resolve the reported problem before activating Haven tools." },
-    next_action: nextAction2,
-    approval: { required: false, expires_at: null },
-    verification: {
-      tools: ["haven_get_agent", "haven_get_allowances"],
-      instruction: "After a successful setup and activation, verify only with haven_get_agent and haven_get_allowances."
-    },
-    error: {
-      code,
-      next_action: nextAction2,
-      // Only a ConnectError's message enters the JSON record: the vocabulary's
-      // prose is connector-authored and safe to serialize, while a plain
-      // Error can carry arbitrary server or filesystem detail (that stance is
-      // pinned by test). Redaction stays on as belt-and-braces; plain-Error
-      // runs still get their redacted message on stderr via the CLI mirror.
-      ...error instanceof ConnectError && message ? { message: redactForAutomation(message) } : {},
-      ...error instanceof ConnectError && error.details.allowedRuntimes ? { allowed_runtimes: error.details.allowedRuntimes } : {},
-      ...error instanceof ConnectError && error.details.installedClients?.length ? { installed_clients: error.details.installedClients } : {},
-      ...error instanceof ConnectError && error.details.suggestedRuntime ? { suggested_runtime: error.details.suggestedRuntime } : {},
-      ...error instanceof ConnectError && error.details.supersededAgentIds ? { superseded_agent_ids: error.details.supersededAgentIds } : {},
-      ...error instanceof ConnectError && error.details.suggestedServerName ? { suggested_name: error.details.suggestedServerName } : {}
+async function runDoctor(input, deps = {}) {
+  const homeDir = deps.homeDir ?? homedir();
+  const checks = [];
+  let signerCapabilities;
+  const { directory, others, parkedOnly } = await discoverCredentialDirectory(homeDir, input.credentialsDir);
+  const resolution = await resolveDoctorRuntime(input, directory);
+  const runtime = resolution.runtime;
+  const input2 = { ...input, runtime };
+  const normalizedRuntime = normalizeRuntimeName(input2.runtime);
+  const configPath = runtimeConfigPathFor(normalizedRuntime ?? input2.runtime, homeDir);
+  let configText = null;
+  if (configPath !== null) {
+    try {
+      configText = await readFile(configPath, "utf8");
+    } catch {
+      configText = null;
     }
-  };
-}
-function printSetupSummary(setup, log) {
-  log(`Fetched Haven setup for ${setup.agent.name}.`);
-  log(`Haven wallet: ${setup.haven_wallet.name} on ${setup.haven_wallet.network}.`);
-  if (setup.agent_budget.length > 0) {
-    for (const budget of setup.agent_budget) {
-      log(
-        `Agent budget: ${budget.allowance_amount} atomic ${budget.token_symbol} / ${budget.reset_period_min} minute reset.`
-      );
+  }
+  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, input2.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 }, input2, deps);
+      entry.checks = result.checks;
+      capabilitiesByDirectory.set(dir, result.signerCapabilities);
+    } else if (rekeyPending) {
+      entry.checks = [rekeyPendingCheck(rekeyPending, void 0, input2.runtime, slug)];
     }
+    inventory.push(entry);
   }
-  log(`Setup challenge expires at ${setup.challenge.expires_at}. If it expires, return to Haven for a fresh setup and rerun Connect \u2014 do not reuse or paste credentials.`);
-}
-function approveBudgetCta(setup, approvalUrl) {
-  const where = approvalUrl ? `at ${approvalUrl}` : "in the Haven dashboard";
-  const budgetPhrase = setup.agent_budget.length > 0 ? setup.agent_budget.map((budget) => `up to ${describeSetupBudget(budget)}`).join(", ") : void 0;
-  if (budgetPhrase) {
-    return `\u2192 Action needed: approve this agent's budget \u2014 ${budgetPhrase} from ${setup.haven_wallet.name} on ${setup.haven_wallet.network} \u2014 ${where}. The approval button is live now; setup continues here in the meantime.`;
+  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);
   }
-  return `\u2192 Action needed: approve this agent's budget ${where} \u2014 the approval button is live now. Setup continues here in the meantime.`;
-}
-function describeSetupBudget(budget) {
-  return describeApprovedBudget({
-    token_symbol: budget.token_symbol,
-    token_address: budget.token_address,
-    amount: budget.allowance_amount,
-    reset_period_min: budget.reset_period_min
-  });
-}
-function assertSetupChallengeIsUsable(expiresAt) {
-  const expiresAtMs = Date.parse(expiresAt);
-  if (!Number.isNaN(expiresAtMs) && expiresAtMs > Date.now()) return;
-  throw new Error(
-    "This Haven setup challenge is expired or invalid. Return to Haven, start a fresh connection, and rerun Connect. No local credentials were written."
-  );
-}
-function deadSetupTokenError(err) {
-  if (!(err instanceof ConnectRequestError) || err.status !== 410 && err.status !== 401) return null;
-  return new ConnectError(
-    "setup_challenge_expired_or_invalid",
-    "This Haven setup token is expired or invalid \u2014 tokens are single-use and expire 30 minutes after the dashboard issues them, and a mistyped token reads the same way. Return to Haven, start a fresh connection, and run its new connector command. No local credentials were written.",
-    "return_to_haven_for_fresh_setup"
-  );
-}
-function isExpiredSetupChallenge(err) {
-  return err instanceof Error && /(?:setup )?challenge.*expir|expir.*(?:setup )?challenge/i.test(err.message);
-}
-function secureLogger(log, redactPaths = false) {
-  return (message) => {
-    log(redactPaths ? redactForAutomation(message) : redactSecrets(message));
-  };
-}
-function printRuntimeInstall(result, log) {
-  for (const message of result.messages) log(message);
-  if (result.localMcpConfigured) {
-    log("Configured local Haven MCP tools.");
-  } else if (result.hostedMcpConfigured) {
-    log("Configured hosted Haven MCP identity.");
+  if (!primaryDirectory) {
+    checks.push({
+      id: "credentials",
+      label: "Agent credentials",
+      level: "failed",
+      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 {
-    log("Haven MCP tools still need runtime setup.");
+    const primaryIdentity = await readIdentity(primaryDirectory);
+    const primarySidecar = await readRuntimeSidecar(primaryDirectory);
+    if (!primaryChecksById.has("credentials")) {
+      const result = await checksForAgent(
+        { directory: primaryDirectory, identity: primaryIdentity, sidecar: primarySidecar },
+        input2,
+        deps
+      );
+      signerCapabilities = result.signerCapabilities;
+      for (const check of result.checks) primaryChecksById.set(check.id, check);
+    }
+    for (const id of ["credentials", "signer_runtime", "runtime_spec_override"]) {
+      const check = primaryChecksById.get(id);
+      if (check) checks.push(check);
+    }
   }
-  if (result.localSignerConfigured) {
-    log("Configured local Haven signer.");
+  const runtimeOwnsNoConfig = normalizedRuntime !== null && configPath === null;
+  if (configPath === null && input2.runtime !== "" && normalizedRuntime === null) {
+    checks.push({
+      id: "runtime_config",
+      label: "Runtime MCP config",
+      level: "failed",
+      detail: `Runtime '${input2.runtime}' is not one the connector recognises. The runtime config was NOT checked. Re-run the doctor naming the runtime \u2014 one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`,
+      repair: `Re-run the doctor naming the runtime \u2014 one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`
+    });
+  } else if (configPath === null && input2.runtime === "") {
+    checks.push({
+      id: "runtime_config",
+      label: "Runtime MCP config",
+      level: "failed",
+      detail: `Runtime is unknown \u2014 no runtime flag was given and the connector's record in ${primaryDirectory ?? input.credentialsDir ?? "~/.haven/agents"} carries no resolvable ${CONNECT_OUTCOME_FILENAME} runtime. The runtime config was NOT checked. Re-run the doctor naming the runtime \u2014 one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`,
+      repair: `Re-run the doctor naming the runtime \u2014 one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`
+    });
+  } else if (configPath === null) {
+    checks.push({
+      id: "runtime_config",
+      label: "Runtime MCP config",
+      level: "ok",
+      detail: `Runtime '${input2.runtime}' is configured through its own CLI or by hand (${input2.runtime === "other" ? "manual runtime" : "CLI-managed"}) and has no file-based config the connector owns \u2014 skipping the file check.`
+    });
+  } else if (configText === null) {
+    checks.push({
+      id: "runtime_config",
+      label: "Runtime MCP config",
+      level: "failed",
+      detail: `No runtime config at ${configPath}.`,
+      repair: repairCommandFor(input2.runtime)
+    });
   } else {
-    log("Local Haven signer still needs runtime setup.");
+    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",
+      level: ok ? "ok" : "failed",
+      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: repairCommandFor(input2.runtime) }
+    });
   }
-}
-function formatAtomicAmount(atomic, decimals) {
-  const s = atomic.toString().padStart(decimals + 1, "0");
-  const intPart = s.slice(0, s.length - decimals) || "0";
-  const fracPart = s.slice(s.length - decimals).replace(/0+$/, "");
-  return fracPart ? `${intPart}.${fracPart}` : intPart;
-}
-function describeResetPeriod(resetPeriodMin) {
-  if (resetPeriodMin === 1440) return "per day";
-  if (resetPeriodMin === 10080) return "per week";
-  if (resetPeriodMin === 43200) return "per month";
-  if (resetPeriodMin === 60) return "per hour";
-  if (resetPeriodMin === 0) return "in total";
-  return `every ${resetPeriodMin} minutes`;
-}
-function describeApprovedBudget(budget) {
-  const token = resolveTokenFromAddress(budget.token_address);
-  const amount = token ? `${formatAtomicAmount(BigInt(budget.amount), token.decimals)} ${budget.token_symbol}` : `${budget.amount} ${budget.token_symbol} (atomic units)`;
-  return `${amount} ${describeResetPeriod(budget.reset_period_min)}`;
-}
-function describeWaitBound(timeoutMs) {
-  if (timeoutMs >= 12e4) {
-    const minutes = Math.round(timeoutMs / 6e4);
-    return `${minutes} minutes`;
+  for (const id of ["hosted_mcp", "identity_match", "rekey_pending"]) {
+    const check = primaryChecksById.get(id);
+    if (check) checks.push(check);
   }
-  return `${Math.round(timeoutMs / 1e3)}s`;
-}
-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((resolve11) => setTimeout(resolve11, ms)));
-  const maxPolls = Math.max(1, Math.floor(timeoutMs / intervalMs));
-  const remindEvery = Math.max(1, Math.floor(3e4 / intervalMs));
-  let waitingAnnounced = false;
-  const announceWaiting = () => {
-    if (waitingAnnounced) return;
-    waitingAnnounced = true;
-    log("Now waiting for you to approve the budget in the Haven dashboard \u2014 approval is what unlocks the agent's Haven tools\u2026");
-  };
-  for (let i = 0; i < maxPolls; i++) {
-    if (i > 0) await sleep(intervalMs);
-    let status;
-    try {
-      status = await api.getConnectorStatus(setupId, apiKey);
-    } catch (err) {
-      if (err instanceof ConnectRequestError && (err.status === 401 || err.status === 404)) {
-        log("This setup ended in Haven \u2014 start a fresh connection from the dashboard when ready.");
-        return "ended";
+  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);
+      if (!identity?.api_key || !identity.api_url) {
+        if (tombstone) retired.push(`${otherAgent} (retired ${tombstone.retired_at})`);
+        else unverifiable.push(`${otherAgent} (no stored key/API URL to probe)`);
+        continue;
       }
-      announceWaiting();
-      continue;
-    }
-    if (status.status === "active") {
-      log(
-        status.approved_budget ? `Budget approved \u{1F389} \u2014 I can now spend up to ${describeApprovedBudget(status.approved_budget)} from your Haven wallet.` : "Budget approved \u{1F389} \u2014 the agent can now spend within its Haven rules."
+      const suffix = tombstone ? " [tombstoned \u2014 key material still present]" : "";
+      const probe = await (deps.probeHostedIdentity ?? probeHostedAgentIdentity)(
+        identity.api_key,
+        identity.api_url,
+        deps.fetch
       );
-      return "approved";
-    }
-    if (status.status === "cancelled" || status.status === "expired" || status.status === "failed") {
-      log(`This setup ended in Haven (${status.status}) \u2014 start a fresh connection from the dashboard when ready.`);
-      return "ended";
+      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}`);
     }
-    announceWaiting();
-    if (i > 0 && i % remindEvery === 0) {
-      const elapsedSeconds = Math.round(i * intervalMs / 1e3);
-      log(
-        `Still waiting for budget approval in Haven \u2014 ${elapsedSeconds}s elapsed, checking every ${Math.round(intervalMs / 1e3)}s. I'll stop waiting after ${describeWaitBound(timeoutMs)}; you can approve later and the tools unlock then.`
+    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 knownIds = new Set([...inventory].map((e) => e.agentId ?? basename(e.directory)));
+    const ledgerDir = input.credentialsDir ? tombstonesDirForAgentDirectory(input.credentialsDir, homeDir) : join(homeDir, ".haven", "tombstones");
+    const ghostRecords = (await readTombstoneRecords(ledgerDir)).filter(
+      (rec) => !knownIds.has(rec.agent_id)
+    );
+    if (ghostRecords.length > 0) {
+      parts.push(
+        `retired records (dir removed): ${ghostRecords.map((rec) => `${rec.agent_id} (${rec.reason})`).join(", ")}`
       );
     }
+    const supersededLive = live.filter((item) => item.entry.classification !== "wired").map((item) => item.label);
+    const classificationUnreliable = configText === null && runtimeOwnsNoConfig;
+    const supersededLevel = supersededLive.length === 0 ? "ok" : classificationUnreliable ? "advisory" : "failed";
+    checks.push({
+      id: "superseded_agents",
+      label: "Superseded agent credentials",
+      level: supersededLevel,
+      detail: supersededLevel === "failed" ? `${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.` : supersededLevel === "advisory" ? `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}. Runtime '${input2.runtime}' has no config file the connector can read, so which of these agents are wired cannot be verified from this machine: a live key here may be an agent you use deliberately, or one a host started before your latest setup is still spending as.` : `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}.`,
+      ...supersededLevel === "failed" ? {
+        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.`
+      } : supersededLevel === "advisory" ? {
+        repair: `Check ${supersededLive.join(", ")} on the Haven agent page: revoke the ones you no longer use, then remove their director(y/ies) under ~/.haven/agents. Connect never revokes or deletes for you.`
+      } : {}
+    });
   }
-  log(
-    "Budget approval is still pending in Haven. Approve it in the dashboard whenever you are ready \u2014 the agent tools unlock the moment you do. Verify later with the read-only haven_get_agent tool."
-  );
-  return "pending";
-}
-function completionHandoffLines(result, approval, approvalUrl) {
-  const approveStep = approvalUrl ? `Approve the budget at ${approvalUrl}. Approval \u2014 not restarting \u2014 unlocks Haven tools.` : "Return to Haven and approve the budget. Approval \u2014 not restarting \u2014 unlocks Haven tools.";
-  if (result.errorCode === "manual_runtime_setup_required") {
-    return [
-      "Next steps:",
-      `1. ${approveStep}`,
-      "2. Finish the manual MCP setup using the secret-free file references printed above, then start a fresh session in your runtime.",
-      `3. ${runtimeVerificationInstruction(result.runtime)}`
-    ];
+  const bindings = (await Promise.all(
+    inventory.filter((entry) => entry.classification !== "retired").map(async (entry) => ({ entry, binding: await readMcpServerBinding(entry.directory) }))
+  )).filter((item) => item.binding !== null);
+  const byName = /* @__PURE__ */ new Map();
+  for (const item of bindings) {
+    const list = byName.get(item.binding.server_name) ?? [];
+    list.push(item);
+    byName.set(item.binding.server_name, list);
   }
-  if (result.errorCode) {
-    return [
-      "Recovery: runtime setup is not complete. Resolve the reported problem, then return to Haven for a fresh connection and run its new connector command. Do not manually edit runtime config or paste credentials into prompts, logs, or config."
-    ];
+  const rebound = [...byName.entries()].filter(([, items]) => items.length > 1);
+  if (rebound.length > 0) {
+    const parts = rebound.map(([name, items]) => {
+      const ordered = [...items].sort((a, b) => a.binding.bound_at < b.binding.bound_at ? -1 : a.binding.bound_at > b.binding.bound_at ? 1 : 0);
+      const backends = new Set(ordered.map((i) => withoutUserinfo(i.binding.api_url)));
+      return `'${name}': ` + ordered.map((i) => `${i.binding.agent_id} on ${withoutUserinfo(i.binding.api_url)} at ${i.binding.bound_at} [${i.entry.classification}]`).join(" \u2192 ") + (backends.size > 1 ? " (BACKEND CHANGED)" : "");
+    });
+    checks.push({
+      id: "mcp_server_name_rebound",
+      label: "MCP server names bound more than once",
+      level: "advisory",
+      detail: `${rebound.length} MCP server name${rebound.length === 1 ? "" : "s"} changed hands on this machine (locally recorded bindings; the backend's own record is the authority for the same backend): ${parts.join("; ")}. A saved session, script or document naming the server may still mean the earlier agent.`,
+      repair: `Retire the earlier director(y/ies) with ${RERUN} --unwire <dir> to release the name, or keep both and address them by --name.`
+    });
   }
-  if (approval === "ended") {
-    return [
-      "Next step: this setup ended in Haven before the budget was approved, so there is nothing left to approve on it \u2014 start a fresh connection from the dashboard when ready."
-    ];
+  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",
+      level: abandoned.length === 0 ? "ok" : "failed",
+      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 profile = runtimeProfile(result.runtime);
-  const activation = activationInstructionWithWhy(profile);
-  if (approval === "approved") {
-    return [
-      "Next steps \u2014 the budget is already approved, so there is nothing more to do in Haven:",
-      `1. ${activation}`,
-      `2. ${runtimeVerificationInstruction(result.runtime)}`
-    ];
+  const signerProcess = primaryChecksById.get("signer_process");
+  if (signerProcess) checks.push(signerProcess);
+  const prune = await (deps.pruneSignerRuntimes ?? pruneSignerRuntimes)({ dryRun: true, measure: false }, { homeDir, credentialsDir: input.credentialsDir });
+  const unused = prune.entries.filter((entry) => entry.action === "would_remove");
+  if (unused.length > 0) {
+    checks.push({
+      id: "signer_runtime_unused",
+      label: "Unused signer-runtime directories",
+      level: "advisory",
+      detail: `${unused.length} signer-runtime director${unused.length === 1 ? "y" : "ies"} under ${prune.root} that no credential directory names: ${unused.map((entry) => entry.key).join(", ")}. Nothing is broken; they are left over from earlier pins or overrides (sizes: --prune-signer-runtimes --dry-run).`,
+      repair: `Run: ${RERUN} --prune-signer-runtimes (add --dry-run to list only).`
+    });
   }
-  return [
-    "Next steps:",
-    `1. ${approveStep}`,
-    `2. ${activation}`,
-    `3. ${runtimeVerificationInstruction(result.runtime)}`
-  ];
+  if (resolution.origin === "record") {
+    const rc = checks.find((check) => check.id === "runtime_config");
+    if (rc) {
+      rc.detail += ` (Resolved '${resolution.runtime}' from ${join(directory ?? "", CONNECT_OUTCOME_FILENAME)}; pass --runtime to check a different one.)`;
+    }
+  }
+  const restart = normalizedRuntime === null ? false : restartRequiredForRuntime(input2.runtime, deps.env);
+  checks.push({
+    id: "restart",
+    label: "Runtime restart",
+    level: "ok",
+    detail: restart ? "This runtime loads MCP config at startup \u2014 restart it after any repair before expecting the tools to appear." : input2.runtime === "" ? "Runtime is unknown \u2014 whether a restart is needed cannot be determined. Re-run the doctor naming the runtime for a definitive answer." : "No restart requirement known for this runtime."
+  });
+  const wiredChecks = inventory.filter((entry) => entry.classification === "wired").flatMap((entry) => entry.checks);
+  const finalChecks = checks.map(finalizeCheck);
+  const level = rollUpLevel([...finalChecks, ...wiredChecks]);
+  return {
+    version: 1,
+    ok: level !== "failed",
+    level,
+    runtime: input2.runtime,
+    credentialDirectory: primaryDirectory,
+    checks: finalChecks,
+    agents: inventory,
+    ...signerCapabilities ? { signerCapabilities } : {}
+  };
 }
-function activationInstructionWithWhy(profile) {
-  if (profile.restartMode === "restart-session") {
-    return `${profile.activationInstruction} (The entries are already written and verified \u2014 ${profile.label} only reads MCP config when a session starts, which is why this step is still needed.)`;
+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 (profile.restartMode === "restart-app") {
-    return `${profile.activationInstruction} (The entries are already written and verified \u2014 ${profile.label} only reads MCP config at app launch, which is why this step is still needed.)`;
+  if (!directory) {
+    return {
+      ok: false,
+      messages: [`No agent credentials found to repair \u2014 run the full setup: ${RERUN} --setup <token>.`]
+    };
   }
-  return profile.activationInstruction;
-}
-var RERUN_HINT = connectorRerunCommand();
-async function listExistingKeyedAgents(baseDir) {
-  const root = defaultCredentialRoot(baseDir);
-  let entries = [];
-  try {
-    entries = await readdir(root);
-  } catch {
-    return [];
+  const resolution = await resolveDoctorRuntime(input, directory);
+  if (resolution.origin === "record") {
+    messages.push(`Runtime not given \u2014 resolved '${resolution.runtime}' from ${join(directory, CONNECT_OUTCOME_FILENAME)}.`);
   }
-  const out = [];
-  for (const entry of entries) {
-    const directory = join(root, entry);
-    try {
-      const identity = JSON.parse(await readFile(join(directory, "identity.json"), "utf8"));
-      if (typeof identity.api_key !== "string" || identity.api_key.length === 0) continue;
-      let agent = {};
-      try {
-        agent = JSON.parse(await readFile(join(directory, "agent.json"), "utf8"));
-      } catch {
-      }
-      const { accountAddress } = readStoredAccountAddress(identity, agent);
-      out.push({ agentId: typeof identity.agent_id === "string" ? identity.agent_id : entry, directory, accountAddress: accountAddress ?? null });
-    } catch {
-    }
+  const runtime = resolution.runtime;
+  const input2 = { ...input, runtime };
+  if (runtime === "") {
+    return {
+      ok: false,
+      messages: [
+        "Runtime is unknown \u2014 no runtime flag was given and the connector record carries no resolvable runtime.",
+        `Repair rewrites the runtime config, so it will not guess. Re-run repair naming the runtime \u2014 one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`
+      ]
+    };
   }
-  return out;
-}
-async function listOtherAgentIds(baseDir, currentDirectory) {
-  const root = defaultCredentialRoot(baseDir);
-  let entries = [];
+  let identity;
   try {
-    entries = await readdir(root);
+    identity = JSON.parse(await readFile(join(directory, "identity.json"), "utf8"));
   } catch {
-    return null;
+    return { ok: false, messages: ["identity.json is unreadable \u2014 re-run the full setup with a fresh token."] };
   }
-  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;
-    }
+  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(normalizeRuntimeName(input2.runtime) ?? input2.runtime, homeDir);
+  if (configPath) {
     try {
-      const identity = JSON.parse(await readFile(identityPath, "utf8"));
-      ids.push(identity.agent_id ?? entry);
+      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 connector command (with --local) to repair a local-stdio install."
+          ]
+        };
+      }
     } catch {
-      ids.push(entry);
     }
   }
-  return ids;
-}
-function printNextSteps(result, log, approval, approvalUrl) {
-  for (const line of completionHandoffLines(result, approval, approvalUrl)) log(line);
+  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, env: deps.env }
+  );
+  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({
+    // Normalized for the WRITE too (#3145 review round 3): `writeRuntimeConfig`
+    // switches on the id, and the raw alias fell to its "manual runtime" arm
+    // — a repair that reported success while writing nothing.
+    runtime: normalizeRuntimeName(input2.runtime) ?? input2.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 };
 }
+var RERUN;
+var init_doctor = __esm({
+  "src/doctor.ts"() {
+    init_prune_runtimes();
+    init_runtime_manifest();
+    init_probes();
+    init_signer_runtime();
+    init_runtime_spec_override();
+    init_config_writers();
+    init_runtime_registry();
+    init_signer_consent();
+    init_tombstone();
+    init_server_names();
+    init_storage();
+    init_redact();
+    RERUN = connectorRerunCommand();
+  }
+});
 
 // src/args.ts
+init_runtime();
 init_server_names();
 init_rekey_messages();
 function parseArgs(argv, env = process.env) {
@@ -5910,6 +5923,7 @@ function requireValue(argv, index, option) {
 }
 
 // src/cli.ts
+init_runtime();
 init_redact();
 init_connect_error();
 function failSubcommand(io, json, err, envelope, fallback) {