@haven_ai/connect 0.1.29-alpha.0 → 0.1.31-alpha.0

package/dist/cli.js

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
-import { ensureConsent, computeConsentHash, loadCredentials, consentInputFromClient, registeredToolNames, MCP_VERSION } from '@haven_ai/mcp';
-import { ensureSignerConsent, computeSignerConsentHash, loadSignerCredentials, createEdgeSigner, toolSchemas } from '@haven_ai/signer';
-import { isSupportedNodeVersion, unsupportedNodeVersionMessage, SKILL_FOLDER_NAME, resolveTokenFromAddress, HAVEN_SKILL_MD, HAVEN_SKILL_BODY_MD, HAVEN_MINIMUM_NODE_VERSION } from '@haven_ai/sdk';
-import { mkdir, rm, stat, readdir, readFile, chmod, access, writeFile, unlink } from 'fs/promises';
+import crypto from 'crypto';
+import { Wallet } from 'ethers';
+import { mkdir, rm, stat, readdir, readFile, chmod, access, writeFile, unlink, rename } from 'fs/promises';
 import { homedir, platform } from 'os';
 import { join, resolve, dirname, basename } from 'path';
+import { ensureConsent, computeConsentHash, loadCredentials, consentInputFromClient, registeredToolNames, MCP_VERSION } from '@haven_ai/mcp';
+import { ensureSignerConsent, computeSignerConsentHash, loadSignerCredentials, createEdgeSigner, toolSchemas } from '@haven_ai/signer';
+import { isSupportedNodeVersion, SKILL_FOLDER_NAME, resolveTokenFromAddress, HAVEN_SKILL_MD, HAVEN_SKILL_BODY_MD, HAVEN_MINIMUM_NODE_VERSION, unsupportedNodeVersionMessage } from '@haven_ai/sdk';
 import { parseDocument, isMap, stringify } from 'yaml';
 import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
 import { realpathSync } from 'fs';
 import { fileURLToPath, pathToFileURL } from 'url';
-import crypto from 'crypto';
-import { Wallet } from 'ethers';
 import { createInterface } from 'readline';
 
 var __defProp = Object.defineProperty;
@@ -24,10 +24,132 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/api.ts
+function createConnectApiClient(baseUrl, fetchImpl = fetch) {
+  const root = baseUrl.replace(/\/+$/, "");
+  return {
+    resolveSetup: (input) => request(fetchImpl, `${root}/agent-connection-setups/resolve`, {
+      method: "POST",
+      body: JSON.stringify({
+        setup_token: input.setupToken,
+        connector_version: input.connectorVersion,
+        runtime: input.runtime
+      })
+    }),
+    registerSetup: (input) => request(fetchImpl, `${root}/agent-connection-setups/register`, {
+      method: "POST",
+      body: JSON.stringify({
+        setup_token: input.setupToken,
+        challenge_id: input.challengeId,
+        delegate_address: input.delegateAddress,
+        proof_signature: input.proofSignature,
+        api_key_hash: input.apiKeyHash,
+        api_key_prefix: input.apiKeyPrefix,
+        runtime: input.runtime,
+        connector_version: input.connectorVersion,
+        mcp_server_name: input.mcpServerName,
+        connector_context: input.connectorContext,
+        install_capabilities: input.installCapabilities && {
+          can_write_runtime_config: input.installCapabilities.canWriteRuntimeConfig,
+          restart_required: input.installCapabilities.restartRequired
+        }
+      })
+    }),
+    getAgentIdentity: (apiKey) => request(fetchImpl, `${root}/machine-payments/agent`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${apiKey}` }
+    }),
+    getConnectorStatus: (setupId, apiKey) => request(fetchImpl, `${root}/agent-connection-setups/${encodeURIComponent(setupId)}/connector-status`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${apiKey}` }
+    }),
+    updateInstallStatus: async (setupId, apiKey, input) => {
+      await request(fetchImpl, `${root}/agent-connection-setups/${encodeURIComponent(setupId)}/install-status`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}` },
+        body: JSON.stringify({
+          runtime: input.runtime,
+          connector_version: input.connectorVersion,
+          runtime_mcp_mode: input.runtimeMcpMode,
+          hosted_mcp_configured: input.hostedMcpConfigured,
+          local_signer_configured: input.localSignerConfigured,
+          local_mcp_configured: input.localMcpConfigured,
+          credential_files_written: input.credentialFilesWritten,
+          signer_acknowledged: input.signerAcknowledged,
+          local_mcp_acknowledged: input.localMcpAcknowledged,
+          activation_command_available: input.activationCommandAvailable,
+          skill_installed: input.skillInstalled,
+          probe_result: input.probeResult,
+          restart_required: input.restartRequired,
+          next_user_action: input.nextUserAction,
+          error_code: input.errorCode ?? null,
+          environment_label: input.environmentLabel
+        })
+      });
+    }
+  };
+}
+async function request(fetchImpl, url, init) {
+  const response = await fetchImpl(url, {
+    ...init,
+    headers: {
+      "Content-Type": "application/json",
+      ...init.headers ?? {}
+    }
+  });
+  const text = await response.text();
+  const body = text ? JSON.parse(text) : null;
+  if (!response.ok) {
+    const message = body?.error ?? body?.message ?? `${response.status} ${response.statusText}`;
+    throw new ConnectRequestError(`Haven setup request failed: ${message}`, response.status);
+  }
+  return body;
+}
+var ConnectRequestError;
+var init_api = __esm({
+  "src/api.ts"() {
+    ConnectRequestError = class extends Error {
+      constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "ConnectRequestError";
+      }
+      status;
+    };
+  }
+});
+function generateDelegateKey() {
+  return delegateKeyFromPrivateKey(Wallet.createRandom().privateKey);
+}
+function delegateKeyFromPrivateKey(privateKey) {
+  const wallet = new Wallet(privateKey);
+  return {
+    privateKey: wallet.privateKey,
+    address: wallet.address,
+    signChallenge: (message) => wallet.signMessage(message)
+  };
+}
+function generateAgentApiKey() {
+  return `sk_agent_${crypto.randomBytes(24).toString("hex")}`;
+}
+function hashAgentApiKey(apiKey) {
+  return crypto.createHash("sha256").update(apiKey).digest("hex");
+}
+function agentApiKeyPrefix(apiKey) {
+  return apiKey.slice(0, 12);
+}
+var init_key = __esm({
+  "src/key.ts"() {
+  }
+});
+
 // src/redact.ts
 function redactSecrets(value) {
   return value.replace(API_KEY_RE, "sk_agent_[redacted]").replace(PRIVATE_KEY_RE, "0x[redacted-private-key]");
 }
+function redactForAutomation(value) {
+  return redactSecrets(value).replace(/(?:~|\/)[^\s`"']*\/(?:identity|signer|agent)\.json\b/g, "[credential-file-redacted]").replace(/(?:~|\/)[^\s`"']*\/\.env\b/g, "[credential-env-redacted]");
+}
 function shortAddress(address) {
   if (!/^0x[0-9a-fA-F]{40}$/.test(address)) return address;
   return `${address.slice(0, 6)}...${address.slice(-4)}`;
@@ -86,119 +208,415 @@ var init_server_names = __esm({
     SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
   }
 });
-function mcpPackageSpec() {
-  return `${MCP_RUNTIME_MANIFEST.mcpPackage}@${MCP_RUNTIME_MANIFEST.mcpVersion}`;
-}
-function sdkPackageSpec() {
-  return `${MCP_RUNTIME_MANIFEST.sdkPackage}@${MCP_RUNTIME_MANIFEST.sdkVersion}`;
-}
-function signerPackageSpec() {
-  return `${MCP_RUNTIME_MANIFEST.signerPackage}@${MCP_RUNTIME_MANIFEST.signerVersion}`;
+async function preflightCredentialStorage(input = {}) {
+  const directory = defaultCredentialRoot(input.baseDir);
+  await mkdir(directory, { recursive: true, mode: 448 });
+  await restrictPermissions(directory, 448, input.warn);
+  const probePath = join(directory, `.haven-connect-preflight-${crypto.randomBytes(8).toString("hex")}`);
+  try {
+    await writeOwnerOnlyJson(probePath, { ok: true }, input.warn);
+  } finally {
+    await rm(probePath, { force: true }).catch(() => void 0);
+  }
+  return directory;
 }
-var MCP_RUNTIME_MANIFEST;
-var init_runtime_manifest = __esm({
-  "src/runtime-manifest.ts"() {
-    MCP_RUNTIME_MANIFEST = {
-      mcpPackage: "@haven_ai/mcp",
-      mcpVersion: MCP_VERSION,
-      sdkPackage: "@haven_ai/sdk",
-      sdkVersion: "0.1.29-alpha.0",
-      signerPackage: "@haven_ai/signer",
-      signerVersion: "0.1.29-alpha.0",
-      // Sourced from the SDK, never a literal (#1161). This field read '20.0.0'
-      // while every package's `engines` said `>=24` and the docs said `>=24.0.0`,
-      // so the guard that was supposed to enforce the floor waved Node v23 through
-      // — including on the `--local` path where it does run. A hand-maintained
-      // second copy of a number is a drift waiting to happen; a guard test pins
-      // this against `package.json`'s `engines.node`.
-      minimumNodeVersion: HAVEN_MINIMUM_NODE_VERSION,
-      supportedClients: ["codex-cli", "codex-desktop", "claude-code"],
-      requiredTools: registeredToolNames(),
-      /**
-       * The signer MCP's tool surface, DERIVED from the pinned @haven_ai/signer
-       * package (#1587) — same anti-drift rule as `requiredTools` above: a
-       * literal list here would rot the first time the signer gains a tool.
-       * The handshake probe requires all of them.
-       */
-      requiredSignerTools: Object.keys(toolSchemas)
-    };
+async function writeCredentialFiles(input) {
+  const directory = defaultAgentDirectory(input.serverName ?? input.agentId, input.baseDir);
+  await mkdir(directory, { recursive: true, mode: 448 });
+  await restrictPermissions(directory, 448, input.warn);
+  const identityPath = join(directory, "identity.json");
+  const signerPath = join(directory, "signer.json");
+  const agentPath = join(directory, "agent.json");
+  await assertDoesNotExist(identityPath);
+  await assertDoesNotExist(signerPath);
+  await assertDoesNotExist(agentPath);
+  await writeOwnerOnlyJson(signerPath, signerPayload(input), input.warn);
+  try {
+    await writeOwnerOnlyJson(identityPath, identityPayload(input), input.warn);
+  } catch (err) {
+    await rm(signerPath, { force: true }).catch(() => void 0);
+    throw err;
   }
-});
-async function writeRuntimeConfig(input, deps = {}) {
-  switch (input.runtime) {
-    case "codex-cli":
-    case "codex-desktop":
-      return writeCodexConfig(input);
-    case "cursor":
-      return writeJsonRuntimeConfig(input, cursorConfigPath(input.homeDir), "mcpServers");
-    case "vscode":
-      return writeJsonRuntimeConfig(input, vscodeConfigPath(input.homeDir), "servers");
-    case "vscode-insiders":
-      return writeJsonRuntimeConfig(input, vscodeInsidersConfigPath(input.homeDir), "servers");
-    case "claude-desktop":
-      return writeJsonRuntimeConfig(input, claudeDesktopConfigPath(input.homeDir), "mcpServers");
-    case "hermes":
-      return writeHermesConfig(input, deps);
-    default:
-      return {
-        hostedConfigured: false,
-        signerConfigured: false,
-        localMcpConfigured: false,
-        runtimeMcpMode: "manual",
-        target: "manual runtime setup",
-        changed: false,
-        restartRequired: true,
-        messages: ["Runtime config needs to be added manually for this agent environment."],
-        errorCode: "manual_runtime_setup_required"
-      };
+  try {
+    await writeOwnerOnlyJson(agentPath, agentPayload(input), input.warn);
+  } catch (err) {
+    await rm(signerPath, { force: true }).catch(() => void 0);
+    await rm(identityPath, { force: true }).catch(() => void 0);
+    await rm(agentPath, { force: true }).catch(() => void 0);
+    throw err;
   }
+  return { directory, identityPath, signerPath, agentPath };
 }
-function buildHostedServer(hostedMcpUrl, apiKey, runtime) {
-  if (runtime === "vscode" || runtime === "vscode-insiders") {
-    return {
-      type: "http",
-      url: hostedMcpUrl,
-      headers: { Authorization: `Bearer ${apiKey}` }
-    };
-  }
+function signerPayload(input) {
   return {
-    url: hostedMcpUrl,
-    headers: { Authorization: `Bearer ${apiKey}` }
-  };
-}
-function resolveSignerLaunchSpec(input) {
-  return input.signerCommand ?? {
-    command: "npx",
-    args: ["-y", signerPackageSpec(), "--credentials", input.signerPath]
+    delegate_key: input.delegateKey,
+    delegate_address: input.delegateAddress,
+    agent_id: input.agentId,
+    safe_address: input.safeAddress,
+    chain_id: input.chainId,
+    network: input.network,
+    x402_binding_signer: input.x402BindingSigner,
+    note: "Local signer credential. Haven backend never receives this private key."
   };
 }
-function buildSignerServer(spec, runtime) {
-  const server = {
-    command: spec.command,
-    args: spec.args
+function identityPayload(input) {
+  return {
+    api_key: input.apiKey,
+    agent_id: input.agentId,
+    safe_address: input.safeAddress,
+    chain_id: input.chainId,
+    network: input.network,
+    api_url: input.apiUrl,
+    hosted_mcp_url: input.hostedMcpUrl,
+    agent_budget: input.agentBudget,
+    note: "Haven API key identifies the agent only. It cannot spend without the local signer key and on-chain Haven wallet rules."
   };
-  if (runtime === "vscode" || runtime === "vscode-insiders") return { type: "stdio", ...server };
-  return server;
 }
-function mergeJsonMcpConfig(existingJson, serverRoot, hostedServer, signerServer, names = serverNamesFor(), configPath) {
-  const config = existingJson?.trim() ? parseJsonObject(existingJson, configPath) : {};
-  const existingRoot = config[serverRoot];
-  const servers = existingRoot && typeof existingRoot === "object" && !Array.isArray(existingRoot) ? existingRoot : {};
-  config[serverRoot] = {
-    ...servers,
-    [names.hosted]: hostedServer,
-    [names.signer]: signerServer
+function agentPayload(input) {
+  return {
+    agent_id: input.agentId,
+    delegate_address: input.delegateAddress,
+    safe_address: input.safeAddress,
+    chain_id: input.chainId,
+    network: input.network,
+    agent_budget: input.agentBudget,
+    note: "Non-secret orientation for the agent: public delegate/Haven wallet identity + configured budget. Contains no API key or signing key. For the live remaining budget, call haven_get_allowances."
   };
-  return `${JSON.stringify(config, null, 2)}
-`;
 }
-function mergeHermesYaml(existingYaml, hostedServer, signerServer, names = serverNamesFor(), configPath) {
-  if (!existingYaml?.trim()) {
-    return renderHermesYaml({ [names.hosted]: hostedServer, [names.signer]: signerServer });
+async function readStoredCredentials(serverName, agentIdOrSlug, baseDir) {
+  const key = serverName ?? agentIdOrSlug;
+  const directory = key ? defaultAgentDirectory(key, baseDir) : await discoverSoleAgentDirectory(baseDir);
+  const identity = await readJsonFile(join(directory, "identity.json"));
+  if (!identity) {
+    throw new Error(
+      `No Haven credentials at ${directory}. Nothing to re-key \u2014 connect this agent first, or pass the --name you wired it under.`
+    );
   }
-  const doc = parseDocument(existingYaml, { keepSourceTokens: true });
-  if (doc.errors.length > 0 || !isMap(doc.contents)) {
-    throw new UnreadableRuntimeConfigError(configPath ?? "the Hermes config", "it is not a YAML object");
+  const agent = await readJsonFile(join(directory, "agent.json")) ?? {};
+  const signer = await readJsonFile(join(directory, "signer.json")) ?? {};
+  const agentId = asString(identity.agent_id);
+  const apiKey = asString(identity.api_key);
+  const apiUrl = asString(identity.api_url);
+  const hostedMcpUrl = asString(identity.hosted_mcp_url);
+  if (!agentId || !apiKey || !apiUrl || !hostedMcpUrl) {
+    throw new Error(
+      `The credential set at ${directory} is incomplete (identity.json is missing agent_id, api_key, api_url or hosted_mcp_url). Re-key cannot rebuild it \u2014 reconnect the agent instead.`
+    );
+  }
+  return {
+    directory,
+    agentId,
+    apiKey,
+    apiUrl,
+    hostedMcpUrl,
+    delegateAddress: asString(agent.delegate_address) ?? asString(signer.delegate_address),
+    safeAddress: asString(identity.safe_address) ?? asString(agent.safe_address),
+    chainId: typeof identity.chain_id === "number" ? identity.chain_id : void 0,
+    network: asString(identity.network),
+    x402BindingSigner: asString(signer.x402_binding_signer),
+    agentBudget: Array.isArray(identity.agent_budget) ? identity.agent_budget : void 0
+  };
+}
+async function discoverSoleAgentDirectory(baseDir) {
+  const root = defaultCredentialRoot(baseDir);
+  let entries = [];
+  try {
+    entries = await readdir(root);
+  } catch {
+    throw new Error(`No Haven credentials found under ${root}. Connect an agent on this machine first.`);
+  }
+  const candidates = [];
+  for (const entry of entries) {
+    const directory = join(root, entry);
+    if (!await readJsonFile(join(directory, "identity.json"))) continue;
+    if (await readJsonFile(join(directory, "TOMBSTONE.json"))) continue;
+    candidates.push(directory);
+  }
+  if (candidates.length === 1) return candidates[0];
+  if (candidates.length === 0) {
+    throw new Error(`No Haven credentials found under ${root}. Connect an agent on this machine first.`);
+  }
+  throw new Error(
+    `Several agents are wired on this machine, so --rekey cannot tell which one you mean:
+` + candidates.map((d) => `  ${d}`).join("\n") + "\nRe-run with --name <slug> to pick one."
+  );
+}
+async function rewriteCredentialFiles(input) {
+  const directory = defaultAgentDirectory(input.serverName ?? input.agentId, input.baseDir);
+  const identityPath = join(directory, "identity.json");
+  const signerPath = join(directory, "signer.json");
+  const agentPath = join(directory, "agent.json");
+  const targets = [
+    { path: signerPath, payload: signerPayload(input) },
+    { path: identityPath, payload: identityPayload(input) },
+    { path: agentPath, payload: agentPayload(input) }
+  ];
+  const originals = /* @__PURE__ */ new Map();
+  for (const { path } of targets) {
+    originals.set(path, await readRawFile(path));
+  }
+  const temps = [];
+  try {
+    for (const { path, payload } of targets) {
+      const temp = `${path}.rekey-${crypto.randomBytes(6).toString("hex")}.tmp`;
+      await writeOwnerOnlyJson(temp, payload, input.warn);
+      temps.push({ from: temp, to: path });
+    }
+    for (const { from, to } of temps) {
+      await rename(from, to);
+    }
+  } catch (err) {
+    for (const { from } of temps) await rm(from, { force: true }).catch(() => void 0);
+    for (const [path, contents] of originals) {
+      if (contents === null) {
+        await rm(path, { force: true }).catch(() => void 0);
+      } else {
+        await writeFile(path, contents, { mode: 384 }).catch(() => void 0);
+      }
+    }
+    throw err;
+  }
+  return { directory, identityPath, signerPath, agentPath };
+}
+async function writeRekeyPending(directory, pending, warn) {
+  const path = join(directory, REKEY_PENDING_FILENAME);
+  await rm(path, { force: true }).catch(() => void 0);
+  await writeOwnerOnlyJson(path, { ...pending }, warn);
+  return path;
+}
+async function readRekeyPending(directory, now = Date.now()) {
+  const path = join(directory, REKEY_PENDING_FILENAME);
+  const raw = await readJsonFile(path);
+  if (!raw) {
+    throw new Error(
+      `No re-key in progress at ${directory}. Run the connector with --rekey first \u2014 it prints the new signing address to paste into the Haven agent page.`
+    );
+  }
+  const pending = raw;
+  if (!pending.new_delegate_key || !pending.new_delegate_address || !pending.agent_id) {
+    throw new Error(`The pending re-key at ${path} is unreadable. Delete it and start again with --rekey.`);
+  }
+  if (pending.expires_at && Date.parse(pending.expires_at) < now) {
+    throw new Error(
+      `The re-key started at ${pending.started_at} has expired. Start again with --rekey \u2014 the address currently shown in your dashboard is no longer the one this machine holds.`
+    );
+  }
+  return pending;
+}
+async function inspectRekeyPending(directory, now = Date.now()) {
+  const path = join(directory, REKEY_PENDING_FILENAME);
+  const raw = await readJsonFile(path);
+  if (!raw) {
+    const present = await readRawFile(path) !== null;
+    return present ? { state: "unreadable", path } : null;
+  }
+  const agentId = asString(raw.agent_id);
+  const newDelegateAddress = asString(raw.new_delegate_address);
+  const startedAt = asString(raw.started_at);
+  const expiresAt = asString(raw.expires_at);
+  if (!agentId || !newDelegateAddress) {
+    return { state: "unreadable", path, ...startedAt ? { startedAt } : {} };
+  }
+  const expired = expiresAt !== void 0 && Date.parse(expiresAt) < now;
+  return {
+    state: expired ? "expired" : "pending",
+    path,
+    agentId,
+    newDelegateAddress,
+    ...startedAt ? { startedAt } : {},
+    ...expiresAt ? { expiresAt } : {}
+  };
+}
+async function clearRekeyPending(directory) {
+  await rm(join(directory, REKEY_PENDING_FILENAME), { force: true }).catch(() => void 0);
+}
+async function readJsonFile(path) {
+  const raw = await readRawFile(path);
+  if (raw === null) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function readRawFile(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+async function assertServerSlugAvailable(serverName, baseDir) {
+  const directory = defaultAgentDirectory(serverName, baseDir);
+  try {
+    await stat(join(directory, "identity.json"));
+  } catch {
+    return;
+  }
+  throw new Error(
+    `The name "${serverName}" is already wired on this machine (${directory} holds credentials). Pick a different --name, or revoke and remove that agent first \u2014 connect never overwrites credentials.`
+  );
+}
+function defaultAgentDirectory(agentId, baseDir = join(homedir(), ".haven", "agents")) {
+  return resolve(defaultCredentialRoot(baseDir), safePathPart(agentId));
+}
+function defaultCredentialRoot(baseDir = join(homedir(), ".haven", "agents")) {
+  return resolve(baseDir);
+}
+async function writeOwnerOnlyJson(path, value, warn) {
+  const json = JSON.stringify(dropUndefined(value), null, 2);
+  await writeFile(path, `${json}
+`, { mode: 384, flag: "wx" });
+  await restrictPermissions(path, 384, warn);
+}
+function safePathPart(value) {
+  return value.replace(/[^A-Za-z0-9_.-]/g, "_");
+}
+function dropUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== void 0));
+}
+async function assertDoesNotExist(path) {
+  try {
+    await access(path);
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") return;
+    throw err;
+  }
+  throw new Error(`Refusing to overwrite existing Haven credential file: ${path}`);
+}
+async function restrictPermissions(path, mode, warn) {
+  try {
+    await chmod(path, mode);
+  } catch (err) {
+    warn?.(
+      `Warning: could not restrict permissions on ${path} to ${mode.toString(8)}. Move this credential to a private location or run chmod ${mode.toString(8)} ${path}. ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+var REKEY_PENDING_FILENAME, REKEY_PENDING_TTL_MS;
+var init_storage = __esm({
+  "src/storage.ts"() {
+    REKEY_PENDING_FILENAME = "rekey-pending.json";
+    REKEY_PENDING_TTL_MS = 24 * 60 * 60 * 1e3;
+  }
+});
+function mcpPackageSpec() {
+  return `${MCP_RUNTIME_MANIFEST.mcpPackage}@${MCP_RUNTIME_MANIFEST.mcpVersion}`;
+}
+function sdkPackageSpec() {
+  return `${MCP_RUNTIME_MANIFEST.sdkPackage}@${MCP_RUNTIME_MANIFEST.sdkVersion}`;
+}
+function signerPackageSpec() {
+  return `${MCP_RUNTIME_MANIFEST.signerPackage}@${MCP_RUNTIME_MANIFEST.signerVersion}`;
+}
+var MCP_RUNTIME_MANIFEST;
+var init_runtime_manifest = __esm({
+  "src/runtime-manifest.ts"() {
+    MCP_RUNTIME_MANIFEST = {
+      mcpPackage: "@haven_ai/mcp",
+      mcpVersion: MCP_VERSION,
+      sdkPackage: "@haven_ai/sdk",
+      sdkVersion: "0.1.31-alpha.0",
+      signerPackage: "@haven_ai/signer",
+      signerVersion: "0.1.31-alpha.0",
+      // Sourced from the SDK, never a literal (#1161). This field read '20.0.0'
+      // while every package's `engines` said `>=24` and the docs said `>=24.0.0`,
+      // so the guard that was supposed to enforce the floor waved Node v23 through
+      // — including on the `--local` path where it does run. A hand-maintained
+      // second copy of a number is a drift waiting to happen; a guard test pins
+      // this against `package.json`'s `engines.node`.
+      minimumNodeVersion: HAVEN_MINIMUM_NODE_VERSION,
+      supportedClients: ["codex-cli", "codex-desktop", "claude-code"],
+      requiredTools: registeredToolNames(),
+      /**
+       * The signer MCP's tool surface, DERIVED from the pinned @haven_ai/signer
+       * package (#1587) — same anti-drift rule as `requiredTools` above: a
+       * literal list here would rot the first time the signer gains a tool.
+       * The handshake probe requires all of them.
+       */
+      requiredSignerTools: Object.keys(toolSchemas)
+    };
+  }
+});
+async function writeRuntimeConfig(input, deps = {}) {
+  switch (input.runtime) {
+    case "codex-cli":
+    case "codex-desktop":
+      return writeCodexConfig(input);
+    case "cursor":
+      return writeJsonRuntimeConfig(input, cursorConfigPath(input.homeDir), "mcpServers");
+    case "vscode":
+      return writeJsonRuntimeConfig(input, vscodeConfigPath(input.homeDir), "servers");
+    case "vscode-insiders":
+      return writeJsonRuntimeConfig(input, vscodeInsidersConfigPath(input.homeDir), "servers");
+    case "claude-desktop":
+      return writeJsonRuntimeConfig(input, claudeDesktopConfigPath(input.homeDir), "mcpServers");
+    case "hermes":
+      return writeHermesConfig(input, deps);
+    default:
+      return {
+        hostedConfigured: false,
+        signerConfigured: false,
+        localMcpConfigured: false,
+        runtimeMcpMode: "manual",
+        target: "manual runtime setup",
+        changed: false,
+        restartRequired: true,
+        messages: ["Runtime config needs to be added manually for this agent environment."],
+        errorCode: "manual_runtime_setup_required"
+      };
+  }
+}
+function buildHostedServer(hostedMcpUrl, apiKey, runtime) {
+  if (runtime === "vscode" || runtime === "vscode-insiders") {
+    return {
+      type: "http",
+      url: hostedMcpUrl,
+      headers: { Authorization: `Bearer ${apiKey}` }
+    };
+  }
+  return {
+    url: hostedMcpUrl,
+    headers: { Authorization: `Bearer ${apiKey}` }
+  };
+}
+function resolveSignerLaunchSpec(input) {
+  return input.signerCommand ?? {
+    command: "npx",
+    args: ["-y", signerPackageSpec(), "--credentials", input.signerPath]
+  };
+}
+function buildSignerServer(spec, runtime) {
+  const server = {
+    command: spec.command,
+    args: spec.args
+  };
+  if (runtime === "vscode" || runtime === "vscode-insiders") return { type: "stdio", ...server };
+  return server;
+}
+function mergeJsonMcpConfig(existingJson, serverRoot, hostedServer, signerServer, names = serverNamesFor(), configPath) {
+  const config = existingJson?.trim() ? parseJsonObject(existingJson, configPath) : {};
+  const existingRoot = config[serverRoot];
+  const servers = existingRoot && typeof existingRoot === "object" && !Array.isArray(existingRoot) ? existingRoot : {};
+  config[serverRoot] = {
+    ...servers,
+    [names.hosted]: hostedServer,
+    [names.signer]: signerServer
+  };
+  return `${JSON.stringify(config, null, 2)}
+`;
+}
+function mergeHermesYaml(existingYaml, hostedServer, signerServer, names = serverNamesFor(), configPath) {
+  if (!existingYaml?.trim()) {
+    return renderHermesYaml({ [names.hosted]: hostedServer, [names.signer]: signerServer });
+  }
+  const doc = parseDocument(existingYaml, { keepSourceTokens: true });
+  if (doc.errors.length > 0 || !isMap(doc.contents)) {
+    throw new UnreadableRuntimeConfigError(configPath ?? "the Hermes config", "it is not a YAML object");
   }
   const mcpPair = doc.contents.items.find((item) => item.key?.toString() === "mcp_servers");
   const existingServers = mcpPair && isMap(mcpPair.value) ? mcpPair.value.toJSON() : {};
@@ -845,27 +1263,107 @@ var init_config_writers = __esm({
     };
   }
 });
-async function probeHostedAgentIdentity(apiKey, apiUrl, fetchImpl = fetch) {
-  let response;
+async function acknowledgeLocalMcpConsent(identityPath, signerPath, log) {
   try {
-    response = await fetchWithTimeout(fetchImpl, `${apiUrl.replace(/\/+$/, "")}/machine-payments/agent`, {
-      method: "GET",
-      headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" }
+    const input = await buildLocalMcpConsentInput(identityPath, signerPath);
+    const decision = await ensureConsent(input, {
+      credentialsPath: identityPath,
+      writeAck: true,
+      out: log ? { write: (chunk) => writeLogChunk(log, chunk) } : void 0
     });
-  } catch {
-    return { status: "network_error" };
-  }
-  if (response.status === 401 || response.status === 403) return { status: "unauthorized" };
-  if (!response.ok) return { status: "bad_response" };
-  try {
-    const payload = JSON.parse(await response.text());
-    if (typeof payload?.delegate_address !== "string") return { status: "bad_response" };
-    return { status: "ok", agentId: payload.id, delegateAddress: payload.delegate_address };
-  } catch {
-    return { status: "bad_response" };
+    return {
+      acknowledged: decision.ok,
+      hash: decision.hash,
+      reason: decision.reason
+    };
+  } catch (err) {
+    return {
+      acknowledged: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
   }
 }
-async function probeHostedMcpTools(apiKey, hostedMcpUrl, fetchImpl = fetch) {
+async function getLocalMcpConsentStatus(identityPath, signerPath) {
+  try {
+    const input = await buildLocalMcpConsentInput(identityPath, signerPath);
+    const hash = computeConsentHash(input);
+    const stored = await readLocalMcpAckFile(localMcpAckPath(identityPath));
+    if (stored === hash) {
+      return { acknowledged: true, hash, reason: "ack_file_match" };
+    }
+    return {
+      acknowledged: false,
+      hash,
+      reason: stored ? "ack_file_mismatch" : "ack_file_missing"
+    };
+  } catch (err) {
+    return {
+      acknowledged: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function localMcpAckPath(identityPath) {
+  return resolve(`${identityPath}.ack.json`);
+}
+async function buildLocalMcpConsentInput(identityPath, signerPath) {
+  const credentials = await loadCredentials({ identityPath, signerPath });
+  const unavailableDuringSetup = {
+    getAllowances: async () => {
+      throw new Error("Haven approval is not complete yet.");
+    }
+  };
+  return consentInputFromClient(
+    unavailableDuringSetup,
+    {
+      apiKey: credentials.apiKey,
+      apiUrl: credentials.apiUrl,
+      agentId: credentials.agentId,
+      safeAddress: credentials.safeAddress,
+      delegateAddress: credentials.delegateAddress,
+      chainId: credentials.chainId,
+      allowanceSummary: credentials.allowanceSummary
+    },
+    registeredToolNames()
+  );
+}
+async function readLocalMcpAckFile(path) {
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    return typeof parsed.ack === "string" ? parsed.ack : null;
+  } catch {
+    return null;
+  }
+}
+function writeLogChunk(log, chunk) {
+  const message = String(chunk).trimEnd();
+  if (message) log(message);
+}
+var init_local_mcp_consent = __esm({
+  "src/local-mcp-consent.ts"() {
+  }
+});
+async function probeHostedAgentIdentity(apiKey, apiUrl, fetchImpl = fetch) {
+  let response;
+  try {
+    response = await fetchWithTimeout(fetchImpl, `${apiUrl.replace(/\/+$/, "")}/machine-payments/agent`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" }
+    });
+  } catch {
+    return { status: "network_error" };
+  }
+  if (response.status === 401 || response.status === 403) return { status: "unauthorized" };
+  if (!response.ok) return { status: "bad_response" };
+  try {
+    const payload = JSON.parse(await response.text());
+    if (typeof payload?.delegate_address !== "string") return { status: "bad_response" };
+    return { status: "ok", agentId: payload.id, delegateAddress: payload.delegate_address };
+  } catch {
+    return { status: "bad_response" };
+  }
+}
+async function probeHostedMcpTools(apiKey, hostedMcpUrl, fetchImpl = fetch) {
   let response;
   try {
     response = await fetchWithTimeout(fetchImpl, hostedMcpUrl, {
@@ -1160,81 +1658,361 @@ var init_signer_runtime = __esm({
     SIGNER_INSTALL_HEARTBEAT_MS = 15e3;
   }
 });
-
-// src/connect-error.ts
-var ConnectError;
-var init_connect_error = __esm({
-  "src/connect-error.ts"() {
-    ConnectError = class extends Error {
-      code;
-      nextAction;
-      constructor(code, message, nextAction2) {
-        super(message);
-        this.name = "ConnectError";
-        this.code = code;
-        this.nextAction = nextAction2;
-      }
-    };
+async function prepareLocalMcpRuntime(input, deps = {}) {
+  assertSupportedNodeVersion(input.nodeVersion);
+  const homeDir = input.homeDir ?? homedir();
+  const runtimeDirectory = resolve(homeDir, ".haven", "mcp-runtime", MCP_RUNTIME_MANIFEST.mcpVersion);
+  const npmCacheDirectory = resolve(homeDir, ".haven", "npm-cache");
+  const cliPath = join(runtimeDirectory, "node_modules", "@haven_ai", "mcp", "dist", "cli.js");
+  const messages = [];
+  await mkdir(runtimeDirectory, { recursive: true, mode: 448 });
+  await chmod(runtimeDirectory, 448).catch(() => void 0);
+  await mkdir(npmCacheDirectory, { recursive: true, mode: 448 });
+  await chmod(npmCacheDirectory, 448).catch(() => void 0);
+  if (await installedRuntimeMatches2(runtimeDirectory, cliPath)) {
+    messages.push(`Using existing local Haven MCP runtime ${mcpPackageSpec()}.`);
+  } else {
+    await installRuntimePackages2(runtimeDirectory, npmCacheDirectory, deps);
+    messages.push(`Installed local Haven MCP runtime ${mcpPackageSpec()}.`);
   }
-});
-
-// src/runtime-registry.ts
-function runtimeProfile(runtime, env = process.env) {
-  return RUNTIME_PROFILES[normalizeRuntime(runtime, env)];
+  await assertFileExists2(cliPath, "local Haven MCP CLI");
+  const wrapperPath = join(input.credentialDirectory, "bin", "haven-mcp");
+  await writeWrapper2({
+    wrapperPath,
+    cliPath,
+    identityPath: input.identityPath,
+    signerPath: input.signerPath
+  });
+  await writeRuntimeSidecar2({
+    path: join(input.credentialDirectory, "mcp-runtime.json"),
+    wrapperPath,
+    runtimeDirectory,
+    npmCacheDirectory,
+    cliPath,
+    serverName: input.serverName
+  });
+  messages.push(`Prepared stable local Haven MCP wrapper: ${wrapperPath}`);
+  return {
+    command: wrapperPath,
+    args: [],
+    wrapperPath,
+    runtimeDirectory,
+    npmCacheDirectory,
+    cliPath,
+    messages
+  };
 }
-function normalizeRuntime(runtime, env = process.env) {
-  const explicit = normalizeRuntimeName(runtime);
-  if (explicit) return explicit;
-  return detectRuntime(env) ?? "other";
+function assertSupportedNodeVersion(nodeVersion = process.versions.node, minimumNodeVersion = MCP_RUNTIME_MANIFEST.minimumNodeVersion, subject = "Haven setup") {
+  if (!isSupportedNodeVersion(nodeVersion, minimumNodeVersion)) {
+    throw new UnsupportedNodeVersionError(nodeVersion, minimumNodeVersion, subject);
+  }
 }
-async function resolveRuntimeSelection(explicit, force, options = {}) {
-  const env = options.env ?? process.env;
-  if (force !== void 0) {
-    const forced = normalizeRuntimeName(force);
-    if (!forced) {
-      throw new ConnectError(
-        "runtime_force_unrecognized",
-        `Unknown --runtime-force value "${force}". Valid values: ${RUNTIME_FLAG_VALUES}.`,
-        "rerun_connect_with_a_valid_runtime_name"
-      );
+async function installRuntimePackages2(runtimeDirectory, npmCacheDirectory, deps) {
+  const { runCommand, onProgress } = deps;
+  const baseArgs = [
+    "install",
+    "--prefix",
+    runtimeDirectory,
+    "--no-audit",
+    "--no-fund",
+    "--omit=dev",
+    "--prefer-offline",
+    mcpPackageSpec(),
+    sdkPackageSpec()
+  ];
+  const run = async (args) => {
+    const startedAt = Date.now();
+    const heartbeat = setInterval(() => {
+      const seconds = Math.round((Date.now() - startedAt) / 1e3);
+      onProgress?.(`Still installing the local Haven MCP runtime\u2026 (${seconds}s \u2014 a cold cache can take several minutes)`);
+    }, SIGNER_INSTALL_HEARTBEAT_MS);
+    heartbeat.unref?.();
+    try {
+      if (runCommand) await runCommand("npm", args);
+      else await execFileAsync2("npm", args, { timeout: SIGNER_INSTALL_TIMEOUT_MS, maxBuffer: 1024 * 1024 });
+    } finally {
+      clearInterval(heartbeat);
     }
-    return { runtime: forced, source: "force" };
-  }
-  const detected = detectRuntime(env);
-  const supplied = explicit?.trim() || options.selfReported?.trim() || void 0;
-  const hint = normalizeRuntimeName(supplied);
-  if (supplied && !hint) {
-    if (!detected) {
-      throw new ConnectError(
-        "runtime_unrecognized",
-        `"${supplied}" is not an agent runtime Haven knows. Valid values: ${RUNTIME_FLAG_VALUES} (the aliases cowork, codex and openclaw are accepted too). Re-run with one of those, or --runtime other to store credentials and finish the MCP setup by hand. Nothing was written and the Haven setup token is still unused.`,
-        "rerun_connect_with_a_valid_runtime_name"
-      );
+  };
+  try {
+    await run(baseArgs);
+  } catch {
+    try {
+      await run([...baseArgs, "--cache", npmCacheDirectory]);
+    } catch (err) {
+      throw new Error(`Could not install local Haven MCP runtime ${mcpPackageSpec()}: ${err instanceof Error ? err.message : String(err)}`);
     }
-    return { runtime: detected, source: "detected", discardedHint: supplied };
-  }
-  if (detected && hint && detected !== hint) {
-    return { runtime: detected, source: "detected", overrodeHint: hint };
   }
-  if (hint) return { runtime: hint, source: "explicit" };
-  if (detected) return { runtime: detected, source: "detected" };
-  if (options.promptForRuntime) {
-    return { runtime: await options.promptForRuntime(), source: "prompted" };
+}
+async function installedRuntimeMatches2(runtimeDirectory, cliPath) {
+  try {
+    await assertFileExists2(cliPath, "local Haven MCP CLI");
+    const [mcpPackage, sdkPackage] = await Promise.all([
+      readPackageJson2(join(runtimeDirectory, "node_modules", "@haven_ai", "mcp", "package.json")),
+      readPackageJson2(join(runtimeDirectory, "node_modules", "@haven_ai", "sdk", "package.json"))
+    ]);
+    return mcpPackage.version === MCP_RUNTIME_MANIFEST.mcpVersion && sdkPackage.version === MCP_RUNTIME_MANIFEST.sdkVersion;
+  } catch {
+    return false;
   }
-  return { runtime: null, source: "none" };
 }
-function restartRequiredForRuntime(runtime, env = process.env) {
-  const mode = runtimeProfile(runtime, env).restartMode;
-  return mode === "restart-session" || mode === "restart-app";
+async function readPackageJson2(path) {
+  return JSON.parse(await readFile(path, "utf8"));
 }
-function runtimeVerificationInstruction(runtime) {
-  const label = RUNTIME_PROFILES[runtime].label;
-  return `In ${label}, run the read-only \`haven_get_agent\` and \`haven_get_allowances\` tools to confirm the Haven wallet and live budget. Do not sign, fund, or create a payment to verify setup.`;
+async function writeWrapper2(input) {
+  await mkdir(dirname(input.wrapperPath), { recursive: true, mode: 448 });
+  await chmod(dirname(input.wrapperPath), 448).catch(() => void 0);
+  const source = [
+    "#!/usr/bin/env node",
+    "import { spawn } from 'node:child_process'",
+    "",
+    `const cliPath = ${JSON.stringify(input.cliPath)}`,
+    `const identityPath = ${JSON.stringify(input.identityPath)}`,
+    `const signerPath = ${JSON.stringify(input.signerPath)}`,
+    "",
+    "const child = spawn(process.execPath, [cliPath, '--identity', identityPath, '--signer', signerPath, ...process.argv.slice(2)], {",
+    "  stdio: 'inherit',",
+    "})",
+    "",
+    "child.on('exit', (code, signal) => {",
+    "  if (signal) process.kill(process.pid, signal)",
+    "  else process.exit(code ?? 1)",
+    "})",
+    ""
+  ].join("\n");
+  await writeFile(input.wrapperPath, source, { mode: 448 });
+  await chmod(input.wrapperPath, 448).catch(() => void 0);
 }
-function normalizeRuntimeName(runtime) {
-  const key = runtime?.trim().toLowerCase();
-  if (!key) return null;
-  return RUNTIME_ALIASES[key.replace(/\s+/g, "-")] ?? null;
+async function writeRuntimeSidecar2(input) {
+  const value = {
+    ...input.serverName ? { server_name: input.serverName } : {},
+    mcp_package: MCP_RUNTIME_MANIFEST.mcpPackage,
+    mcp_version: MCP_RUNTIME_MANIFEST.mcpVersion,
+    sdk_package: MCP_RUNTIME_MANIFEST.sdkPackage,
+    sdk_version: MCP_RUNTIME_MANIFEST.sdkVersion,
+    minimum_node_version: MCP_RUNTIME_MANIFEST.minimumNodeVersion,
+    wrapper_path: input.wrapperPath,
+    runtime_directory: input.runtimeDirectory,
+    npm_cache_directory: input.npmCacheDirectory,
+    cli_path: input.cliPath
+  };
+  await writeFile(input.path, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  await chmod(input.path, 384).catch(() => void 0);
+}
+async function assertFileExists2(path, label) {
+  try {
+    await access(path);
+  } catch {
+    throw new Error(`Missing ${label}: ${path}`);
+  }
+}
+var execFileAsync2, UnsupportedNodeVersionError;
+var init_local_mcp_runtime = __esm({
+  "src/local-mcp-runtime.ts"() {
+    init_signer_runtime();
+    init_runtime_manifest();
+    execFileAsync2 = promisify(execFile);
+    UnsupportedNodeVersionError = class extends Error {
+      code = "local_mcp_unsupported_node_version";
+      nodeVersion;
+      minimumNodeVersion;
+      constructor(nodeVersion, minimumNodeVersion, subject = "Haven setup") {
+        super(unsupportedNodeVersionMessage({ subject, nodeVersion, minimumNodeVersion }));
+        this.name = "UnsupportedNodeVersionError";
+        this.nodeVersion = nodeVersion;
+        this.minimumNodeVersion = minimumNodeVersion;
+      }
+    };
+  }
+});
+async function installSkillForRuntime(runtime, deps = {}) {
+  switch (runtime) {
+    case "claude-code":
+      return installSkillFile(
+        resolve(deps.homeDir ?? homedir(), ".claude", "skills", SKILL_FOLDER_NAME),
+        "~/.claude/skills/haven-pay"
+      );
+    case "hermes":
+      return installSkillFile(
+        join(hermesHome(deps), "skills", SKILL_FOLDER_NAME),
+        "the Hermes skills folder"
+      );
+    case "codex-cli":
+    case "codex-desktop":
+      return installCodexAgentsSection(deps);
+    default:
+      return void 0;
+  }
+}
+async function installSkillFile(skillDir, label) {
+  try {
+    await mkdir(skillDir, { recursive: true });
+    const target = join(skillDir, "SKILL.md");
+    await writeFile(target, HAVEN_SKILL_MD, "utf8");
+    return {
+      installed: true,
+      target,
+      messages: [`Installed the generic Haven payment skill (${label}). It contains no secrets.`]
+    };
+  } catch (err) {
+    return {
+      installed: false,
+      messages: [
+        `Could not install the Haven payment skill: ${err instanceof Error ? err.message : String(err)}. Download it from the Haven dashboard instead.`
+      ]
+    };
+  }
+}
+async function installCodexAgentsSection(deps) {
+  try {
+    const codexDir = resolve(deps.homeDir ?? homedir(), ".codex");
+    const target = join(codexDir, "AGENTS.md");
+    await mkdir(codexDir, { recursive: true });
+    const existing = await readFile(target, "utf8").catch(() => null);
+    const next = upsertManagedSection(existing, codexManagedSection());
+    if (next !== existing) {
+      await writeFile(target, next, "utf8");
+    }
+    return {
+      installed: true,
+      target,
+      messages: [
+        "Installed the generic Haven payment guidance as a managed section in ~/.codex/AGENTS.md (Codex reads it as global instructions). It contains no secrets; your own content in that file is untouched."
+      ]
+    };
+  } catch (err) {
+    return {
+      installed: false,
+      messages: [
+        `Could not install the Haven payment guidance into ~/.codex/AGENTS.md: ${err instanceof Error ? err.message : String(err)}. Download the skill from the Haven dashboard instead.`
+      ]
+    };
+  }
+}
+function codexManagedSection() {
+  return `${CODEX_AGENTS_BEGIN_MARKER}
+
+${HAVEN_SKILL_BODY_MD.trimEnd()}
+
+${CODEX_AGENTS_END_MARKER}
+`;
+}
+function upsertManagedSection(existing, section) {
+  if (existing === null || existing.trim() === "") return section;
+  const begins = markerLineIndexes(existing, CODEX_AGENTS_BEGIN_MARKER);
+  const ends = markerLineIndexes(existing, CODEX_AGENTS_END_MARKER);
+  if (begins.length === 1 && ends.length === 1 && ends[0] > begins[0]) {
+    const afterEnd = ends[0] + CODEX_AGENTS_END_MARKER.length;
+    const tail = existing.startsWith("\r\n", afterEnd) ? existing.slice(afterEnd + 2) : existing.startsWith("\n", afterEnd) ? existing.slice(afterEnd + 1) : existing.slice(afterEnd);
+    return existing.slice(0, begins[0]) + section + tail;
+  }
+  if (begins.length > 0 || ends.length > 0) {
+    throw new Error(
+      "found a damaged Haven marker section (orphaned or duplicated markers); remove the leftover marker lines and re-run setup"
+    );
+  }
+  return `${existing.replace(/\n*$/, "\n\n")}${section}`;
+}
+function markerLineIndexes(text, marker) {
+  const indexes = [];
+  for (let from = 0; ; ) {
+    const at = text.indexOf(marker, from);
+    if (at === -1) return indexes;
+    if (at === 0 || text[at - 1] === "\n") indexes.push(at);
+    from = at + marker.length;
+  }
+}
+function hermesHome(deps) {
+  const env = deps.env ?? process.env;
+  return env.HERMES_HOME ?? join(deps.homeDir ?? homedir(), ".hermes");
+}
+var CODEX_AGENTS_BEGIN_MARKER, CODEX_AGENTS_END_MARKER;
+var init_skill_install = __esm({
+  "src/skill-install.ts"() {
+    CODEX_AGENTS_BEGIN_MARKER = "<!-- BEGIN haven-pay (managed by @haven_ai/connect; edits inside this section are overwritten on re-setup) -->";
+    CODEX_AGENTS_END_MARKER = "<!-- END haven-pay -->";
+  }
+});
+
+// src/connect-error.ts
+var ConnectError;
+var init_connect_error = __esm({
+  "src/connect-error.ts"() {
+    ConnectError = class extends Error {
+      code;
+      nextAction;
+      details;
+      constructor(code, message, nextAction2, details = {}) {
+        super(message);
+        this.name = "ConnectError";
+        this.code = code;
+        this.nextAction = nextAction2;
+        this.details = details;
+      }
+    };
+  }
+});
+
+// src/runtime-registry.ts
+function runtimeProfile(runtime, env = process.env) {
+  return RUNTIME_PROFILES[normalizeRuntime(runtime, env)];
+}
+function normalizeRuntime(runtime, env = process.env) {
+  const explicit = normalizeRuntimeName(runtime);
+  if (explicit) return explicit;
+  return detectRuntime(env) ?? "other";
+}
+async function resolveRuntimeSelection(explicit, force, options = {}) {
+  const env = options.env ?? process.env;
+  if (force !== void 0) {
+    const forced = normalizeRuntimeName(force);
+    if (!forced) {
+      throw new ConnectError(
+        "runtime_force_unrecognized",
+        `Unknown --runtime-force value "${force}". Valid values: ${RUNTIME_FLAG_VALUES}.`,
+        "rerun_connect_with_a_valid_runtime_name",
+        { allowedRuntimes: RUNTIME_FLAG_VALUE_LIST }
+      );
+    }
+    return { runtime: forced, source: "force" };
+  }
+  const detected = detectRuntime(env);
+  const supplied = explicit?.trim() || options.selfReported?.trim() || void 0;
+  const hint = normalizeRuntimeName(supplied);
+  if (supplied && !hint) {
+    if (!detected) {
+      throw new ConnectError(
+        "runtime_unrecognized",
+        `"${supplied}" is not an agent runtime Haven knows. Valid values: ${RUNTIME_FLAG_VALUES} (the aliases cowork, codex and openclaw are accepted too). Re-run with one of those, or --runtime other to store credentials and finish the MCP setup by hand. Nothing was written and the Haven setup token is still unused.`,
+        "rerun_connect_with_a_valid_runtime_name",
+        { allowedRuntimes: RUNTIME_FLAG_VALUE_LIST }
+      );
+    }
+    return { runtime: detected, source: "detected", discardedHint: supplied };
+  }
+  if (detected && hint && detected !== hint) {
+    return { runtime: detected, source: "detected", overrodeHint: hint };
+  }
+  if (hint) return { runtime: hint, source: "explicit" };
+  if (detected) return { runtime: detected, source: "detected" };
+  if (options.promptForRuntime) {
+    return { runtime: await options.promptForRuntime(), source: "prompted" };
+  }
+  return { runtime: null, source: "none" };
+}
+function restartRequiredForRuntime(runtime, env = process.env) {
+  const mode = runtimeProfile(runtime, env).restartMode;
+  return mode === "restart-session" || mode === "restart-app";
+}
+function runtimeVerificationInstruction(runtime) {
+  const label = RUNTIME_PROFILES[runtime].label;
+  return `In ${label}, run the read-only \`haven_get_agent\` and \`haven_get_allowances\` tools to confirm the Haven wallet and live budget. Do not sign, fund, or create a payment to verify setup.`;
+}
+function normalizeRuntimeName(runtime) {
+  const key = runtime?.trim().toLowerCase();
+  if (!key) return null;
+  return RUNTIME_ALIASES[key.replace(/\s+/g, "-")] ?? null;
 }
 function detectRuntime(env) {
   if (env.CLAUDECODE || env.CLAUDE_CODE || env.CLAUDECODE_CWD) return "claude-code";
@@ -1243,7 +2021,7 @@ function detectRuntime(env) {
   if (env.HERMES_HOME || env.HERMES_AGENT) return "hermes";
   return null;
 }
-var RUNTIME_PROFILES, RUNTIME_ALIASES, RUNTIME_FLAG_VALUES;
+var RUNTIME_PROFILES, RUNTIME_ALIASES, RUNTIME_FLAG_VALUE_LIST, RUNTIME_FLAG_VALUES;
 var init_runtime_registry = __esm({
   "src/runtime-registry.ts"() {
     init_connect_error();
@@ -1362,7 +2140,18 @@ var init_runtime_registry = __esm({
       other: "other",
       manual: "other"
     };
-    RUNTIME_FLAG_VALUES = "claude-code, codex-cli, codex-desktop, cursor, vscode, vscode-insiders, claude-desktop, hermes, other";
+    RUNTIME_FLAG_VALUE_LIST = [
+      "claude-code",
+      "codex-cli",
+      "codex-desktop",
+      "cursor",
+      "vscode",
+      "vscode-insiders",
+      "claude-desktop",
+      "hermes",
+      "other"
+    ];
+    RUNTIME_FLAG_VALUES = RUNTIME_FLAG_VALUE_LIST.join(", ");
   }
 });
 async function acknowledgeLocalSignerConsent(signerPath, log) {
@@ -1438,1519 +2227,1319 @@ var init_signer_consent = __esm({
   "src/signer-consent.ts"() {
   }
 });
-
-// src/tombstone.ts
-var tombstone_exports = {};
-__export(tombstone_exports, {
-  TOMBSTONE_FILENAME: () => TOMBSTONE_FILENAME,
-  TOMBSTONE_MARKER: () => TOMBSTONE_MARKER,
-  readAgentTombstone: () => readAgentTombstone,
-  writeAgentTombstone: () => writeAgentTombstone
-});
-function tombstoneScript(info) {
-  const lines = [
-    `${TOMBSTONE_MARKER}: this Haven agent was retired.`,
-    "",
-    `  agent:      ${info.agent_id}`,
-    `  retired at: ${info.retired_at}`,
-    `  reason:     ${info.reason}`,
-    ...info.replaced_by ? [`  replaced by: ${info.replaced_by}`] : [],
-    "",
-    "This process is running with a wiring snapshot that predates the",
-    "retirement \u2014 it loaded its MCP config at startup and has kept it since.",
-    "Restart THIS host to pick up the current wiring. If several long-lived",
-    "hosts are running (a gateway, a TUI worker, an editor), restart EVERY",
-    "one of them: each holds the snapshot from its own start time, so after",
-    "a chain of recreations each can be parked on a DIFFERENT old agent.",
-    "",
-    "Then verify with: npx @haven_ai/connect@alpha --doctor --runtime <runtime>"
-  ];
-  return [
-    "#!/usr/bin/env node",
-    `// ${TOMBSTONE_MARKER} \u2014 written by @haven_ai/connect (#1681). Safe to delete`,
-    "// once every long-lived MCP host on this machine has been restarted.",
-    `process.stderr.write(${JSON.stringify(lines.join("\n") + "\n")})`,
-    "process.exit(1)",
-    ""
-  ].join("\n");
-}
-async function writeAgentTombstone(input) {
-  const dirStat = await stat(input.directory).catch(() => null);
-  if (!dirStat?.isDirectory()) {
-    throw new Error(`Not a directory: ${input.directory} \u2014 nothing to tombstone.`);
-  }
-  const info = {
-    // reason / replaced_by are persisted to disk and re-emitted to the host's
-    // MCP stderr log on EVERY stale probe, potentially for months — redact
-    // like every other output path, at the write layer so any future caller
-    // inherits it. (#1681 review, finding 1)
-    agent_id: input.agentId,
-    retired_at: input.retiredAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-    reason: redactSecrets(input.reason),
-    ...input.replacedBy ? { replaced_by: redactSecrets(input.replacedBy) } : {}
-  };
-  const binDir = join(input.directory, "bin");
-  await mkdir(binDir, { recursive: true });
-  const wrapperPath = join(binDir, "haven-signer.mjs");
-  await writeFile(wrapperPath, tombstoneScript(info), "utf8");
-  await chmod(wrapperPath, 493);
-  await writeFile(join(input.directory, TOMBSTONE_FILENAME), JSON.stringify(info, null, 2) + "\n", "utf8");
-  return info;
-}
-async function readAgentTombstone(directory) {
-  try {
-    const parsed = JSON.parse(await readFile(join(directory, TOMBSTONE_FILENAME), "utf8"));
-    if (typeof parsed?.agent_id !== "string") return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-var TOMBSTONE_FILENAME, TOMBSTONE_MARKER;
-var init_tombstone = __esm({
-  "src/tombstone.ts"() {
-    init_redact();
-    TOMBSTONE_FILENAME = "TOMBSTONE.json";
-    TOMBSTONE_MARKER = "HAVEN-TOMBSTONE";
-  }
-});
-
-// src/doctor.ts
-var doctor_exports = {};
-__export(doctor_exports, {
-  runDoctor: () => runDoctor,
-  runRepair: () => runRepair
-});
-async function discoverCredentialDirectory(homeDir, explicit) {
-  const root = explicit ? dirname(explicit) : join(homeDir, ".haven", "agents");
-  let entries = [];
-  try {
-    entries = await readdir(root);
-  } catch {
-    return explicit ? { directory: explicit, others: [] } : { others: [] };
+async function installRuntime(input, deps = {}) {
+  const runtime = normalizeRuntime(input.runtime, deps.env);
+  const profile = runtimeProfile(runtime, deps.env);
+  const progress = deps.onProgress ?? (() => void 0);
+  const localRuntime = input.localMcp === true && supportsLocalMcp(runtime);
+  const consentMessages = [];
+  const localMcpConsent = localRuntime ? await resolveLocalMcpConsent(input, consentMessages) : void 0;
+  const signerConsent = localRuntime ? void 0 : await resolveSignerConsent(input, consentMessages);
+  if (runtime === "other") {
+    const signerCredentialReady2 = await probeLocalSignerCredential(input.signerPath);
+    const signerReady = signerCredentialReady2 && signerConsent?.acknowledged;
+    return {
+      runtime,
+      runtimeMcpMode: "manual",
+      hostedMcpConfigured: false,
+      localSignerConfigured: false,
+      localMcpConfigured: false,
+      probeResult: signerReady ? "manual_runtime_setup_required_local_signer_ready" : "manual_runtime_setup_required_local_signer_unavailable",
+      restartRequired: true,
+      nextUserAction: "return_to_haven_for_wallet_approval_then_configure_runtime",
+      errorCode: "manual_runtime_setup_required",
+      configTarget: "manual runtime setup",
+      signerAcknowledged: signerConsent?.acknowledged,
+      localMcpAcknowledged: false,
+      messages: [
+        ...consentMessages,
+        "Custom runtime: Haven did not auto-configure it. Your credentials are on disk (chmod 600) \u2014 read them at runtime; never paste a key into the agent prompt, memory, or logs.",
+        `  identity (hosted MCP Bearer): ${input.identityPath}`,
+        `  signer (local signing key):   ${input.signerPath}`,
+        "After wallet approval, wire the runtime to Haven by reference:",
+        `  Hosted MCP + local signer: point your MCP client at ${input.hostedMcpUrl} with the api_key from identity.json, then run  npx -y ${signerPackageSpec()} --credentials ${input.signerPath}`,
+        `  Fully local MCP (no hosted dependency):  npx -y ${mcpPackageSpec()} --identity ${input.identityPath} --signer ${input.signerPath}`
+      ]
+    };
   }
-  const candidates = [];
-  const tombstonedOnly = [];
-  for (const entry of entries) {
-    const directory = join(root, entry);
+  let localRuntimeInstall;
+  let localRuntimeError;
+  if (localRuntime) {
     try {
-      const s = await stat(join(directory, "identity.json"));
-      candidates.push({ directory, mtimeMs: s.mtimeMs });
-    } catch {
-      try {
-        await stat(join(directory, TOMBSTONE_FILENAME));
-        tombstonedOnly.push(directory);
-      } catch {
-      }
+      localRuntimeInstall = await prepareRuntimeForLocalMcp(input, deps);
+    } catch (err) {
+      localRuntimeError = err;
     }
   }
-  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  if (explicit) {
+  if (localRuntimeError) {
+    const errorCode2 = localRuntimePrepareErrorCode(localRuntimeError);
     return {
-      directory: explicit,
-      others: [...candidates.map((c) => c.directory), ...tombstonedOnly].filter((d) => d !== explicit)
+      runtime,
+      runtimeMcpMode: "local_stdio",
+      hostedMcpConfigured: false,
+      localSignerConfigured: false,
+      localMcpConfigured: false,
+      probeResult: errorCode2 === "local_mcp_unsupported_node_version" ? "local_stdio_mcp_unsupported_node_version" : "local_stdio_mcp_runtime_install_failed",
+      restartRequired: true,
+      nextUserAction: nextAction(runtime, profile.restartMode, errorCode2),
+      errorCode: errorCode2,
+      configTarget: profile.label,
+      signerAcknowledged: signerConsent?.acknowledged,
+      localMcpAcknowledged: localMcpConsent?.acknowledged,
+      activationCommand: void 0,
+      messages: [
+        ...consentMessages,
+        `Could not prepare local Haven MCP runtime: ${localRuntimeError instanceof Error ? localRuntimeError.message : String(localRuntimeError)}`
+      ]
     };
   }
-  if (candidates.length === 0 && tombstonedOnly.length === 0) return { others: [] };
+  let signerCommand;
+  if (!localRuntime) {
+    progress("Getting the signer ready\u2026");
+    try {
+      const signerRuntime = await prepareSignerForRuntime(input, deps);
+      signerCommand = { command: signerRuntime.command, args: signerRuntime.args };
+      consentMessages.push(...signerRuntime.messages);
+    } catch (err) {
+      return {
+        runtime,
+        runtimeMcpMode: "hosted_plus_signer",
+        hostedMcpConfigured: false,
+        localSignerConfigured: false,
+        localMcpConfigured: false,
+        probeResult: "signer_runtime_install_failed",
+        restartRequired: false,
+        nextUserAction: "The local Haven signer runtime could not be installed, so no configuration was written. Check your network (a cold install downloads the signer package set) and re-run: npx @haven_ai/connect@alpha",
+        errorCode: "signer_runtime_install_failed",
+        configTarget: profile.label,
+        signerAcknowledged: signerConsent?.acknowledged,
+        localMcpAcknowledged: localMcpConsent?.acknowledged,
+        activationCommand: void 0,
+        signerRuntimePrepared: false,
+        messages: [
+          ...consentMessages,
+          `Could not pre-install the local Haven signer: ${err instanceof Error ? err.message : String(err)}`,
+          "No runtime configuration was written (fail-closed): a config pointing at an uninstalled signer looks wired but cannot start.",
+          "Re-run `npx @haven_ai/connect@alpha` to retry the setup."
+        ]
+      };
+    }
+  }
+  const signerRuntimePrepared = localRuntime ? void 0 : signerCommand !== void 0;
+  progress("Setting up your Haven tools\u2026");
+  const configResult = localRuntime ? runtime === "claude-code" ? await configureClaudeCode(deps, localRuntimeInstall?.command ?? "", input.serverName) : await writeRuntimeConfig({
+    runtime,
+    hostedMcpUrl: input.hostedMcpUrl,
+    apiKey: input.apiKey,
+    identityPath: input.identityPath,
+    signerPath: input.signerPath,
+    serverName: input.serverName,
+    credentialDirectory: input.credentialDirectory,
+    localMcpCommand: localRuntimeInstall?.command,
+    signerCommand,
+    homeDir: deps.homeDir,
+    mode: "local"
+  }) : await writeHostedRuntimeConfig(deps, { ...input, runtime }, signerCommand);
+  if (deps.onRuntimeConfigured) {
+    const signerCredentialOnDisk = await probeLocalSignerCredential(input.signerPath);
+    const earlyLocalMcpOk = configResult.runtimeMcpMode === "local_stdio" && configResult.localMcpConfigured && signerCredentialOnDisk && Boolean(localMcpConsent?.acknowledged);
+    const earlySignerOk = configResult.runtimeMcpMode === "local_stdio" ? earlyLocalMcpOk : configResult.signerConfigured && signerCredentialOnDisk && Boolean(signerConsent?.acknowledged);
+    try {
+      await deps.onRuntimeConfigured({
+        runtime,
+        runtimeMcpMode: configResult.runtimeMcpMode,
+        hostedMcpConfigured: configResult.hostedConfigured,
+        localSignerConfigured: earlySignerOk,
+        localMcpConfigured: earlyLocalMcpOk,
+        signerAcknowledged: signerConsent?.acknowledged,
+        localMcpAcknowledged: localMcpConsent?.acknowledged,
+        restartRequired: configResult.restartRequired || restartRequiredForRuntime(runtime, deps.env),
+        nextUserAction: nextAction(runtime, profile.restartMode, configResult.errorCode),
+        errorCode: configResult.errorCode
+      });
+    } catch {
+    }
+  }
+  progress("Almost there \u2014 just confirming everything connects\u2026");
+  const localProbePromise = configResult.runtimeMcpMode === "local_stdio" && localRuntimeInstall ? runLocalMcpProbe(localRuntimeInstall, deps) : Promise.resolve(void 0);
+  const signerProbePromise = configResult.runtimeMcpMode !== "local_stdio" && signerCommand ? (deps.probeSignerTools ?? probeLocalMcpTools)(
+    signerCommand.command,
+    signerCommand.args,
+    MCP_RUNTIME_MANIFEST.requiredSignerTools
+  ) : Promise.resolve(void 0);
+  const [hostedProbe, signerCredentialReady, localMcpProbe, signerProbe] = await Promise.all([
+    configResult.hostedConfigured ? probeHostedMcpTools(input.apiKey, input.hostedMcpUrl, deps.fetch) : Promise.resolve({ status: "bad_response" }),
+    probeLocalSignerCredential(input.signerPath),
+    localProbePromise,
+    signerProbePromise
+  ]);
+  const hostedOk = configResult.hostedConfigured && hostedProbe.status === "ok";
+  const localMcpOk = configResult.runtimeMcpMode === "local_stdio" && configResult.localMcpConfigured && signerCredentialReady && Boolean(localMcpConsent?.acknowledged) && localMcpProbe?.status === "ok";
+  const signerOk = configResult.runtimeMcpMode === "local_stdio" ? localMcpOk : configResult.signerConfigured && signerCredentialReady && Boolean(signerConsent?.acknowledged) && // #1587: no handshake, no green. A signer command that was registered
+  // but not probed (manual topology) keeps the old semantics.
+  (signerProbe === void 0 || signerProbe.status === "ok");
+  const restartRequired = configResult.restartRequired || restartRequiredForRuntime(runtime, deps.env);
+  const errorCode = configResult.errorCode ?? (configResult.runtimeMcpMode === "local_stdio" ? localMcpErrorCode(signerCredentialReady, localMcpConsent, localMcpProbe?.status) : hostedMcpErrorCode(configResult.hostedConfigured, hostedProbe.status) ?? signerConsentErrorCode(signerCredentialReady, signerConsent) ?? signerProbeErrorCode(signerProbe));
+  const hostedProbeMessages = configResult.hostedConfigured && hostedProbe.status !== "ok" ? [`Hosted Haven MCP probe failed: ${hostedProbe.status}.`] : configResult.hostedConfigured ? ["Verified hosted Haven MCP tools with a read-only handshake."] : [];
+  const signerProbeMessages = signerProbe ? signerProbe.status === "ok" ? ["Verified local Haven signer with a stdio handshake."] : [
+    `Local Haven signer handshake failed: ${signerProbe.status}.`,
+    "Re-run `npx @haven_ai/connect@alpha` to repair the signer setup."
+  ] : [];
+  const localProbeMessages = localMcpProbe && localMcpProbe.status !== "ok" ? [`Local Haven MCP handshake failed: ${localMcpProbe.status}.`] : localMcpProbe?.status === "ok" ? ["Verified local Haven MCP tools with a stdio handshake."] : [];
+  const skillInstall = !configResult.errorCode ? await installSkillForRuntime(runtime, { homeDir: deps.homeDir, env: deps.env }) : void 0;
   return {
-    directory: candidates[0]?.directory,
-    others: [...candidates.slice(1).map((c) => c.directory), ...tombstonedOnly]
+    runtime,
+    runtimeMcpMode: configResult.runtimeMcpMode,
+    hostedMcpConfigured: hostedOk,
+    localSignerConfigured: signerOk,
+    localMcpConfigured: localMcpOk,
+    probeResult: buildProbeResult(configResult.runtimeMcpMode, configResult.hostedConfigured, hostedProbe.status, signerOk, localMcpOk, localMcpProbe?.status),
+    restartRequired,
+    nextUserAction: nextAction(runtime, profile.restartMode, errorCode),
+    errorCode,
+    configTarget: configResult.target,
+    signerAcknowledged: signerConsent?.acknowledged,
+    localMcpAcknowledged: localMcpConsent?.acknowledged,
+    activationCommand: configResult.activationCommand,
+    skillInstalled: skillInstall?.installed,
+    signerRuntimePrepared,
+    messages: [...consentMessages, ...localRuntimeInstall?.messages ?? [], ...configResult.messages, ...hostedProbeMessages, ...signerProbeMessages, ...localProbeMessages, ...skillInstall?.messages ?? []]
   };
 }
-function agentIsWired(configText, names, slug, identity, sidecar, isPrimary, bareOwnerExists) {
-  if (configText === null) return isPrimary;
-  if (slug) {
-    for (const name of [names.hosted, names.codexHosted, names.signer, names.codexSigner]) {
-      if (new RegExp(`(^|[."'\\s\\[])${name}(["'\\]:\\s]|$)`, "m").test(configText)) return true;
-    }
-    return false;
-  }
-  if (sidecar?.wrapper_path && configText.includes(sidecar.wrapper_path)) return true;
-  if (bareOwnerExists) return false;
-  return isPrimary && Boolean(identity?.hosted_mcp_url && configText.includes(identity.hosted_mcp_url));
+function runtimeInstallCapabilities(runtime, env = process.env) {
+  const profile = runtimeProfile(runtime, env);
+  return {
+    canWriteRuntimeConfig: profile.canWriteRuntimeConfig,
+    restartRequired: restartRequiredForRuntime(runtime, env)
+  };
 }
-async function readIdentity(directory) {
+async function configureClaudeCode(deps, localMcpCommand, serverName) {
+  const runCommand = deps.runCommand ?? defaultRunCommand;
+  const serverJson = JSON.stringify({
+    type: "stdio",
+    command: localMcpCommand,
+    args: [],
+    env: {}
+  });
   try {
-    return JSON.parse(await readFile(join(directory, "identity.json"), "utf8"));
-  } catch {
-    return void 0;
-  }
-}
-async function checksForAgent(entry, input, deps) {
-  const { directory, identity, sidecar } = entry;
-  const checks = [];
-  let signerCapabilities;
-  let signerFile;
-  try {
-    const parsed = JSON.parse(await readFile(join(directory, "signer.json"), "utf8"));
-    signerFile = typeof parsed === "object" && parsed !== null ? parsed : void 0;
-  } catch {
-    signerFile = void 0;
+    if (!localMcpCommand) throw new Error("local MCP wrapper command is required");
+    const names = serverNamesFor(serverName);
+    await runCommand("claude", ["mcp", "remove", names.hosted]).catch(() => void 0);
+    await runCommand("claude", ["mcp", "remove", names.signer]).catch(() => void 0);
+    await runCommand("claude", ["mcp", "add-json", names.hosted, serverJson, "--scope", "user"]).catch(async () => {
+      await runCommand("claude", ["mcp", "add", names.hosted, "--scope", "user", "--", localMcpCommand]);
+    });
+    const verified = await runCommand("claude", ["mcp", "get", names.hosted]).then(() => true).catch(() => false);
+    return {
+      hostedConfigured: false,
+      signerConfigured: true,
+      localMcpConfigured: true,
+      runtimeMcpMode: "local_stdio",
+      target: "Claude Code MCP config",
+      changed: true,
+      restartRequired: true,
+      messages: [
+        "Updated local Haven MCP entry with Claude Code.",
+        ...verified ? ["Verified Claude Code MCP entry."] : []
+      ]
+    };
+  } catch (err) {
+    return {
+      hostedConfigured: false,
+      signerConfigured: false,
+      localMcpConfigured: false,
+      runtimeMcpMode: "local_stdio",
+      target: "Claude Code MCP config",
+      changed: false,
+      restartRequired: true,
+      messages: [
+        `Could not update Claude Code MCP config: ${err instanceof Error ? err.message : String(err)}`,
+        "Install Claude Code or rerun the Haven setup command inside a Claude Code terminal."
+      ],
+      errorCode: "claude_code_config_failed"
+    };
   }
-  const credentialsOk = Boolean(identity?.api_key) && signerFile !== void 0;
-  checks.push({
-    id: "credentials",
-    label: "Agent credentials",
-    ok: credentialsOk,
-    detail: credentialsOk ? `identity.json and signer.json parse (agent ${identity?.agent_id ?? "unknown"})` : "identity.json or signer.json is missing or unparseable.",
-    ...credentialsOk ? {} : { repair: `Re-run the full setup with a fresh token: ${RERUN} --setup <token>.` }
+}
+async function writeHostedRuntimeConfig(deps, input, signerCommand) {
+  if (input.runtime === "claude-code") {
+    return configureClaudeCodeHosted(deps, input, signerCommand);
+  }
+  return writeRuntimeConfig({
+    runtime: input.runtime,
+    hostedMcpUrl: input.hostedMcpUrl,
+    apiKey: input.apiKey,
+    identityPath: input.identityPath,
+    signerPath: input.signerPath,
+    serverName: input.serverName,
+    credentialDirectory: input.credentialDirectory,
+    signerCommand,
+    homeDir: deps.homeDir,
+    mode: "hosted"
   });
-  if (!sidecar) {
-    checks.push({
-      id: "signer_runtime",
-      label: "Signer runtime (preinstalled wrapper)",
-      ok: false,
-      detail: "No signer-runtime.json sidecar \u2014 the pinned signer runtime was never prepared (or a pre-#1586 npx config).",
-      repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}`
-    });
-  } else {
-    const matches = await installedRuntimeMatches(sidecar.runtime_directory, sidecar.cli_path);
-    const versionOk = sidecar.signer_version === MCP_RUNTIME_MANIFEST.signerVersion;
-    const ok = matches && versionOk;
-    checks.push({
-      id: "signer_runtime",
-      label: "Signer runtime (preinstalled wrapper)",
-      ok,
-      detail: ok ? `Installed ${sidecar.signer_package}@${sidecar.signer_version} at ${sidecar.runtime_directory}` : matches ? `Installed version ${sidecar.signer_version} does not match the connector's pinned ${MCP_RUNTIME_MANIFEST.signerVersion}.` : `Runtime directory is stale or empty (${sidecar.runtime_directory}) \u2014 the CLI or package versions are missing.`,
-      ...ok ? {} : { repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}` }
-    });
+}
+async function configureClaudeCodeHosted(deps, input, signerCommand) {
+  const runCommand = deps.runCommand ?? defaultRunCommand;
+  const hostedJson = JSON.stringify({
+    type: "http",
+    url: input.hostedMcpUrl,
+    headers: { Authorization: `Bearer ${input.apiKey}` }
+  });
+  const signerJson = JSON.stringify({
+    type: "stdio",
+    command: signerCommand?.command ?? "npx",
+    args: signerCommand?.args ?? ["-y", signerPackageSpec(), "--credentials", input.signerPath],
+    env: {}
+  });
+  try {
+    const names = serverNamesFor(input.serverName);
+    await runCommand("claude", ["mcp", "remove", names.hosted]).catch(() => void 0);
+    await runCommand("claude", ["mcp", "remove", names.signer]).catch(() => void 0);
+    await runCommand("claude", ["mcp", "add-json", names.hosted, hostedJson, "--scope", "user"]);
+    await runCommand("claude", ["mcp", "add-json", names.signer, signerJson, "--scope", "user"]);
+    const verified = await runCommand("claude", ["mcp", "get", names.hosted]).then(() => true).catch(() => false);
+    return {
+      hostedConfigured: true,
+      signerConfigured: true,
+      localMcpConfigured: false,
+      runtimeMcpMode: "hosted_plus_signer",
+      target: "Claude Code MCP config",
+      changed: true,
+      restartRequired: true,
+      messages: [
+        "Updated hosted Haven MCP and local signer entries with Claude Code.",
+        ...verified ? ["Verified Claude Code MCP entry."] : []
+      ]
+    };
+  } catch (err) {
+    return {
+      hostedConfigured: false,
+      signerConfigured: false,
+      localMcpConfigured: false,
+      runtimeMcpMode: "hosted_plus_signer",
+      target: "Claude Code MCP config",
+      changed: false,
+      restartRequired: true,
+      messages: [
+        `Could not update Claude Code MCP config: ${err instanceof Error ? err.message : String(err)}`,
+        "Install Claude Code or rerun the Haven setup command inside a Claude Code terminal."
+      ],
+      errorCode: "claude_code_config_failed"
+    };
   }
-  const hostedUrl = identity?.hosted_mcp_url ?? (identity?.api_url ? `${identity.api_url}/mcp` : void 0);
-  if (identity?.api_key && hostedUrl) {
-    const probe = await (deps.probeHosted ?? probeHostedMcpTools)(identity.api_key, hostedUrl, deps.fetch);
-    checks.push({
-      id: "hosted_mcp",
-      label: "Hosted Haven MCP",
-      ok: probe.status === "ok",
-      detail: probe.status === "ok" ? `Reachable and authorized (${hostedUrl}).` : `Probe failed: ${probe.status} (${hostedUrl}).`,
-      ...probe.status === "ok" ? {} : {
-        repair: probe.status === "unauthorized" ? `The stored API key was rejected \u2014 re-run the full setup with a fresh token: ${RERUN} --setup <token>.` : "Check network access to the hosted MCP URL, then re-run --doctor."
-      }
-    });
-  } else {
-    checks.push({
-      id: "hosted_mcp",
-      label: "Hosted Haven MCP",
-      ok: false,
-      detail: "No stored API key / hosted MCP URL to probe with.",
-      repair: `Re-run the full setup: ${RERUN} --setup <token>.`
-    });
+}
+async function defaultRunCommand(command, args) {
+  await execFileAsync3(command, args, { timeout: 1e4 });
+}
+function buildProbeResult(mode, hostedConfigured, hostedStatus, signerReady, localMcpReady, localMcpProbeStatus) {
+  if (mode === "local_stdio") {
+    if (localMcpReady) return "local_stdio_mcp_ready";
+    return localMcpProbeStatus ? `local_stdio_mcp_${localMcpProbeStatus}` : "local_stdio_mcp_unavailable";
   }
-  const localDelegate = typeof signerFile?.delegate_address === "string" ? signerFile.delegate_address : void 0;
-  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") {
-      checks.push({
-        id: "identity_match",
-        label: "Hosted identity matches the local signing key",
-        ok: false,
-        detail: probe.status === "unauthorized" ? "The stored API key was rejected, so the agent it authenticates as cannot be compared with the local signing key." : `Could not read the hosted identity (${probe.status}) \u2014 the comparison did not happen, so it cannot be reported as a match.`,
-        repair: probe.status === "unauthorized" ? `Re-run the full setup with a fresh token: ${RERUN} --setup <token>.` : `Restore network access to the Haven API, then re-run: ${RERUN} --doctor --runtime ${input.runtime}`
-      });
-    } else if (!localDelegate) {
-      checks.push({
-        id: "identity_match",
-        label: "Hosted identity matches the local signing key",
-        ok: false,
-        detail: "signer.json holds no delegate_address to compare against the hosted identity.",
-        repair: `Re-run the full setup with a fresh token: ${RERUN} --setup <token>.`
-      });
+  const hostedPart = hostedConfigured ? `hosted_${hostedStatus}` : "hosted_not_configured";
+  const signerPart = signerReady ? "local_signer_ready" : "local_signer_unavailable";
+  return `${hostedPart}_${signerPart}`.slice(0, 120);
+}
+async function resolveLocalMcpConsent(input, messages) {
+  if (input.ackLocalTools || input.ackSigner) {
+    const status = await acknowledgeLocalMcpConsent(input.identityPath, input.signerPath, (message) => messages.push(message));
+    if (status.acknowledged) {
+      messages.push("Prepared the local Haven tools acknowledgement.");
     } else {
-      const same = probe.delegateAddress?.toLowerCase() === localDelegate.toLowerCase();
-      checks.push({
-        id: "identity_match",
-        label: "Hosted identity matches the local signing key",
-        ok: same,
-        detail: same ? `The stored API key authenticates as the agent whose signing key is in this directory (${shortAddress(localDelegate)}).` : `MISMATCH: the stored API key authenticates as agent ${probe.agentId ?? "unknown"} with delegate ${shortAddress(probe.delegateAddress ?? "unknown")}, but signer.json here holds ${shortAddress(localDelegate)}. This runtime would quote as one agent and sign as another.`,
-        ...same ? {} : {
-          repair: `Re-run setup for this agent so its API key and signing key come from one run: ${RERUN} --setup <token>. Do not hand-edit either file.`
-        }
-      });
+      messages.push("Local Haven tools acknowledgement still needs attention.");
     }
+    return status;
   }
-  if (sidecar) {
-    const consent = await getLocalSignerConsentStatus(join(directory, "signer.json"));
-    if (!consent.acknowledged) {
-      checks.push({
-        id: "signer_process",
-        label: "Signer stdio handshake",
-        ok: false,
-        detail: "The local-tools consent is not acknowledged, so the signer refuses to start (by design).",
-        repair: `Run: ${RERUN} --ack-local-tools --setup <token>  (or re-run your original setup command with --ack-local-tools).`
-      });
+  return getLocalMcpConsentStatus(input.identityPath, input.signerPath);
+}
+async function resolveSignerConsent(input, messages) {
+  if (input.ackSigner || input.ackLocalTools) {
+    const status = await acknowledgeLocalSignerConsent(input.signerPath, (message) => messages.push(message));
+    if (status.acknowledged) {
+      messages.push("Prepared the local Haven signer acknowledgement.");
     } else {
-      const probe = await (deps.probeSignerTools ?? probeLocalMcpTools)(
-        sidecar.wrapper_path,
-        [],
-        MCP_RUNTIME_MANIFEST.requiredSignerTools
-      );
-      const experimental = probe.capabilities?.experimental ?? probe.capabilities;
-      const compat = experimental?.["haven/signer-compatibility"];
-      signerCapabilities = compat ? { "haven/signer-compatibility": compat } : void 0;
-      const compatDetail = compat ? ` Compat: x402 expected-context v${JSON.stringify(compat.x402_expected_context_versions ?? "?")}.` : "";
-      checks.push({
-        id: "signer_process",
-        label: "Signer stdio handshake",
-        ok: probe.status === "ok",
-        detail: probe.status === "ok" ? `Signer started, listed ${probe.toolNames?.length ?? 0} tools${probe.serverInfo?.version ? ` (v${probe.serverInfo.version})` : ""}.${compatDetail}` : `Handshake failed: ${probe.status}.`,
-        ...probe.status === "ok" ? {} : { repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}` }
-      });
+      messages.push("Local Haven signer acknowledgement still needs attention.");
     }
-  } else {
-    checks.push({
-      id: "signer_process",
-      label: "Signer stdio handshake",
-      ok: false,
-      detail: "Skipped \u2014 no prepared signer runtime to probe.",
-      repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}`
-    });
+    return status;
   }
-  return { checks, ...signerCapabilities ? { signerCapabilities } : {} };
+  return getLocalSignerConsentStatus(input.signerPath);
 }
-async function runDoctor(input, deps = {}) {
-  const homeDir = deps.homeDir ?? homedir();
-  const checks = [];
-  let signerCapabilities;
-  const { directory, others } = await discoverCredentialDirectory(homeDir, input.credentialsDir);
-  const configPath = runtimeConfigPathFor(input.runtime, homeDir);
-  let configText = null;
-  if (configPath !== null) {
-    try {
-      configText = await readFile(configPath, "utf8");
-    } catch {
-      configText = null;
-    }
+function signerConsentErrorCode(signerCredentialReady, signerConsent) {
+  if (!signerCredentialReady) return "local_signer_credential_unavailable";
+  if (!signerConsent?.acknowledged) return "local_signer_ack_required";
+  return void 0;
+}
+function signerProbeErrorCode(probe) {
+  if (!probe || probe.status === "ok") return void 0;
+  return `local_signer_probe_${probe.status}`;
+}
+function hostedMcpErrorCode(hostedConfigured, hostedProbeStatus) {
+  if (!hostedConfigured || hostedProbeStatus === "ok") return void 0;
+  return `hosted_mcp_probe_${hostedProbeStatus}`;
+}
+function localMcpErrorCode(signerCredentialReady, localMcpConsent, localMcpProbeStatus) {
+  if (!signerCredentialReady) return "local_signer_credential_unavailable";
+  if (!localMcpConsent?.acknowledged) return "local_mcp_ack_required";
+  if (localMcpProbeStatus && localMcpProbeStatus !== "ok") return `local_mcp_probe_${localMcpProbeStatus}`;
+  return void 0;
+}
+function nextAction(runtime, restartMode, errorCode) {
+  if (errorCode) return "return_to_haven_for_wallet_approval_then_finish_runtime_setup";
+  if (restartMode === "hot-reload") return "return_to_haven_for_wallet_approval";
+  if (runtime === "codex-cli" || runtime === "codex-desktop") return "return_to_haven_for_wallet_approval_then_restart_codex";
+  if (runtime === "claude-code") return "return_to_haven_for_wallet_approval_then_restart_claude_code";
+  if (restartMode === "restart-app") return "return_to_haven_for_wallet_approval_then_restart_app";
+  if (restartMode === "restart-session") return "return_to_haven_for_wallet_approval_then_restart_agent_session";
+  return "return_to_haven_for_wallet_approval_then_configure_runtime";
+}
+function supportsLocalMcp(runtime) {
+  return runtime === "codex-cli" || runtime === "codex-desktop" || runtime === "claude-code";
+}
+async function prepareRuntimeForLocalMcp(input, deps) {
+  const prepare = deps.prepareLocalMcpRuntime ?? ((runtimeInput) => prepareLocalMcpRuntime(runtimeInput, { runCommand: deps.runCommand, onProgress: deps.onProgress }));
+  return prepare({
+    credentialDirectory: input.credentialDirectory,
+    identityPath: input.identityPath,
+    signerPath: input.signerPath,
+    homeDir: deps.homeDir,
+    serverName: input.serverName
+  });
+}
+async function prepareSignerForRuntime(input, deps) {
+  const prepare = deps.prepareSignerRuntime ?? ((runtimeInput) => (
+    // onProgress threaded through on purpose (#1586 review): without it the
+    // install heartbeat was dead code in production and the console still
+    // went silent for the whole cold install — the exact symptom the issue
+    // set out to remove, at a longer timeout.
+    prepareSignerRuntime(runtimeInput, { runCommand: deps.runCommand, onProgress: deps.onProgress })
+  ));
+  return prepare({
+    credentialDirectory: input.credentialDirectory,
+    signerPath: input.signerPath,
+    homeDir: deps.homeDir,
+    serverName: input.serverName
+  });
+}
+async function runLocalMcpProbe(runtimeInstall, deps) {
+  const probe = deps.probeLocalMcpTools ?? probeLocalMcpTools;
+  try {
+    return await probe(runtimeInstall.command, runtimeInstall.args, MCP_RUNTIME_MANIFEST.requiredTools);
+  } catch {
+    return { status: "process_error" };
   }
-  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;
-    }
+}
+function localRuntimePrepareErrorCode(err) {
+  if (err && typeof err === "object" && "code" in err && err.code === "local_mcp_unsupported_node_version") {
+    return "local_mcp_unsupported_node_version";
   }
-  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);
-    if (!identity?.api_key) {
-      inventory.push({
-        ...slug ? { slug } : {},
-        ...tombstone?.agent_id ? { agentId: tombstone.agent_id } : {},
-        directory: dir,
-        classification: tombstone ? "retired" : "orphaned",
-        checks: []
-      });
-      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: []
-    };
-    if (wired) {
-      const result = await checksForAgent({ directory: dir, identity, sidecar }, input, deps);
-      entry.checks = result.checks;
-      capabilitiesByDirectory.set(dir, result.signerCapabilities);
-    }
-    inventory.push(entry);
+  return "local_mcp_runtime_install_failed";
+}
+var execFileAsync3;
+var init_runtime_install = __esm({
+  "src/runtime-install.ts"() {
+    init_config_writers();
+    init_server_names();
+    init_local_mcp_consent();
+    init_probes();
+    init_local_mcp_runtime();
+    init_signer_runtime();
+    init_runtime_manifest();
+    init_skill_install();
+    init_runtime_registry();
+    init_signer_consent();
+    execFileAsync3 = promisify(execFile);
   }
-  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);
+});
+
+// src/tombstone.ts
+var tombstone_exports = {};
+__export(tombstone_exports, {
+  TOMBSTONE_FILENAME: () => TOMBSTONE_FILENAME,
+  TOMBSTONE_MARKER: () => TOMBSTONE_MARKER,
+  readAgentTombstone: () => readAgentTombstone,
+  writeAgentTombstone: () => writeAgentTombstone
+});
+function tombstoneScript(info) {
+  const lines = [
+    `${TOMBSTONE_MARKER}: this Haven agent was retired.`,
+    "",
+    `  agent:      ${info.agent_id}`,
+    `  retired at: ${info.retired_at}`,
+    `  reason:     ${info.reason}`,
+    ...info.replaced_by ? [`  replaced by: ${info.replaced_by}`] : [],
+    "",
+    "This process is running with a wiring snapshot that predates the",
+    "retirement \u2014 it loaded its MCP config at startup and has kept it since.",
+    "Restart THIS host to pick up the current wiring. If several long-lived",
+    "hosts are running (a gateway, a TUI worker, an editor), restart EVERY",
+    "one of them: each holds the snapshot from its own start time, so after",
+    "a chain of recreations each can be parked on a DIFFERENT old agent.",
+    "",
+    "Then verify with: npx @haven_ai/connect@alpha --doctor --runtime <runtime>"
+  ];
+  return [
+    "#!/usr/bin/env node",
+    `// ${TOMBSTONE_MARKER} \u2014 written by @haven_ai/connect (#1681). Safe to delete`,
+    "// once every long-lived MCP host on this machine has been restarted.",
+    `process.stderr.write(${JSON.stringify(lines.join("\n") + "\n")})`,
+    "process.exit(1)",
+    ""
+  ].join("\n");
+}
+async function writeAgentTombstone(input) {
+  const dirStat = await stat(input.directory).catch(() => null);
+  if (!dirStat?.isDirectory()) {
+    throw new Error(`Not a directory: ${input.directory} \u2014 nothing to tombstone.`);
   }
-  if (!primaryDirectory) {
-    checks.push({
-      id: "credentials",
-      label: "Agent credentials",
-      ok: false,
-      detail: "No agent credential directory with an identity.json under ~/.haven/agents.",
-      repair: `Run the full setup once: ${RERUN} --setup <token from the Haven dashboard>.`
-    });
-  } else {
-    const primaryIdentity = await readIdentity(primaryDirectory);
-    const primarySidecar = await readRuntimeSidecar(primaryDirectory);
-    if (primaryChecksById.size === 0) {
-      const result = await checksForAgent(
-        { directory: primaryDirectory, identity: primaryIdentity, sidecar: primarySidecar },
-        input,
-        deps
-      );
-      signerCapabilities = result.signerCapabilities;
-      for (const check of result.checks) primaryChecksById.set(check.id, check);
-    }
-    for (const id of ["credentials", "signer_runtime"]) {
-      const check = primaryChecksById.get(id);
-      if (check) checks.push(check);
-    }
+  const info = {
+    // reason / replaced_by are persisted to disk and re-emitted to the host's
+    // MCP stderr log on EVERY stale probe, potentially for months — redact
+    // like every other output path, at the write layer so any future caller
+    // inherits it. (#1681 review, finding 1)
+    agent_id: input.agentId,
+    retired_at: input.retiredAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    reason: redactSecrets(input.reason),
+    ...input.replacedBy ? { replaced_by: redactSecrets(input.replacedBy) } : {}
+  };
+  const binDir = join(input.directory, "bin");
+  await mkdir(binDir, { recursive: true });
+  const wrapperPath = join(binDir, "haven-signer.mjs");
+  await writeFile(wrapperPath, tombstoneScript(info), "utf8");
+  await chmod(wrapperPath, 493);
+  await writeFile(join(input.directory, TOMBSTONE_FILENAME), JSON.stringify(info, null, 2) + "\n", "utf8");
+  return info;
+}
+async function readAgentTombstone(directory) {
+  try {
+    const parsed = JSON.parse(await readFile(join(directory, TOMBSTONE_FILENAME), "utf8"));
+    if (typeof parsed?.agent_id !== "string") return null;
+    return parsed;
+  } catch {
+    return null;
   }
-  if (configPath === null) {
-    checks.push({
-      id: "runtime_config",
-      label: "Runtime MCP config",
-      ok: true,
-      detail: `Runtime '${input.runtime}' has no file-based config the connector owns (CLI-managed) \u2014 skipping the file check.`
-    });
-  } else if (configText === null) {
-    checks.push({
-      id: "runtime_config",
-      label: "Runtime MCP config",
-      ok: false,
-      detail: `No runtime config at ${configPath}.`,
-      repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}`
-    });
-  } else {
-    const primaryIdentity = await readIdentity(primaryDirectory ?? "");
-    const primarySidecar = primaryDirectory ? await readRuntimeSidecar(primaryDirectory) : null;
-    const hasHaven = primaryIdentity?.hosted_mcp_url ? configText.includes(primaryIdentity.hosted_mcp_url) : configText.includes("haven");
-    const signerViaNpx = configText.includes("@haven_ai/signer");
-    const wrapperReferenced = primarySidecar ? configText.includes(primarySidecar.wrapper_path) : false;
-    const ok = hasHaven && !signerViaNpx && (primarySidecar ? wrapperReferenced : true);
-    checks.push({
-      id: "runtime_config",
-      label: "Runtime MCP config",
-      ok,
-      detail: ok ? `Config at ${configPath} references the hosted server and the prepared signer wrapper.` : signerViaNpx ? `Config at ${configPath} still launches the signer via npx \u2014 the pre-#1586 shape that cannot start under a 120s startup timeout.` : `Config at ${configPath} is missing the Haven entries${primarySidecar && !wrapperReferenced ? " (or references a different signer wrapper)" : ""}.`,
-      ...ok ? {} : { repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}` }
-    });
+}
+var TOMBSTONE_FILENAME, TOMBSTONE_MARKER;
+var init_tombstone = __esm({
+  "src/tombstone.ts"() {
+    init_redact();
+    TOMBSTONE_FILENAME = "TOMBSTONE.json";
+    TOMBSTONE_MARKER = "HAVEN-TOMBSTONE";
   }
-  for (const id of ["hosted_mcp", "identity_match"]) {
-    const check = primaryChecksById.get(id);
-    if (check) checks.push(check);
+});
+
+// src/rekey.ts
+var rekey_exports = {};
+__export(rekey_exports, {
+  finishRekey: () => finishRekey,
+  startRekey: () => startRekey
+});
+async function startRekey(options, deps = {}) {
+  const now = deps.now ?? (() => Date.now());
+  const stored = await readStoredCredentials(
+    options.serverName,
+    options.agentId,
+    options.credentialsDir
+  );
+  const api = (deps.createApi ?? ((url) => createConnectApiClient(url)))(stored.apiUrl);
+  const identity = await probeIdentity(api, stored.apiKey, "current");
+  assertRekeyable(identity, stored);
+  const key = (deps.generateKey ?? generateDelegateKey)();
+  const startedAt = new Date(now()).toISOString();
+  const expiresAt = new Date(now() + REKEY_PENDING_TTL_MS).toISOString();
+  await writeRekeyPending(stored.directory, {
+    agent_id: stored.agentId,
+    new_delegate_address: key.address,
+    new_delegate_key: key.privateKey,
+    started_at: startedAt,
+    expires_at: expiresAt
+  });
+  const finishCommand = [
+    "npx @haven_ai/connect@alpha --rekey-finish",
+    options.serverName ? `--name ${options.serverName}` : void 0,
+    "--api-key <the key the dashboard showed you>",
+    options.runtime ? `--runtime ${options.runtime}` : "--runtime <your runtime>"
+  ].filter(Boolean).join(" ");
+  return {
+    started: true,
+    agentId: stored.agentId,
+    directory: stored.directory,
+    newDelegateAddress: key.address,
+    expiresAt,
+    messages: [
+      `New signing key generated on this machine for agent ${identity.name || stored.agentId}.`,
+      "",
+      `  New signing address:  ${key.address}`,
+      "",
+      "The private half stays here \u2014 Haven never receives it, and there is no way to move it",
+      "between machines. That is what keeps the account non-custodial.",
+      "",
+      'Next, on the Haven agent page: choose "Replace signing key" and paste that address.',
+      "When it finishes it shows a new API key ONCE. Come back here and run:",
+      "",
+      `  ${finishCommand}`,
+      "",
+      `Nothing has changed yet \u2014 the agent keeps working on its old key until you finish.`,
+      `This pending re-key expires ${expiresAt}.`
+    ]
+  };
+}
+async function finishRekey(options, deps = {}) {
+  const now = deps.now ?? (() => Date.now());
+  if (!options.newApiKey) {
+    throw new Error("--rekey-finish needs --api-key <key> \u2014 the one the Haven agent page showed once.");
   }
-  const 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 = identity?.agent_id ?? tombstone?.agent_id ?? basename(entry.directory);
-      const otherUrl = identity?.hosted_mcp_url ?? (identity?.api_url ? `${identity.api_url}/mcp` : void 0);
-      if (!identity?.api_key || !otherUrl) {
-        if (tombstone) retired.push(`${otherAgent} (retired ${tombstone.retired_at})`);
-        else unverifiable.push(`${otherAgent} (no stored key/URL to probe)`);
-        continue;
-      }
-      const suffix = tombstone ? " [tombstoned \u2014 key material still present]" : "";
-      const probe = await (deps.probeHosted ?? probeHostedMcpTools)(identity.api_key, otherUrl, deps.fetch);
-      if (probe.status === "ok") live.push({ label: `${otherAgent}${suffix}`, entry });
-      else if (probe.status === "unauthorized") revoked.push(`${otherAgent}${suffix}`);
-      else unverifiable.push(`${otherAgent} (${probe.status})${suffix}`);
-    }
-    const parts = [];
-    if (live.length > 0) parts.push(`STILL SPEND-CAPABLE: ${live.map((item) => item.label).join(", ")}`);
-    if (revoked.length > 0) parts.push(`already revoked: ${revoked.join(", ")}`);
-    if (retired.length > 0) parts.push(`tombstoned (keys removed): ${retired.join(", ")}`);
-    if (unverifiable.length > 0) parts.push(`could not verify: ${unverifiable.join(", ")}`);
-    const supersededLive = live.filter((item) => item.entry.classification !== "wired").map((item) => item.label);
-    checks.push({
-      id: "superseded_agents",
-      label: "Superseded agent credentials",
-      ok: supersededLive.length === 0,
-      detail: supersededLive.length > 0 ? `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}. A host started before your latest setup keeps authenticating (and spending) as the old agent.` : `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}.`,
-      ...supersededLive.length > 0 ? {
-        repair: `Revoke ${supersededLive.join(", ")} on the Haven agent page, then remove the old director(y/ies) under ~/.haven/agents. Connect never revokes or deletes for you.`
-      } : {}
-    });
+  const 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 signerProcess = primaryChecksById.get("signer_process");
-  if (signerProcess) checks.push(signerProcess);
-  const restart = restartRequiredForRuntime(input.runtime, deps.env);
-  checks.push({
-    id: "restart",
-    label: "Runtime restart",
-    ok: true,
-    detail: restart ? "This runtime loads MCP config at startup \u2014 restart it after any repair before expecting the tools to appear." : "No restart requirement known for this runtime."
+  const api = (deps.createApi ?? ((url) => createConnectApiClient(url)))(stored.apiUrl);
+  const identity = await probeIdentity(api, options.newApiKey, "new");
+  if (identity.id !== stored.agentId) {
+    throw new Error(
+      `That API key belongs to agent ${identity.id}, not ${stored.agentId}. Nothing was changed.`
+    );
+  }
+  const onChain = (identity.delegate_address ?? "").toLowerCase();
+  const expected = pending.new_delegate_address.toLowerCase();
+  if (onChain !== expected) {
+    throw new Error(
+      `Haven says this agent's signing address is ${identity.delegate_address ?? "unset"}, but this machine generated ${pending.new_delegate_address}. Nothing was changed. Either the re-key on the agent page used a different address, or it has not finished yet.`
+    );
+  }
+  await rewriteCredentialFiles({
+    baseDir: options.credentialsDir,
+    agentId: stored.agentId,
+    serverName: options.serverName,
+    apiKey: options.newApiKey,
+    delegateKey: pending.new_delegate_key,
+    delegateAddress: pending.new_delegate_address,
+    safeAddress: stored.safeAddress ?? identity.safe_address ?? void 0,
+    chainId: stored.chainId ?? identity.chain_id ?? void 0,
+    network: stored.network,
+    agentBudget: stored.agentBudget,
+    apiUrl: stored.apiUrl,
+    hostedMcpUrl: stored.hostedMcpUrl,
+    x402BindingSigner: stored.x402BindingSigner,
+    warn: deps.log
   });
-  const wiredOk = inventory.filter((entry) => entry.classification === "wired").every((entry) => entry.checks.every((check) => check.ok));
+  await clearRekeyPending(stored.directory);
+  const names = serverNamesFor(options.serverName);
+  const messages = [
+    `Agent ${identity.name || stored.agentId} is now on its new signing key.`,
+    `  Signing address:  ${pending.new_delegate_address}`,
+    `  Credentials:      ${stored.directory} (rewritten in place)`,
+    `  MCP servers:      ${names.hosted} / ${names.signer} (unchanged names)`
+  ];
+  let configRewritten = false;
+  if (options.runtime) {
+    const prepared = await (deps.prepareSigner ?? prepareSignerRuntime)(
+      {
+        credentialDirectory: stored.directory,
+        signerPath: `${stored.directory}/signer.json`,
+        homeDir: options.homeDir
+      },
+      { runCommand: deps.runCommand }
+    );
+    const result = await (deps.writeConfig ?? writeHostedRuntimeConfig)(
+      { runCommand: deps.runCommand, homeDir: options.homeDir },
+      {
+        runtime: options.runtime,
+        hostedMcpUrl: stored.hostedMcpUrl,
+        apiKey: options.newApiKey,
+        identityPath: `${stored.directory}/identity.json`,
+        signerPath: `${stored.directory}/signer.json`,
+        credentialDirectory: stored.directory,
+        serverName: options.serverName
+      },
+      { command: prepared.command, args: prepared.args }
+    );
+    configRewritten = result.hostedConfigured;
+    messages.push(`  Config:           ${result.target}`);
+    messages.push(...result.messages.map((line) => `  ${line}`));
+    if (!configRewritten) {
+      messages.push(
+        "",
+        "WARNING: the MCP config was NOT updated, so it still carries the OLD API key and every",
+        `wired host will fail with 401. Fix the cause above and re-run with --runtime ${options.runtime},`,
+        "or update the config by hand. The credential files on disk are already on the new key."
+      );
+    }
+  } 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 {
-    version: 1,
-    ok: checks.every((check) => check.ok) && wiredOk,
-    runtime: input.runtime,
-    credentialDirectory: primaryDirectory,
-    checks,
-    agents: inventory,
-    ...signerCapabilities ? { signerCapabilities } : {}
+    finished: true,
+    agentId: stored.agentId,
+    directory: stored.directory,
+    newDelegateAddress: pending.new_delegate_address,
+    serverNames: { hosted: names.hosted, signer: names.signer },
+    configRewritten,
+    messages
   };
 }
-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.`);
+async function probeIdentity(api, apiKey, which) {
+  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."
+      );
+    }
+    throw new Error(
+      `Could not reach Haven to check this agent (${redactSecrets(
+        err instanceof Error ? err.message : String(err)
+      )}). Nothing was changed.`
+    );
   }
-  if (!directory) {
-    return {
-      ok: false,
-      messages: [`No agent credentials found to repair \u2014 run the full setup: ${RERUN} --setup <token>.`]
+}
+function assertRekeyable(identity, stored) {
+  if (identity.id !== stored.agentId) {
+    throw new Error(
+      `The credentials at ${stored.directory} say agent ${stored.agentId}, but Haven says that key belongs to ${identity.id}. Refusing to re-key an agent this directory does not own.`
+    );
+  }
+  if (identity.execution_rail === "legacy") {
+    throw new Error(
+      `Agent ${identity.name || identity.id} is on the legacy rail, which cannot be re-keyed \u2014 its authority is per-token Safe allowances, not a signed delegation there is anything to re-issue. Re-onboard the agent on the delegation rail instead.`
+    );
+  }
+  if (identity.status === "revoked") {
+    throw new Error(
+      `Agent ${identity.name || identity.id} is revoked. Re-keying would hand a revoked agent fresh credentials \u2014 create a new agent instead.`
+    );
+  }
+}
+var init_rekey = __esm({
+  "src/rekey.ts"() {
+    init_api();
+    init_runtime_install();
+    init_signer_runtime();
+    init_key();
+    init_redact();
+    init_server_names();
+    init_storage();
+  }
+});
+
+// src/rekey-restart.ts
+var rekey_restart_exports = {};
+__export(rekey_restart_exports, {
+  restartGuidance: () => restartGuidance
+});
+function restartGuidance(runtime) {
+  const profile = runtime ? BY_RUNTIME[runtime] : void 0;
+  const lines = ["The new key is only live in a process that started after now.", ""];
+  if (profile) {
+    lines.push(profile.how);
+    for (const command of profile.commands) lines.push(`    ${command}`);
+    if (profile.commands.length > 0) lines.push("");
+  } else {
+    lines.push(
+      runtime ? `No standard restart command is known for "${runtime}" \u2014 restart it the way you start it.` : "Pass --runtime <name> to get the restart command for a specific host."
+    );
+    lines.push("");
+  }
+  lines.push(SWEEP);
+  return { commands: profile?.commands ?? [], lines };
+}
+var SWEEP, BY_RUNTIME;
+var init_rekey_restart = __esm({
+  "src/rekey-restart.ts"() {
+    SWEEP = "Then restart EVERY other long-lived MCP host on this machine \u2014 gateways, TUI workers, editors. Each holds the wiring snapshot from its own start time, so after a re-key each one is still presenting the OLD API key and will fail with 401 until it restarts.";
+    BY_RUNTIME = {
+      "claude-code": {
+        commands: ["claude --continue"],
+        how: "Exit this Claude Code session and start a new one:"
+      },
+      "codex-cli": {
+        commands: ["codex resume --last"],
+        how: "Start a fresh Codex CLI session:"
+      },
+      "codex-desktop": {
+        commands: [],
+        how: "Quit Codex Desktop completely (not just the window) and reopen it."
+      },
+      "claude-desktop": {
+        commands: [],
+        how: "Quit Claude Desktop completely (not just the window) and reopen it."
+      },
+      hermes: {
+        commands: ["systemctl --user restart hermes-gateway", "/restart"],
+        how: "Restart the Hermes gateway, or run /restart inside a Hermes session. The first form is the one that matters if you run it as a user service:"
+      },
+      cursor: {
+        commands: [],
+        how: 'Cursor hot-reloads MCP config, so it will pick the new key up on its own. If a tool call still fails with 401, reload the window (Cmd/Ctrl+Shift+P \u2192 "Reload Window").'
+      },
+      vscode: {
+        commands: [],
+        how: 'VS Code hot-reloads MCP config. If a tool call still fails with 401, reload the window (Cmd/Ctrl+Shift+P \u2192 "Reload Window").'
+      },
+      "vscode-insiders": {
+        commands: [],
+        how: 'VS Code Insiders hot-reloads MCP config. If a tool call still fails with 401, reload the window (Cmd/Ctrl+Shift+P \u2192 "Reload Window").'
+      }
     };
   }
-  let identity;
+});
+
+// src/doctor.ts
+var doctor_exports = {};
+__export(doctor_exports, {
+  runDoctor: () => runDoctor,
+  runRepair: () => runRepair
+});
+async function discoverCredentialDirectory(homeDir, explicit) {
+  const root = explicit ? dirname(explicit) : join(homeDir, ".haven", "agents");
+  let entries = [];
   try {
-    identity = JSON.parse(await readFile(join(directory, "identity.json"), "utf8"));
+    entries = await readdir(root);
   } 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 explicit ? { directory: explicit, others: [], parkedOnly: /* @__PURE__ */ new Set() } : { others: [], parkedOnly: /* @__PURE__ */ new Set() };
   }
-  const configPath = runtimeConfigPathFor(input.runtime, homeDir);
-  if (configPath) {
+  const candidates = [];
+  const tombstonedOnly = [];
+  const parkedOnly = [];
+  for (const entry of entries) {
+    const directory = join(root, entry);
     try {
-      const existing = await readFile(configPath, "utf8");
-      if (existing.includes("bin/haven-mcp") || existing.includes(".haven/mcp-runtime")) {
-        return {
-          ok: false,
-          messages: [
-            `The config at ${configPath} is the LOCAL-stdio topology (--local). Repair currently rewrites only the hosted+signer shape and will not touch it.`,
-            "Re-run your original setup command (with --local) to repair a local-stdio install."
-          ]
-        };
-      }
+      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 signerPath = join(directory, "signer.json");
-  const prepared = await prepareSignerRuntime(
-    { credentialDirectory: directory, signerPath, homeDir },
-    { runCommand: deps.runCommand }
-  );
-  messages.push(...prepared.messages);
-  const configResult = await writeRuntimeConfig({
-    runtime: input.runtime,
-    hostedMcpUrl: identity.hosted_mcp_url ?? `${identity.api_url}/mcp`,
-    apiKey: identity.api_key,
-    identityPath: join(directory, "identity.json"),
-    signerPath,
-    credentialDirectory: directory,
-    signerCommand: { command: prepared.command, args: prepared.args },
-    homeDir,
-    mode: "hosted"
-  });
-  messages.push(...configResult.messages);
-  messages.push("Repair complete \u2014 restart the runtime, then verify with --doctor.");
-  return { ok: true, messages };
+  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 };
+  }
+  return {
+    directory: candidates[0]?.directory,
+    others: [...candidates.slice(1).map((c) => c.directory), ...tombstonedOnly, ...parkedOnly],
+    parkedOnly: parkedOnlySet
+  };
 }
-var RERUN;
-var init_doctor = __esm({
-  "src/doctor.ts"() {
-    init_runtime_manifest();
-    init_probes();
-    init_signer_runtime();
-    init_config_writers();
-    init_runtime_registry();
-    init_signer_consent();
-    init_tombstone();
-    init_server_names();
-    init_redact();
-    RERUN = "npx @haven_ai/connect@alpha";
+function agentIsWired(configText, names, slug, identity, sidecar, isPrimary, bareOwnerExists) {
+  if (configText === null) return isPrimary;
+  if (slug) {
+    for (const name of [names.hosted, names.codexHosted, names.signer, names.codexSigner]) {
+      if (new RegExp(`(^|[."'\\s\\[])${name}(["'\\]:\\s]|$)`, "m").test(configText)) return true;
+    }
+    return false;
+  }
+  if (sidecar?.wrapper_path && configText.includes(sidecar.wrapper_path)) return true;
+  if (bareOwnerExists) return false;
+  return isPrimary && Boolean(identity?.hosted_mcp_url && configText.includes(identity.hosted_mcp_url));
+}
+function rekeyPendingCheck(status, hostedDelegateAddress, runtime, slug) {
+  const label = "Pending re-key";
+  const nameFlag = slug ? ` --name ${slug}` : "";
+  if (status.state === "unreadable") {
+    return {
+      id: "rekey_pending",
+      label,
+      ok: false,
+      detail: `A re-key was started here but ${status.path} does not parse, so neither the address it generated nor when it started can be read. The file still holds what was a private key.`,
+      repair: `Delete ${status.path}, then start again: ${RERUN} --rekey${nameFlag}`
+    };
+  }
+  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,
+      ok: false,
+      detail: `A re-key started ${started} has COMPLETED on Haven \u2014 the agent's signing address is already ${address}, the one this machine generated \u2014 but the local half was never finished, so the credential files here still hold the old key. Parked at ${status.path}.` + (status.state === "expired" ? " The local file is also past its 24h TTL, which --rekey-finish refuses, so the finish command below will not accept it any more." : ""),
+      repair: status.state === "expired" ? `The parked key expired. Start again \u2014 ${RERUN} --rekey${nameFlag} \u2014 and re-run "Replace signing key" on the Haven agent page with the new address it prints.` : `Run: ${RERUN} --rekey-finish${nameFlag} --api-key <the key the agent page showed you> --runtime ${runtime}`
+    };
+  }
+  const wedgeNote = "Haven is NOT yet on this address, so the re-key did not complete. This machine cannot tell whether the on-chain revoke on the agent page already ran: if it did not, closing this costs nothing; if it did, the agent's old delegations are revoked, no new ones were issued, and only an owner re-grant restores its spend authority (#1868). Check the agent page before assuming the harmless case.";
+  if (status.state === "expired") {
+    return {
+      id: "rekey_pending",
+      label,
+      ok: false,
+      detail: `A re-key started ${started} EXPIRED ${status.expiresAt ?? ""} without being finished. Its address was ${address}; the private half it generated is still on disk at ${status.path}. ` + wedgeNote,
+      repair: `Either delete ${status.path} to drop the parked key, or start over: ${RERUN} --rekey${nameFlag}. Connect never deletes it for you \u2014 an expired TTL is a refusal to USE the key, not a licence to destroy key material you may still be mid-flow on.`
+    };
   }
-});
-
-// src/api.ts
-function createConnectApiClient(baseUrl, fetchImpl = fetch) {
-  const root = baseUrl.replace(/\/+$/, "");
   return {
-    resolveSetup: (input) => request(fetchImpl, `${root}/agent-connection-setups/resolve`, {
-      method: "POST",
-      body: JSON.stringify({
-        setup_token: input.setupToken,
-        connector_version: input.connectorVersion,
-        runtime: input.runtime
-      })
-    }),
-    registerSetup: (input) => request(fetchImpl, `${root}/agent-connection-setups/register`, {
-      method: "POST",
-      body: JSON.stringify({
-        setup_token: input.setupToken,
-        challenge_id: input.challengeId,
-        delegate_address: input.delegateAddress,
-        proof_signature: input.proofSignature,
-        api_key_hash: input.apiKeyHash,
-        api_key_prefix: input.apiKeyPrefix,
-        runtime: input.runtime,
-        connector_version: input.connectorVersion,
-        connector_context: input.connectorContext,
-        install_capabilities: input.installCapabilities && {
-          can_write_runtime_config: input.installCapabilities.canWriteRuntimeConfig,
-          restart_required: input.installCapabilities.restartRequired
-        }
-      })
-    }),
-    getConnectorStatus: (setupId, apiKey) => request(fetchImpl, `${root}/agent-connection-setups/${encodeURIComponent(setupId)}/connector-status`, {
-      method: "GET",
-      headers: { Authorization: `Bearer ${apiKey}` }
-    }),
-    updateInstallStatus: async (setupId, apiKey, input) => {
-      await request(fetchImpl, `${root}/agent-connection-setups/${encodeURIComponent(setupId)}/install-status`, {
-        method: "POST",
-        headers: { Authorization: `Bearer ${apiKey}` },
-        body: JSON.stringify({
-          runtime: input.runtime,
-          connector_version: input.connectorVersion,
-          runtime_mcp_mode: input.runtimeMcpMode,
-          hosted_mcp_configured: input.hostedMcpConfigured,
-          local_signer_configured: input.localSignerConfigured,
-          local_mcp_configured: input.localMcpConfigured,
-          credential_files_written: input.credentialFilesWritten,
-          signer_acknowledged: input.signerAcknowledged,
-          local_mcp_acknowledged: input.localMcpAcknowledged,
-          activation_command_available: input.activationCommandAvailable,
-          skill_installed: input.skillInstalled,
-          probe_result: input.probeResult,
-          restart_required: input.restartRequired,
-          next_user_action: input.nextUserAction,
-          error_code: input.errorCode ?? null,
-          environment_label: input.environmentLabel
-        })
-      });
-    }
-  };
-}
-var ConnectRequestError = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-    this.name = "ConnectRequestError";
-  }
-  status;
-};
-async function request(fetchImpl, url, init) {
-  const response = await fetchImpl(url, {
-    ...init,
-    headers: {
-      "Content-Type": "application/json",
-      ...init.headers ?? {}
-    }
-  });
-  const text = await response.text();
-  const body = text ? JSON.parse(text) : null;
-  if (!response.ok) {
-    const message = body?.error ?? body?.message ?? `${response.status} ${response.statusText}`;
-    throw new ConnectRequestError(`Haven setup request failed: ${message}`, response.status);
-  }
-  return body;
-}
-function generateDelegateKey() {
-  return delegateKeyFromPrivateKey(Wallet.createRandom().privateKey);
-}
-function delegateKeyFromPrivateKey(privateKey) {
-  const wallet = new Wallet(privateKey);
-  return {
-    privateKey: wallet.privateKey,
-    address: wallet.address,
-    signChallenge: (message) => wallet.signMessage(message)
+    id: "rekey_pending",
+    label,
+    ok: true,
+    detail: `A re-key started ${started} is still open (expires ${status.expiresAt ?? "unknown"}). Paste this address into "Replace signing key" on the Haven agent page: ${address}. Parked at ${status.path}. ` + wedgeNote
   };
 }
-function generateAgentApiKey() {
-  return `sk_agent_${crypto.randomBytes(24).toString("hex")}`;
-}
-function hashAgentApiKey(apiKey) {
-  return crypto.createHash("sha256").update(apiKey).digest("hex");
-}
-function agentApiKeyPrefix(apiKey) {
-  return apiKey.slice(0, 12);
-}
-
-// src/runtime.ts
-init_redact();
-init_server_names();
-async function preflightCredentialStorage(input = {}) {
-  const directory = defaultCredentialRoot(input.baseDir);
-  await mkdir(directory, { recursive: true, mode: 448 });
-  await restrictPermissions(directory, 448, input.warn);
-  const probePath = join(directory, `.haven-connect-preflight-${crypto.randomBytes(8).toString("hex")}`);
-  try {
-    await writeOwnerOnlyJson(probePath, { ok: true }, input.warn);
-  } finally {
-    await rm(probePath, { force: true }).catch(() => void 0);
-  }
-  return directory;
-}
-async function writeCredentialFiles(input) {
-  const directory = defaultAgentDirectory(input.serverName ?? input.agentId, input.baseDir);
-  await mkdir(directory, { recursive: true, mode: 448 });
-  await restrictPermissions(directory, 448, input.warn);
-  const identityPath = join(directory, "identity.json");
-  const signerPath = join(directory, "signer.json");
-  const agentPath = join(directory, "agent.json");
-  await assertDoesNotExist(identityPath);
-  await assertDoesNotExist(signerPath);
-  await assertDoesNotExist(agentPath);
-  await writeOwnerOnlyJson(
-    signerPath,
-    {
-      delegate_key: input.delegateKey,
-      delegate_address: input.delegateAddress,
-      agent_id: input.agentId,
-      safe_address: input.safeAddress,
-      chain_id: input.chainId,
-      network: input.network,
-      x402_binding_signer: input.x402BindingSigner,
-      note: "Local signer credential. Haven backend never receives this private key."
-    },
-    input.warn
-  );
-  try {
-    await writeOwnerOnlyJson(
-      identityPath,
-      {
-        api_key: input.apiKey,
-        agent_id: input.agentId,
-        safe_address: input.safeAddress,
-        chain_id: input.chainId,
-        network: input.network,
-        api_url: input.apiUrl,
-        hosted_mcp_url: input.hostedMcpUrl,
-        agent_budget: input.agentBudget,
-        note: "Haven API key identifies the agent only. It cannot spend without the local signer key and on-chain Haven wallet rules."
-      },
-      input.warn
-    );
-  } catch (err) {
-    await rm(signerPath, { force: true }).catch(() => void 0);
-    throw err;
-  }
-  try {
-    await writeOwnerOnlyJson(
-      agentPath,
-      {
-        agent_id: input.agentId,
-        delegate_address: input.delegateAddress,
-        safe_address: input.safeAddress,
-        chain_id: input.chainId,
-        network: input.network,
-        agent_budget: input.agentBudget,
-        note: "Non-secret orientation for the agent: public delegate/Haven wallet identity + configured budget. Contains no API key or signing key. For the live remaining budget, call haven_get_allowances."
-      },
-      input.warn
-    );
-  } catch (err) {
-    await rm(signerPath, { force: true }).catch(() => void 0);
-    await rm(identityPath, { force: true }).catch(() => void 0);
-    await rm(agentPath, { force: true }).catch(() => void 0);
-    throw err;
-  }
-  return { directory, identityPath, signerPath, agentPath };
-}
-async function assertServerSlugAvailable(serverName, baseDir) {
-  const directory = defaultAgentDirectory(serverName, baseDir);
+async function readIdentity(directory) {
   try {
-    await stat(join(directory, "identity.json"));
+    return JSON.parse(await readFile(join(directory, "identity.json"), "utf8"));
   } catch {
-    return;
+    return void 0;
   }
-  throw new Error(
-    `The name "${serverName}" is already wired on this machine (${directory} holds credentials). Pick a different --name, or revoke and remove that agent first \u2014 connect never overwrites credentials.`
-  );
-}
-function defaultAgentDirectory(agentId, baseDir = join(homedir(), ".haven", "agents")) {
-  return resolve(defaultCredentialRoot(baseDir), safePathPart(agentId));
-}
-function defaultCredentialRoot(baseDir = join(homedir(), ".haven", "agents")) {
-  return resolve(baseDir);
-}
-async function writeOwnerOnlyJson(path, value, warn) {
-  const json = JSON.stringify(dropUndefined(value), null, 2);
-  await writeFile(path, `${json}
-`, { mode: 384, flag: "wx" });
-  await restrictPermissions(path, 384, warn);
-}
-function safePathPart(value) {
-  return value.replace(/[^A-Za-z0-9_.-]/g, "_");
-}
-function dropUndefined(value) {
-  return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== void 0));
 }
-async function assertDoesNotExist(path) {
+async function checksForAgent(entry, input, deps) {
+  const { directory, identity, sidecar } = entry;
+  const checks = [];
+  let signerCapabilities;
+  let signerFile;
   try {
-    await access(path);
-  } catch (err) {
-    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") return;
-    throw err;
+    const parsed = JSON.parse(await readFile(join(directory, "signer.json"), "utf8"));
+    signerFile = typeof parsed === "object" && parsed !== null ? parsed : void 0;
+  } catch {
+    signerFile = void 0;
   }
-  throw new Error(`Refusing to overwrite existing Haven credential file: ${path}`);
-}
-async function restrictPermissions(path, mode, warn) {
-  try {
-    await chmod(path, mode);
-  } catch (err) {
-    warn?.(
-      `Warning: could not restrict permissions on ${path} to ${mode.toString(8)}. Move this credential to a private location or run chmod ${mode.toString(8)} ${path}. ${err instanceof Error ? err.message : String(err)}`
-    );
+  const credentialsOk = Boolean(identity?.api_key) && signerFile !== void 0;
+  checks.push({
+    id: "credentials",
+    label: "Agent credentials",
+    ok: credentialsOk,
+    detail: credentialsOk ? `identity.json and signer.json parse (agent ${identity?.agent_id ?? "unknown"})` : "identity.json or signer.json is missing or unparseable.",
+    ...credentialsOk ? {} : { repair: `Re-run the full setup with a fresh token: ${RERUN} --setup <token>.` }
+  });
+  if (!sidecar) {
+    checks.push({
+      id: "signer_runtime",
+      label: "Signer runtime (preinstalled wrapper)",
+      ok: false,
+      detail: "No signer-runtime.json sidecar \u2014 the pinned signer runtime was never prepared (or a pre-#1586 npx config).",
+      repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}`
+    });
+  } else {
+    const matches = await installedRuntimeMatches(sidecar.runtime_directory, sidecar.cli_path);
+    const versionOk = sidecar.signer_version === MCP_RUNTIME_MANIFEST.signerVersion;
+    const ok = matches && versionOk;
+    checks.push({
+      id: "signer_runtime",
+      label: "Signer runtime (preinstalled wrapper)",
+      ok,
+      detail: ok ? `Installed ${sidecar.signer_package}@${sidecar.signer_version} at ${sidecar.runtime_directory}` : matches ? `Installed version ${sidecar.signer_version} does not match the connector's pinned ${MCP_RUNTIME_MANIFEST.signerVersion}.` : `Runtime directory is stale or empty (${sidecar.runtime_directory}) \u2014 the CLI or package versions are missing.`,
+      ...ok ? {} : { repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}` }
+    });
   }
-}
-
-// src/runtime-install.ts
-init_config_writers();
-init_server_names();
-async function acknowledgeLocalMcpConsent(identityPath, signerPath, log) {
-  try {
-    const input = await buildLocalMcpConsentInput(identityPath, signerPath);
-    const decision = await ensureConsent(input, {
-      credentialsPath: identityPath,
-      writeAck: true,
-      out: log ? { write: (chunk) => writeLogChunk(log, chunk) } : void 0
+  const hostedUrl = identity?.hosted_mcp_url ?? (identity?.api_url ? `${identity.api_url}/mcp` : void 0);
+  if (identity?.api_key && hostedUrl) {
+    const probe = await (deps.probeHosted ?? probeHostedMcpTools)(identity.api_key, hostedUrl, deps.fetch);
+    checks.push({
+      id: "hosted_mcp",
+      label: "Hosted Haven MCP",
+      ok: probe.status === "ok",
+      detail: probe.status === "ok" ? `Reachable and authorized (${hostedUrl}).` : `Probe failed: ${probe.status} (${hostedUrl}).`,
+      ...probe.status === "ok" ? {} : {
+        repair: probe.status === "unauthorized" ? `The stored API key was rejected \u2014 re-run the full setup with a fresh token: ${RERUN} --setup <token>.` : "Check network access to the hosted MCP URL, then re-run --doctor."
+      }
+    });
+  } else {
+    checks.push({
+      id: "hosted_mcp",
+      label: "Hosted Haven MCP",
+      ok: false,
+      detail: "No stored API key / hosted MCP URL to probe with.",
+      repair: `Re-run the full setup: ${RERUN} --setup <token>.`
     });
-    return {
-      acknowledged: decision.ok,
-      hash: decision.hash,
-      reason: decision.reason
-    };
-  } catch (err) {
-    return {
-      acknowledged: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
   }
-}
-async function getLocalMcpConsentStatus(identityPath, signerPath) {
-  try {
-    const input = await buildLocalMcpConsentInput(identityPath, signerPath);
-    const hash = computeConsentHash(input);
-    const stored = await readLocalMcpAckFile(localMcpAckPath(identityPath));
-    if (stored === hash) {
-      return { acknowledged: true, hash, reason: "ack_file_match" };
-    }
-    return {
-      acknowledged: false,
-      hash,
-      reason: stored ? "ack_file_mismatch" : "ack_file_missing"
-    };
-  } catch (err) {
-    return {
-      acknowledged: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
-}
-function localMcpAckPath(identityPath) {
-  return resolve(`${identityPath}.ack.json`);
-}
-async function buildLocalMcpConsentInput(identityPath, signerPath) {
-  const credentials = await loadCredentials({ identityPath, signerPath });
-  const unavailableDuringSetup = {
-    getAllowances: async () => {
-      throw new Error("Haven approval is not complete yet.");
+  const localDelegate = typeof signerFile?.delegate_address === "string" ? signerFile.delegate_address : void 0;
+  let hostedDelegateAddress;
+  if (identity?.api_key && identity.api_url) {
+    const probe = await (deps.probeHostedIdentity ?? probeHostedAgentIdentity)(
+      identity.api_key,
+      identity.api_url,
+      deps.fetch
+    );
+    if (probe.status === "ok") hostedDelegateAddress = probe.delegateAddress;
+    if (probe.status !== "ok") {
+      checks.push({
+        id: "identity_match",
+        label: "Hosted identity matches the local signing key",
+        ok: false,
+        detail: probe.status === "unauthorized" ? "The stored API key was rejected, so the agent it authenticates as cannot be compared with the local signing key." : `Could not read the hosted identity (${probe.status}) \u2014 the comparison did not happen, so it cannot be reported as a match.`,
+        repair: probe.status === "unauthorized" ? `Re-run the full setup with a fresh token: ${RERUN} --setup <token>.` : `Restore network access to the Haven API, then re-run: ${RERUN} --doctor --runtime ${input.runtime}`
+      });
+    } else if (!localDelegate) {
+      checks.push({
+        id: "identity_match",
+        label: "Hosted identity matches the local signing key",
+        ok: false,
+        detail: "signer.json holds no delegate_address to compare against the hosted identity.",
+        repair: `Re-run the full setup with a fresh token: ${RERUN} --setup <token>.`
+      });
+    } else {
+      const same = probe.delegateAddress?.toLowerCase() === localDelegate.toLowerCase();
+      checks.push({
+        id: "identity_match",
+        label: "Hosted identity matches the local signing key",
+        ok: same,
+        detail: same ? `The stored API key authenticates as the agent whose signing key is in this directory (${shortAddress(localDelegate)}).` : `MISMATCH: the stored API key authenticates as agent ${probe.agentId ?? "unknown"} with delegate ${shortAddress(probe.delegateAddress ?? "unknown")}, but signer.json here holds ${shortAddress(localDelegate)}. This runtime would quote as one agent and sign as another.`,
+        ...same ? {} : {
+          repair: `Re-run setup for this agent so its API key and signing key come from one run: ${RERUN} --setup <token>. Do not hand-edit either file.`
+        }
+      });
     }
-  };
-  return consentInputFromClient(
-    unavailableDuringSetup,
-    {
-      apiKey: credentials.apiKey,
-      apiUrl: credentials.apiUrl,
-      agentId: credentials.agentId,
-      safeAddress: credentials.safeAddress,
-      delegateAddress: credentials.delegateAddress,
-      chainId: credentials.chainId,
-      allowanceSummary: credentials.allowanceSummary
-    },
-    registeredToolNames()
-  );
-}
-async function readLocalMcpAckFile(path) {
-  try {
-    const parsed = JSON.parse(await readFile(path, "utf8"));
-    return typeof parsed.ack === "string" ? parsed.ack : null;
-  } catch {
-    return null;
   }
-}
-function writeLogChunk(log, chunk) {
-  const message = String(chunk).trimEnd();
-  if (message) log(message);
-}
-
-// src/runtime-install.ts
-init_probes();
-
-// src/local-mcp-runtime.ts
-init_signer_runtime();
-init_runtime_manifest();
-var execFileAsync2 = promisify(execFile);
-var UnsupportedNodeVersionError = class extends Error {
-  code = "local_mcp_unsupported_node_version";
-  nodeVersion;
-  minimumNodeVersion;
-  constructor(nodeVersion, minimumNodeVersion, subject = "Haven setup") {
-    super(unsupportedNodeVersionMessage({ subject, nodeVersion, minimumNodeVersion }));
-    this.name = "UnsupportedNodeVersionError";
-    this.nodeVersion = nodeVersion;
-    this.minimumNodeVersion = minimumNodeVersion;
+  const pending = await inspectRekeyPending(directory, deps.now?.() ?? Date.now());
+  if (pending) {
+    checks.push(rekeyPendingCheck(pending, hostedDelegateAddress, input.runtime, sidecar?.server_name));
   }
-};
-async function prepareLocalMcpRuntime(input, deps = {}) {
-  assertSupportedNodeVersion(input.nodeVersion);
-  const homeDir = input.homeDir ?? homedir();
-  const runtimeDirectory = resolve(homeDir, ".haven", "mcp-runtime", MCP_RUNTIME_MANIFEST.mcpVersion);
-  const npmCacheDirectory = resolve(homeDir, ".haven", "npm-cache");
-  const cliPath = join(runtimeDirectory, "node_modules", "@haven_ai", "mcp", "dist", "cli.js");
-  const messages = [];
-  await mkdir(runtimeDirectory, { recursive: true, mode: 448 });
-  await chmod(runtimeDirectory, 448).catch(() => void 0);
-  await mkdir(npmCacheDirectory, { recursive: true, mode: 448 });
-  await chmod(npmCacheDirectory, 448).catch(() => void 0);
-  if (await installedRuntimeMatches2(runtimeDirectory, cliPath)) {
-    messages.push(`Using existing local Haven MCP runtime ${mcpPackageSpec()}.`);
+  if (sidecar) {
+    const consent = await getLocalSignerConsentStatus(join(directory, "signer.json"));
+    if (!consent.acknowledged) {
+      checks.push({
+        id: "signer_process",
+        label: "Signer stdio handshake",
+        ok: false,
+        detail: "The local-tools consent is not acknowledged, so the signer refuses to start (by design).",
+        repair: `Run: ${RERUN} --ack-local-tools --setup <token>  (or re-run your original setup command with --ack-local-tools).`
+      });
+    } else {
+      const probe = await (deps.probeSignerTools ?? probeLocalMcpTools)(
+        sidecar.wrapper_path,
+        [],
+        MCP_RUNTIME_MANIFEST.requiredSignerTools
+      );
+      const experimental = probe.capabilities?.experimental ?? probe.capabilities;
+      const compat = experimental?.["haven/signer-compatibility"];
+      signerCapabilities = compat ? { "haven/signer-compatibility": compat } : void 0;
+      const compatDetail = compat ? ` Compat: x402 expected-context v${JSON.stringify(compat.x402_expected_context_versions ?? "?")}.` : "";
+      checks.push({
+        id: "signer_process",
+        label: "Signer stdio handshake",
+        ok: probe.status === "ok",
+        detail: probe.status === "ok" ? `Signer started, listed ${probe.toolNames?.length ?? 0} tools${probe.serverInfo?.version ? ` (v${probe.serverInfo.version})` : ""}.${compatDetail}` : `Handshake failed: ${probe.status}.`,
+        ...probe.status === "ok" ? {} : { repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}` }
+      });
+    }
   } else {
-    await installRuntimePackages2(runtimeDirectory, npmCacheDirectory, deps);
-    messages.push(`Installed local Haven MCP runtime ${mcpPackageSpec()}.`);
-  }
-  await assertFileExists2(cliPath, "local Haven MCP CLI");
-  const wrapperPath = join(input.credentialDirectory, "bin", "haven-mcp");
-  await writeWrapper2({
-    wrapperPath,
-    cliPath,
-    identityPath: input.identityPath,
-    signerPath: input.signerPath
-  });
-  await writeRuntimeSidecar2({
-    path: join(input.credentialDirectory, "mcp-runtime.json"),
-    wrapperPath,
-    runtimeDirectory,
-    npmCacheDirectory,
-    cliPath,
-    serverName: input.serverName
-  });
-  messages.push(`Prepared stable local Haven MCP wrapper: ${wrapperPath}`);
-  return {
-    command: wrapperPath,
-    args: [],
-    wrapperPath,
-    runtimeDirectory,
-    npmCacheDirectory,
-    cliPath,
-    messages
-  };
-}
-function assertSupportedNodeVersion(nodeVersion = process.versions.node, minimumNodeVersion = MCP_RUNTIME_MANIFEST.minimumNodeVersion, subject = "Haven setup") {
-  if (!isSupportedNodeVersion(nodeVersion, minimumNodeVersion)) {
-    throw new UnsupportedNodeVersionError(nodeVersion, minimumNodeVersion, subject);
+    checks.push({
+      id: "signer_process",
+      label: "Signer stdio handshake",
+      ok: false,
+      detail: "Skipped \u2014 no prepared signer runtime to probe.",
+      repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}`
+    });
   }
+  return { checks, ...signerCapabilities ? { signerCapabilities } : {} };
 }
-async function installRuntimePackages2(runtimeDirectory, npmCacheDirectory, deps) {
-  const { runCommand, onProgress } = deps;
-  const baseArgs = [
-    "install",
-    "--prefix",
-    runtimeDirectory,
-    "--no-audit",
-    "--no-fund",
-    "--omit=dev",
-    "--prefer-offline",
-    mcpPackageSpec(),
-    sdkPackageSpec()
-  ];
-  const run = async (args) => {
-    const startedAt = Date.now();
-    const heartbeat = setInterval(() => {
-      const seconds = Math.round((Date.now() - startedAt) / 1e3);
-      onProgress?.(`Still installing the local Haven MCP runtime\u2026 (${seconds}s \u2014 a cold cache can take several minutes)`);
-    }, SIGNER_INSTALL_HEARTBEAT_MS);
-    heartbeat.unref?.();
-    try {
-      if (runCommand) await runCommand("npm", args);
-      else await execFileAsync2("npm", args, { timeout: SIGNER_INSTALL_TIMEOUT_MS, maxBuffer: 1024 * 1024 });
-    } finally {
-      clearInterval(heartbeat);
-    }
-  };
-  try {
-    await run(baseArgs);
-  } catch {
+async function runDoctor(input, deps = {}) {
+  const homeDir = deps.homeDir ?? homedir();
+  const checks = [];
+  let signerCapabilities;
+  const { directory, others, parkedOnly } = await discoverCredentialDirectory(homeDir, input.credentialsDir);
+  const configPath = runtimeConfigPathFor(input.runtime, homeDir);
+  let configText = null;
+  if (configPath !== null) {
     try {
-      await run([...baseArgs, "--cache", npmCacheDirectory]);
-    } catch (err) {
-      throw new Error(`Could not install local Haven MCP runtime ${mcpPackageSpec()}: ${err instanceof Error ? err.message : String(err)}`);
+      configText = await readFile(configPath, "utf8");
+    } catch {
+      configText = null;
     }
   }
-}
-async function installedRuntimeMatches2(runtimeDirectory, cliPath) {
-  try {
-    await assertFileExists2(cliPath, "local Haven MCP CLI");
-    const [mcpPackage, sdkPackage] = await Promise.all([
-      readPackageJson2(join(runtimeDirectory, "node_modules", "@haven_ai", "mcp", "package.json")),
-      readPackageJson2(join(runtimeDirectory, "node_modules", "@haven_ai", "sdk", "package.json"))
-    ]);
-    return mcpPackage.version === MCP_RUNTIME_MANIFEST.mcpVersion && sdkPackage.version === MCP_RUNTIME_MANIFEST.sdkVersion;
-  } catch {
-    return false;
+  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;
+    }
   }
-}
-async function readPackageJson2(path) {
-  return JSON.parse(await readFile(path, "utf8"));
-}
-async function writeWrapper2(input) {
-  await mkdir(dirname(input.wrapperPath), { recursive: true, mode: 448 });
-  await chmod(dirname(input.wrapperPath), 448).catch(() => void 0);
-  const source = [
-    "#!/usr/bin/env node",
-    "import { spawn } from 'node:child_process'",
-    "",
-    `const cliPath = ${JSON.stringify(input.cliPath)}`,
-    `const identityPath = ${JSON.stringify(input.identityPath)}`,
-    `const signerPath = ${JSON.stringify(input.signerPath)}`,
-    "",
-    "const child = spawn(process.execPath, [cliPath, '--identity', identityPath, '--signer', signerPath, ...process.argv.slice(2)], {",
-    "  stdio: 'inherit',",
-    "})",
-    "",
-    "child.on('exit', (code, signal) => {",
-    "  if (signal) process.kill(process.pid, signal)",
-    "  else process.exit(code ?? 1)",
-    "})",
-    ""
-  ].join("\n");
-  await writeFile(input.wrapperPath, source, { mode: 448 });
-  await chmod(input.wrapperPath, 448).catch(() => void 0);
-}
-async function writeRuntimeSidecar2(input) {
-  const value = {
-    ...input.serverName ? { server_name: input.serverName } : {},
-    mcp_package: MCP_RUNTIME_MANIFEST.mcpPackage,
-    mcp_version: MCP_RUNTIME_MANIFEST.mcpVersion,
-    sdk_package: MCP_RUNTIME_MANIFEST.sdkPackage,
-    sdk_version: MCP_RUNTIME_MANIFEST.sdkVersion,
-    minimum_node_version: MCP_RUNTIME_MANIFEST.minimumNodeVersion,
-    wrapper_path: input.wrapperPath,
-    runtime_directory: input.runtimeDirectory,
-    npm_cache_directory: input.npmCacheDirectory,
-    cli_path: input.cliPath
-  };
-  await writeFile(input.path, `${JSON.stringify(value, null, 2)}
-`, { mode: 384 });
-  await chmod(input.path, 384).catch(() => void 0);
-}
-async function assertFileExists2(path, label) {
-  try {
-    await access(path);
-  } catch {
-    throw new Error(`Missing ${label}: ${path}`);
-  }
-}
-
-// src/runtime-install.ts
-init_signer_runtime();
-init_runtime_manifest();
-var CODEX_AGENTS_BEGIN_MARKER = "<!-- BEGIN haven-pay (managed by @haven_ai/connect; edits inside this section are overwritten on re-setup) -->";
-var CODEX_AGENTS_END_MARKER = "<!-- END haven-pay -->";
-async function installSkillForRuntime(runtime, deps = {}) {
-  switch (runtime) {
-    case "claude-code":
-      return installSkillFile(
-        resolve(deps.homeDir ?? homedir(), ".claude", "skills", SKILL_FOLDER_NAME),
-        "~/.claude/skills/haven-pay"
-      );
-    case "hermes":
-      return installSkillFile(
-        join(hermesHome(deps), "skills", SKILL_FOLDER_NAME),
-        "the Hermes skills folder"
-      );
-    case "codex-cli":
-    case "codex-desktop":
-      return installCodexAgentsSection(deps);
-    default:
-      return void 0;
-  }
-}
-async function installSkillFile(skillDir, label) {
-  try {
-    await mkdir(skillDir, { recursive: true });
-    const target = join(skillDir, "SKILL.md");
-    await writeFile(target, HAVEN_SKILL_MD, "utf8");
-    return {
-      installed: true,
-      target,
-      messages: [`Installed the generic Haven payment skill (${label}). It contains no secrets.`]
-    };
-  } catch (err) {
-    return {
-      installed: false,
-      messages: [
-        `Could not install the Haven payment skill: ${err instanceof Error ? err.message : String(err)}. Download it from the Haven dashboard instead.`
-      ]
-    };
-  }
-}
-async function installCodexAgentsSection(deps) {
-  try {
-    const codexDir = resolve(deps.homeDir ?? homedir(), ".codex");
-    const target = join(codexDir, "AGENTS.md");
-    await mkdir(codexDir, { recursive: true });
-    const existing = await readFile(target, "utf8").catch(() => null);
-    const next = upsertManagedSection(existing, codexManagedSection());
-    if (next !== existing) {
-      await writeFile(target, next, "utf8");
+  const inventory = [];
+  const capabilitiesByDirectory = /* @__PURE__ */ new Map();
+  const primaryChecksById = /* @__PURE__ */ new Map();
+  for (const dir of allDirectories) {
+    const identity = await readIdentity(dir);
+    const sidecar = await readRuntimeSidecar(dir);
+    const tombstone = await readAgentTombstone(dir);
+    const slug = sidecar?.server_name;
+    const names = serverNamesFor(slug);
+    const rekeyPending = await inspectRekeyPending(dir, deps.now?.() ?? Date.now());
+    if (!identity?.api_key) {
+      const agentId = tombstone?.agent_id ?? rekeyPending?.agentId;
+      inventory.push({
+        ...slug ? { slug } : {},
+        ...agentId ? { agentId } : {},
+        directory: dir,
+        // A tombstone is a deliberate record and outranks the discovery tell:
+        // a retired directory that also holds a parked key stays `retired`.
+        classification: tombstone ? "retired" : parkedOnly.has(dir) ? "parked" : "orphaned",
+        checks: rekeyPending ? [rekeyPendingCheck(rekeyPending, void 0, input.runtime, slug)] : [],
+        ...rekeyPending ? { rekeyPending } : {}
+      });
+      continue;
     }
-    return {
-      installed: true,
-      target,
-      messages: [
-        "Installed the generic Haven payment guidance as a managed section in ~/.codex/AGENTS.md (Codex reads it as global instructions). It contains no secrets; your own content in that file is untouched."
-      ]
-    };
-  } catch (err) {
-    return {
-      installed: false,
-      messages: [
-        `Could not install the Haven payment guidance into ~/.codex/AGENTS.md: ${err instanceof Error ? err.message : String(err)}. Download the skill from the Haven dashboard instead.`
-      ]
-    };
-  }
-}
-function codexManagedSection() {
-  return `${CODEX_AGENTS_BEGIN_MARKER}
-
-${HAVEN_SKILL_BODY_MD.trimEnd()}
-
-${CODEX_AGENTS_END_MARKER}
-`;
-}
-function upsertManagedSection(existing, section) {
-  if (existing === null || existing.trim() === "") return section;
-  const begins = markerLineIndexes(existing, CODEX_AGENTS_BEGIN_MARKER);
-  const ends = markerLineIndexes(existing, CODEX_AGENTS_END_MARKER);
-  if (begins.length === 1 && ends.length === 1 && ends[0] > begins[0]) {
-    const afterEnd = ends[0] + CODEX_AGENTS_END_MARKER.length;
-    const tail = existing.startsWith("\r\n", afterEnd) ? existing.slice(afterEnd + 2) : existing.startsWith("\n", afterEnd) ? existing.slice(afterEnd + 1) : existing.slice(afterEnd);
-    return existing.slice(0, begins[0]) + section + tail;
-  }
-  if (begins.length > 0 || ends.length > 0) {
-    throw new Error(
-      "found a damaged Haven marker section (orphaned or duplicated markers); remove the leftover marker lines and re-run setup"
-    );
-  }
-  return `${existing.replace(/\n*$/, "\n\n")}${section}`;
-}
-function markerLineIndexes(text, marker) {
-  const indexes = [];
-  for (let from = 0; ; ) {
-    const at = text.indexOf(marker, from);
-    if (at === -1) return indexes;
-    if (at === 0 || text[at - 1] === "\n") indexes.push(at);
-    from = at + marker.length;
-  }
-}
-function hermesHome(deps) {
-  const env = deps.env ?? process.env;
-  return env.HERMES_HOME ?? join(deps.homeDir ?? homedir(), ".hermes");
-}
-
-// src/runtime-install.ts
-init_runtime_registry();
-init_signer_consent();
-var execFileAsync3 = promisify(execFile);
-async function installRuntime(input, deps = {}) {
-  const runtime = normalizeRuntime(input.runtime, deps.env);
-  const profile = runtimeProfile(runtime, deps.env);
-  const progress = deps.onProgress ?? (() => void 0);
-  const localRuntime = input.localMcp === true && supportsLocalMcp(runtime);
-  const consentMessages = [];
-  const localMcpConsent = localRuntime ? await resolveLocalMcpConsent(input, consentMessages) : void 0;
-  const signerConsent = localRuntime ? void 0 : await resolveSignerConsent(input, consentMessages);
-  if (runtime === "other") {
-    const signerCredentialReady2 = await probeLocalSignerCredential(input.signerPath);
-    const signerReady = signerCredentialReady2 && signerConsent?.acknowledged;
-    return {
-      runtime,
-      runtimeMcpMode: "manual",
-      hostedMcpConfigured: false,
-      localSignerConfigured: false,
-      localMcpConfigured: false,
-      probeResult: signerReady ? "manual_runtime_setup_required_local_signer_ready" : "manual_runtime_setup_required_local_signer_unavailable",
-      restartRequired: true,
-      nextUserAction: "return_to_haven_for_wallet_approval_then_configure_runtime",
-      errorCode: "manual_runtime_setup_required",
-      configTarget: "manual runtime setup",
-      signerAcknowledged: signerConsent?.acknowledged,
-      localMcpAcknowledged: false,
-      messages: [
-        ...consentMessages,
-        "Custom runtime: Haven did not auto-configure it. Your credentials are on disk (chmod 600) \u2014 read them at runtime; never paste a key into the agent prompt, memory, or logs.",
-        `  identity (hosted MCP Bearer): ${input.identityPath}`,
-        `  signer (local signing key):   ${input.signerPath}`,
-        "After wallet approval, wire the runtime to Haven by reference:",
-        `  Hosted MCP + local signer: point your MCP client at ${input.hostedMcpUrl} with the api_key from identity.json, then run  npx -y ${signerPackageSpec()} --credentials ${input.signerPath}`,
-        `  Fully local MCP (no hosted dependency):  npx -y ${mcpPackageSpec()} --identity ${input.identityPath} --signer ${input.signerPath}`
-      ]
+    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 } : {}
     };
-  }
-  let localRuntimeInstall;
-  let localRuntimeError;
-  if (localRuntime) {
-    try {
-      localRuntimeInstall = await prepareRuntimeForLocalMcp(input, deps);
-    } catch (err) {
-      localRuntimeError = err;
+    if (wired) {
+      const result = await checksForAgent({ directory: dir, identity, sidecar }, input, deps);
+      entry.checks = result.checks;
+      capabilitiesByDirectory.set(dir, result.signerCapabilities);
+    } else if (rekeyPending) {
+      entry.checks = [rekeyPendingCheck(rekeyPending, void 0, input.runtime, slug)];
     }
+    inventory.push(entry);
   }
-  if (localRuntimeError) {
-    const errorCode2 = localRuntimePrepareErrorCode(localRuntimeError);
-    return {
-      runtime,
-      runtimeMcpMode: "local_stdio",
-      hostedMcpConfigured: false,
-      localSignerConfigured: false,
-      localMcpConfigured: false,
-      probeResult: errorCode2 === "local_mcp_unsupported_node_version" ? "local_stdio_mcp_unsupported_node_version" : "local_stdio_mcp_runtime_install_failed",
-      restartRequired: true,
-      nextUserAction: nextAction(runtime, profile.restartMode, errorCode2),
-      errorCode: errorCode2,
-      configTarget: profile.label,
-      signerAcknowledged: signerConsent?.acknowledged,
-      localMcpAcknowledged: localMcpConsent?.acknowledged,
-      activationCommand: void 0,
-      messages: [
-        ...consentMessages,
-        `Could not prepare local Haven MCP runtime: ${localRuntimeError instanceof Error ? localRuntimeError.message : String(localRuntimeError)}`
-      ]
-    };
+  const 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);
   }
-  let signerCommand;
-  if (!localRuntime) {
-    progress("Getting the signer ready\u2026");
-    try {
-      const signerRuntime = await prepareSignerForRuntime(input, deps);
-      signerCommand = { command: signerRuntime.command, args: signerRuntime.args };
-      consentMessages.push(...signerRuntime.messages);
-    } catch (err) {
-      return {
-        runtime,
-        runtimeMcpMode: "hosted_plus_signer",
-        hostedMcpConfigured: false,
-        localSignerConfigured: false,
-        localMcpConfigured: false,
-        probeResult: "signer_runtime_install_failed",
-        restartRequired: false,
-        nextUserAction: "The local Haven signer runtime could not be installed, so no configuration was written. Check your network (a cold install downloads the signer package set) and re-run: npx @haven_ai/connect@alpha",
-        errorCode: "signer_runtime_install_failed",
-        configTarget: profile.label,
-        signerAcknowledged: signerConsent?.acknowledged,
-        localMcpAcknowledged: localMcpConsent?.acknowledged,
-        activationCommand: void 0,
-        signerRuntimePrepared: false,
-        messages: [
-          ...consentMessages,
-          `Could not pre-install the local Haven signer: ${err instanceof Error ? err.message : String(err)}`,
-          "No runtime configuration was written (fail-closed): a config pointing at an uninstalled signer looks wired but cannot start.",
-          "Re-run `npx @haven_ai/connect@alpha` to retry the setup."
-        ]
-      };
+  if (!primaryDirectory) {
+    checks.push({
+      id: "credentials",
+      label: "Agent credentials",
+      ok: false,
+      detail: "No agent credential directory with an identity.json under ~/.haven/agents.",
+      repair: `Run the full setup once: ${RERUN} --setup <token from the Haven dashboard>.`
+    });
+  } else {
+    const primaryIdentity = await readIdentity(primaryDirectory);
+    const primarySidecar = await readRuntimeSidecar(primaryDirectory);
+    if (!primaryChecksById.has("credentials")) {
+      const result = await checksForAgent(
+        { directory: primaryDirectory, identity: primaryIdentity, sidecar: primarySidecar },
+        input,
+        deps
+      );
+      signerCapabilities = result.signerCapabilities;
+      for (const check of result.checks) primaryChecksById.set(check.id, check);
     }
-  }
-  const signerRuntimePrepared = localRuntime ? void 0 : signerCommand !== void 0;
-  progress("Setting up your Haven tools\u2026");
-  const configResult = runtime === "claude-code" ? localRuntime ? await configureClaudeCode(deps, localRuntimeInstall?.command ?? "", input.serverName) : await configureClaudeCodeHosted(deps, input, signerCommand) : await writeRuntimeConfig({
-    runtime,
-    hostedMcpUrl: input.hostedMcpUrl,
-    apiKey: input.apiKey,
-    identityPath: input.identityPath,
-    signerPath: input.signerPath,
-    serverName: input.serverName,
-    credentialDirectory: input.credentialDirectory,
-    localMcpCommand: localRuntimeInstall?.command,
-    signerCommand,
-    homeDir: deps.homeDir,
-    mode: localRuntime ? "local" : "hosted"
-  });
-  if (deps.onRuntimeConfigured) {
-    const signerCredentialOnDisk = await probeLocalSignerCredential(input.signerPath);
-    const earlyLocalMcpOk = configResult.runtimeMcpMode === "local_stdio" && configResult.localMcpConfigured && signerCredentialOnDisk && Boolean(localMcpConsent?.acknowledged);
-    const earlySignerOk = configResult.runtimeMcpMode === "local_stdio" ? earlyLocalMcpOk : configResult.signerConfigured && signerCredentialOnDisk && Boolean(signerConsent?.acknowledged);
-    try {
-      await deps.onRuntimeConfigured({
-        runtime,
-        runtimeMcpMode: configResult.runtimeMcpMode,
-        hostedMcpConfigured: configResult.hostedConfigured,
-        localSignerConfigured: earlySignerOk,
-        localMcpConfigured: earlyLocalMcpOk,
-        signerAcknowledged: signerConsent?.acknowledged,
-        localMcpAcknowledged: localMcpConsent?.acknowledged,
-        restartRequired: configResult.restartRequired || restartRequiredForRuntime(runtime, deps.env),
-        nextUserAction: nextAction(runtime, profile.restartMode, configResult.errorCode),
-        errorCode: configResult.errorCode
-      });
-    } catch {
+    for (const id of ["credentials", "signer_runtime"]) {
+      const check = primaryChecksById.get(id);
+      if (check) checks.push(check);
     }
   }
-  progress("Almost there \u2014 just confirming everything connects\u2026");
-  const localProbePromise = configResult.runtimeMcpMode === "local_stdio" && localRuntimeInstall ? runLocalMcpProbe(localRuntimeInstall, deps) : Promise.resolve(void 0);
-  const signerProbePromise = configResult.runtimeMcpMode !== "local_stdio" && signerCommand ? (deps.probeSignerTools ?? probeLocalMcpTools)(
-    signerCommand.command,
-    signerCommand.args,
-    MCP_RUNTIME_MANIFEST.requiredSignerTools
-  ) : Promise.resolve(void 0);
-  const [hostedProbe, signerCredentialReady, localMcpProbe, signerProbe] = await Promise.all([
-    configResult.hostedConfigured ? probeHostedMcpTools(input.apiKey, input.hostedMcpUrl, deps.fetch) : Promise.resolve({ status: "bad_response" }),
-    probeLocalSignerCredential(input.signerPath),
-    localProbePromise,
-    signerProbePromise
-  ]);
-  const hostedOk = configResult.hostedConfigured && hostedProbe.status === "ok";
-  const localMcpOk = configResult.runtimeMcpMode === "local_stdio" && configResult.localMcpConfigured && signerCredentialReady && Boolean(localMcpConsent?.acknowledged) && localMcpProbe?.status === "ok";
-  const signerOk = configResult.runtimeMcpMode === "local_stdio" ? localMcpOk : configResult.signerConfigured && signerCredentialReady && Boolean(signerConsent?.acknowledged) && // #1587: no handshake, no green. A signer command that was registered
-  // but not probed (manual topology) keeps the old semantics.
-  (signerProbe === void 0 || signerProbe.status === "ok");
-  const restartRequired = configResult.restartRequired || restartRequiredForRuntime(runtime, deps.env);
-  const errorCode = configResult.errorCode ?? (configResult.runtimeMcpMode === "local_stdio" ? localMcpErrorCode(signerCredentialReady, localMcpConsent, localMcpProbe?.status) : hostedMcpErrorCode(configResult.hostedConfigured, hostedProbe.status) ?? signerConsentErrorCode(signerCredentialReady, signerConsent) ?? signerProbeErrorCode(signerProbe));
-  const hostedProbeMessages = configResult.hostedConfigured && hostedProbe.status !== "ok" ? [`Hosted Haven MCP probe failed: ${hostedProbe.status}.`] : configResult.hostedConfigured ? ["Verified hosted Haven MCP tools with a read-only handshake."] : [];
-  const signerProbeMessages = signerProbe ? signerProbe.status === "ok" ? ["Verified local Haven signer with a stdio handshake."] : [
-    `Local Haven signer handshake failed: ${signerProbe.status}.`,
-    "Re-run `npx @haven_ai/connect@alpha` to repair the signer setup."
-  ] : [];
-  const localProbeMessages = localMcpProbe && localMcpProbe.status !== "ok" ? [`Local Haven MCP handshake failed: ${localMcpProbe.status}.`] : localMcpProbe?.status === "ok" ? ["Verified local Haven MCP tools with a stdio handshake."] : [];
-  const skillInstall = !configResult.errorCode ? await installSkillForRuntime(runtime, { homeDir: deps.homeDir, env: deps.env }) : void 0;
-  return {
-    runtime,
-    runtimeMcpMode: configResult.runtimeMcpMode,
-    hostedMcpConfigured: hostedOk,
-    localSignerConfigured: signerOk,
-    localMcpConfigured: localMcpOk,
-    probeResult: buildProbeResult(configResult.runtimeMcpMode, configResult.hostedConfigured, hostedProbe.status, signerOk, localMcpOk, localMcpProbe?.status),
-    restartRequired,
-    nextUserAction: nextAction(runtime, profile.restartMode, errorCode),
-    errorCode,
-    configTarget: configResult.target,
-    signerAcknowledged: signerConsent?.acknowledged,
-    localMcpAcknowledged: localMcpConsent?.acknowledged,
-    activationCommand: configResult.activationCommand,
-    skillInstalled: skillInstall?.installed,
-    signerRuntimePrepared,
-    messages: [...consentMessages, ...localRuntimeInstall?.messages ?? [], ...configResult.messages, ...hostedProbeMessages, ...signerProbeMessages, ...localProbeMessages, ...skillInstall?.messages ?? []]
-  };
-}
-function runtimeInstallCapabilities(runtime, env = process.env) {
-  const profile = runtimeProfile(runtime, env);
-  return {
-    canWriteRuntimeConfig: profile.canWriteRuntimeConfig,
-    restartRequired: restartRequiredForRuntime(runtime, env)
-  };
-}
-async function configureClaudeCode(deps, localMcpCommand, serverName) {
-  const runCommand = deps.runCommand ?? defaultRunCommand;
-  const serverJson = JSON.stringify({
-    type: "stdio",
-    command: localMcpCommand,
-    args: [],
-    env: {}
-  });
-  try {
-    if (!localMcpCommand) throw new Error("local MCP wrapper command is required");
-    const names = serverNamesFor(serverName);
-    await runCommand("claude", ["mcp", "remove", names.hosted]).catch(() => void 0);
-    await runCommand("claude", ["mcp", "remove", names.signer]).catch(() => void 0);
-    await runCommand("claude", ["mcp", "add-json", names.hosted, serverJson, "--scope", "user"]).catch(async () => {
-      await runCommand("claude", ["mcp", "add", names.hosted, "--scope", "user", "--", localMcpCommand]);
+  if (configPath === null) {
+    checks.push({
+      id: "runtime_config",
+      label: "Runtime MCP config",
+      ok: true,
+      detail: `Runtime '${input.runtime}' has no file-based config the connector owns (CLI-managed) \u2014 skipping the file check.`
+    });
+  } else if (configText === null) {
+    checks.push({
+      id: "runtime_config",
+      label: "Runtime MCP config",
+      ok: false,
+      detail: `No runtime config at ${configPath}.`,
+      repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}`
+    });
+  } else {
+    const primaryIdentity = await readIdentity(primaryDirectory ?? "");
+    const primarySidecar = primaryDirectory ? await readRuntimeSidecar(primaryDirectory) : null;
+    const hasHaven = primaryIdentity?.hosted_mcp_url ? configText.includes(primaryIdentity.hosted_mcp_url) : configText.includes("haven");
+    const signerViaNpx = configText.includes("@haven_ai/signer");
+    const wrapperReferenced = primarySidecar ? configText.includes(primarySidecar.wrapper_path) : false;
+    const ok = hasHaven && !signerViaNpx && (primarySidecar ? wrapperReferenced : true);
+    checks.push({
+      id: "runtime_config",
+      label: "Runtime MCP config",
+      ok,
+      detail: ok ? `Config at ${configPath} references the hosted server and the prepared signer wrapper.` : signerViaNpx ? `Config at ${configPath} still launches the signer via npx \u2014 the pre-#1586 shape that cannot start under a 120s startup timeout.` : `Config at ${configPath} is missing the Haven entries${primarySidecar && !wrapperReferenced ? " (or references a different signer wrapper)" : ""}.`,
+      ...ok ? {} : { repair: `Run: ${RERUN} --doctor --repair --runtime ${input.runtime}` }
     });
-    const verified = await runCommand("claude", ["mcp", "get", names.hosted]).then(() => true).catch(() => false);
-    return {
-      hostedConfigured: false,
-      signerConfigured: true,
-      localMcpConfigured: true,
-      runtimeMcpMode: "local_stdio",
-      target: "Claude Code MCP config",
-      changed: true,
-      restartRequired: true,
-      messages: [
-        "Updated local Haven MCP entry with Claude Code.",
-        ...verified ? ["Verified Claude Code MCP entry."] : []
-      ]
-    };
-  } catch (err) {
-    return {
-      hostedConfigured: false,
-      signerConfigured: false,
-      localMcpConfigured: false,
-      runtimeMcpMode: "local_stdio",
-      target: "Claude Code MCP config",
-      changed: false,
-      restartRequired: true,
-      messages: [
-        `Could not update Claude Code MCP config: ${err instanceof Error ? err.message : String(err)}`,
-        "Install Claude Code or rerun the Haven setup command inside a Claude Code terminal."
-      ],
-      errorCode: "claude_code_config_failed"
-    };
-  }
-}
-async function configureClaudeCodeHosted(deps, input, signerCommand) {
-  const runCommand = deps.runCommand ?? defaultRunCommand;
-  const hostedJson = JSON.stringify({
-    type: "http",
-    url: input.hostedMcpUrl,
-    headers: { Authorization: `Bearer ${input.apiKey}` }
-  });
-  const signerJson = JSON.stringify({
-    type: "stdio",
-    command: signerCommand?.command ?? "npx",
-    args: signerCommand?.args ?? ["-y", signerPackageSpec(), "--credentials", input.signerPath],
-    env: {}
-  });
-  try {
-    const names = serverNamesFor(input.serverName);
-    await runCommand("claude", ["mcp", "remove", names.hosted]).catch(() => void 0);
-    await runCommand("claude", ["mcp", "remove", names.signer]).catch(() => void 0);
-    await runCommand("claude", ["mcp", "add-json", names.hosted, hostedJson, "--scope", "user"]);
-    await runCommand("claude", ["mcp", "add-json", names.signer, signerJson, "--scope", "user"]);
-    const verified = await runCommand("claude", ["mcp", "get", names.hosted]).then(() => true).catch(() => false);
-    return {
-      hostedConfigured: true,
-      signerConfigured: true,
-      localMcpConfigured: false,
-      runtimeMcpMode: "hosted_plus_signer",
-      target: "Claude Code MCP config",
-      changed: true,
-      restartRequired: true,
-      messages: [
-        "Updated hosted Haven MCP and local signer entries with Claude Code.",
-        ...verified ? ["Verified Claude Code MCP entry."] : []
-      ]
-    };
-  } catch (err) {
-    return {
-      hostedConfigured: false,
-      signerConfigured: false,
-      localMcpConfigured: false,
-      runtimeMcpMode: "hosted_plus_signer",
-      target: "Claude Code MCP config",
-      changed: false,
-      restartRequired: true,
-      messages: [
-        `Could not update Claude Code MCP config: ${err instanceof Error ? err.message : String(err)}`,
-        "Install Claude Code or rerun the Haven setup command inside a Claude Code terminal."
-      ],
-      errorCode: "claude_code_config_failed"
-    };
-  }
-}
-async function defaultRunCommand(command, args) {
-  await execFileAsync3(command, args, { timeout: 1e4 });
-}
-function buildProbeResult(mode, hostedConfigured, hostedStatus, signerReady, localMcpReady, localMcpProbeStatus) {
-  if (mode === "local_stdio") {
-    if (localMcpReady) return "local_stdio_mcp_ready";
-    return localMcpProbeStatus ? `local_stdio_mcp_${localMcpProbeStatus}` : "local_stdio_mcp_unavailable";
   }
-  const hostedPart = hostedConfigured ? `hosted_${hostedStatus}` : "hosted_not_configured";
-  const signerPart = signerReady ? "local_signer_ready" : "local_signer_unavailable";
-  return `${hostedPart}_${signerPart}`.slice(0, 120);
-}
-async function resolveLocalMcpConsent(input, messages) {
-  if (input.ackLocalTools || input.ackSigner) {
-    const status = await acknowledgeLocalMcpConsent(input.identityPath, input.signerPath, (message) => messages.push(message));
-    if (status.acknowledged) {
-      messages.push("Prepared the local Haven tools acknowledgement.");
-    } else {
-      messages.push("Local Haven tools acknowledgement still needs attention.");
-    }
-    return status;
+  for (const id of ["hosted_mcp", "identity_match", "rekey_pending"]) {
+    const check = primaryChecksById.get(id);
+    if (check) checks.push(check);
   }
-  return getLocalMcpConsentStatus(input.identityPath, input.signerPath);
-}
-async function resolveSignerConsent(input, messages) {
-  if (input.ackSigner || input.ackLocalTools) {
-    const status = await acknowledgeLocalSignerConsent(input.signerPath, (message) => messages.push(message));
-    if (status.acknowledged) {
-      messages.push("Prepared the local Haven signer acknowledgement.");
-    } else {
-      messages.push("Local Haven signer acknowledgement still needs attention.");
+  const otherEntries = inventory.filter((entry) => entry.directory !== primaryDirectory);
+  if (otherEntries.length > 0) {
+    const live = [];
+    const revoked = [];
+    const unverifiable = [];
+    const retired = [];
+    for (const entry of otherEntries) {
+      const identity = await readIdentity(entry.directory);
+      const tombstone = await readAgentTombstone(entry.directory);
+      const otherAgent = entry.agentId ?? basename(entry.directory);
+      const otherUrl = identity?.hosted_mcp_url ?? (identity?.api_url ? `${identity.api_url}/mcp` : void 0);
+      if (!identity?.api_key || !otherUrl) {
+        if (tombstone) retired.push(`${otherAgent} (retired ${tombstone.retired_at})`);
+        else unverifiable.push(`${otherAgent} (no stored key/URL to probe)`);
+        continue;
+      }
+      const suffix = tombstone ? " [tombstoned \u2014 key material still present]" : "";
+      const probe = await (deps.probeHosted ?? probeHostedMcpTools)(identity.api_key, otherUrl, deps.fetch);
+      if (probe.status === "ok") live.push({ label: `${otherAgent}${suffix}`, entry });
+      else if (probe.status === "unauthorized") revoked.push(`${otherAgent}${suffix}`);
+      else unverifiable.push(`${otherAgent} (${probe.status})${suffix}`);
     }
-    return status;
+    const parts = [];
+    if (live.length > 0) parts.push(`STILL SPEND-CAPABLE: ${live.map((item) => item.label).join(", ")}`);
+    if (revoked.length > 0) parts.push(`already revoked: ${revoked.join(", ")}`);
+    if (retired.length > 0) parts.push(`tombstoned (keys removed): ${retired.join(", ")}`);
+    if (unverifiable.length > 0) parts.push(`could not verify: ${unverifiable.join(", ")}`);
+    const supersededLive = live.filter((item) => item.entry.classification !== "wired").map((item) => item.label);
+    checks.push({
+      id: "superseded_agents",
+      label: "Superseded agent credentials",
+      ok: supersededLive.length === 0,
+      detail: supersededLive.length > 0 ? `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}. A host started before your latest setup keeps authenticating (and spending) as the old agent.` : `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}.`,
+      ...supersededLive.length > 0 ? {
+        repair: `Revoke ${supersededLive.join(", ")} on the Haven agent page, then remove the old director(y/ies) under ~/.haven/agents. Connect never revokes or deletes for you.`
+      } : {}
+    });
   }
-  return getLocalSignerConsentStatus(input.signerPath);
-}
-function signerConsentErrorCode(signerCredentialReady, signerConsent) {
-  if (!signerCredentialReady) return "local_signer_credential_unavailable";
-  if (!signerConsent?.acknowledged) return "local_signer_ack_required";
-  return void 0;
-}
-function signerProbeErrorCode(probe) {
-  if (!probe || probe.status === "ok") return void 0;
-  return `local_signer_probe_${probe.status}`;
-}
-function hostedMcpErrorCode(hostedConfigured, hostedProbeStatus) {
-  if (!hostedConfigured || hostedProbeStatus === "ok") return void 0;
-  return `hosted_mcp_probe_${hostedProbeStatus}`;
-}
-function localMcpErrorCode(signerCredentialReady, localMcpConsent, localMcpProbeStatus) {
-  if (!signerCredentialReady) return "local_signer_credential_unavailable";
-  if (!localMcpConsent?.acknowledged) return "local_mcp_ack_required";
-  if (localMcpProbeStatus && localMcpProbeStatus !== "ok") return `local_mcp_probe_${localMcpProbeStatus}`;
-  return void 0;
-}
-function nextAction(runtime, restartMode, errorCode) {
-  if (errorCode) return "return_to_haven_for_wallet_approval_then_finish_runtime_setup";
-  if (restartMode === "hot-reload") return "return_to_haven_for_wallet_approval";
-  if (runtime === "codex-cli" || runtime === "codex-desktop") return "return_to_haven_for_wallet_approval_then_restart_codex";
-  if (runtime === "claude-code") return "return_to_haven_for_wallet_approval_then_restart_claude_code";
-  if (restartMode === "restart-app") return "return_to_haven_for_wallet_approval_then_restart_app";
-  if (restartMode === "restart-session") return "return_to_haven_for_wallet_approval_then_restart_agent_session";
-  return "return_to_haven_for_wallet_approval_then_configure_runtime";
-}
-function supportsLocalMcp(runtime) {
-  return runtime === "codex-cli" || runtime === "codex-desktop" || runtime === "claude-code";
-}
-async function prepareRuntimeForLocalMcp(input, deps) {
-  const prepare = deps.prepareLocalMcpRuntime ?? ((runtimeInput) => prepareLocalMcpRuntime(runtimeInput, { runCommand: deps.runCommand, onProgress: deps.onProgress }));
-  return prepare({
-    credentialDirectory: input.credentialDirectory,
-    identityPath: input.identityPath,
-    signerPath: input.signerPath,
-    homeDir: deps.homeDir,
-    serverName: input.serverName
-  });
-}
-async function prepareSignerForRuntime(input, deps) {
-  const prepare = deps.prepareSignerRuntime ?? ((runtimeInput) => (
-    // onProgress threaded through on purpose (#1586 review): without it the
-    // install heartbeat was dead code in production and the console still
-    // went silent for the whole cold install — the exact symptom the issue
-    // set out to remove, at a longer timeout.
-    prepareSignerRuntime(runtimeInput, { runCommand: deps.runCommand, onProgress: deps.onProgress })
-  ));
-  return prepare({
-    credentialDirectory: input.credentialDirectory,
-    signerPath: input.signerPath,
-    homeDir: deps.homeDir,
-    serverName: input.serverName
+  const parkedElsewhere = inventory.filter((entry) => entry.directory !== primaryDirectory && entry.rekeyPending).map((entry) => ({ entry, pending: entry.rekeyPending }));
+  if (parkedElsewhere.length > 0) {
+    const abandoned = parkedElsewhere.filter((item) => item.pending.state !== "pending");
+    const describe = (item) => `${item.entry.slug ?? item.entry.agentId ?? basename(item.entry.directory)} (${item.pending.state}, ${item.pending.path})`;
+    checks.push({
+      id: "rekey_pending_elsewhere",
+      label: "Parked re-keys in other credential directories",
+      ok: abandoned.length === 0,
+      detail: abandoned.length > 0 ? `ABANDONED re-key key material outside the agent this report describes: ${abandoned.map(describe).join(", ")}. Each holds a private key that was generated for a re-key nobody finished.` : `${parkedElsewhere.length} other director(y/ies) hold an open pending re-key: ${parkedElsewhere.map(describe).join(", ")}.`,
+      ...abandoned.length > 0 ? {
+        repair: "Check the Haven agent page for each before deleting: if its on-chain revoke already ran, the agent has no spend authority until you re-grant it (#1868), and that is not visible from this machine. Connect never deletes key material for you."
+      } : {}
+    });
+  }
+  const signerProcess = primaryChecksById.get("signer_process");
+  if (signerProcess) checks.push(signerProcess);
+  const restart = restartRequiredForRuntime(input.runtime, deps.env);
+  checks.push({
+    id: "restart",
+    label: "Runtime restart",
+    ok: true,
+    detail: restart ? "This runtime loads MCP config at startup \u2014 restart it after any repair before expecting the tools to appear." : "No restart requirement known for this runtime."
   });
+  const wiredOk = inventory.filter((entry) => entry.classification === "wired").every((entry) => entry.checks.every((check) => check.ok));
+  return {
+    version: 1,
+    ok: checks.every((check) => check.ok) && wiredOk,
+    runtime: input.runtime,
+    credentialDirectory: primaryDirectory,
+    checks,
+    agents: inventory,
+    ...signerCapabilities ? { signerCapabilities } : {}
+  };
 }
-async function runLocalMcpProbe(runtimeInstall, deps) {
-  const probe = deps.probeLocalMcpTools ?? probeLocalMcpTools;
+async function runRepair(input, deps = {}) {
+  const homeDir = deps.homeDir ?? homedir();
+  const messages = [];
+  const { directory, others } = await discoverCredentialDirectory(homeDir, input.credentialsDir);
+  if (others.length > 0) {
+    messages.push(`Note: ${others.length} other agent credential dir(s) exist \u2014 run --doctor for their status.`);
+  }
+  if (!directory) {
+    return {
+      ok: false,
+      messages: [`No agent credentials found to repair \u2014 run the full setup: ${RERUN} --setup <token>.`]
+    };
+  }
+  let identity;
   try {
-    return await probe(runtimeInstall.command, runtimeInstall.args, MCP_RUNTIME_MANIFEST.requiredTools);
+    identity = JSON.parse(await readFile(join(directory, "identity.json"), "utf8"));
   } catch {
-    return { status: "process_error" };
+    return { ok: false, messages: ["identity.json is unreadable \u2014 re-run the full setup with a fresh token."] };
   }
-}
-function localRuntimePrepareErrorCode(err) {
-  if (err && typeof err === "object" && "code" in err && err.code === "local_mcp_unsupported_node_version") {
-    return "local_mcp_unsupported_node_version";
+  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 "local_mcp_runtime_install_failed";
+  const configPath = runtimeConfigPathFor(input.runtime, homeDir);
+  if (configPath) {
+    try {
+      const existing = await readFile(configPath, "utf8");
+      if (existing.includes("bin/haven-mcp") || existing.includes(".haven/mcp-runtime")) {
+        return {
+          ok: false,
+          messages: [
+            `The config at ${configPath} is the LOCAL-stdio topology (--local). Repair currently rewrites only the hosted+signer shape and will not touch it.`,
+            "Re-run your original setup command (with --local) to repair a local-stdio install."
+          ]
+        };
+      }
+    } catch {
+    }
+  }
+  const existingSidecar = await readRuntimeSidecar(directory);
+  const serverName = existingSidecar?.server_name;
+  const signerPath = join(directory, "signer.json");
+  const prepared = await prepareSignerRuntime(
+    { credentialDirectory: directory, signerPath, homeDir, serverName },
+    { runCommand: deps.runCommand }
+  );
+  messages.push(...prepared.messages);
+  const names = serverNamesFor(serverName);
+  messages.push(`Rewriting MCP entries ${names.hosted} / ${names.signer}${serverName ? ` (agent "${serverName}")` : " (unnamed pair)"} \u2014 no other pair is touched.`);
+  const configResult = await writeRuntimeConfig({
+    runtime: input.runtime,
+    hostedMcpUrl: identity.hosted_mcp_url ?? `${identity.api_url}/mcp`,
+    apiKey: identity.api_key,
+    identityPath: join(directory, "identity.json"),
+    signerPath,
+    credentialDirectory: directory,
+    signerCommand: { command: prepared.command, args: prepared.args },
+    homeDir,
+    mode: "hosted",
+    serverName
+  });
+  messages.push(...configResult.messages);
+  messages.push("Repair complete \u2014 restart the runtime, then verify with --doctor.");
+  return { ok: true, messages };
 }
+var RERUN;
+var init_doctor = __esm({
+  "src/doctor.ts"() {
+    init_runtime_manifest();
+    init_probes();
+    init_signer_runtime();
+    init_config_writers();
+    init_runtime_registry();
+    init_signer_consent();
+    init_tombstone();
+    init_server_names();
+    init_storage();
+    init_redact();
+    RERUN = "npx @haven_ai/connect@alpha";
+  }
+});
 
 // src/runtime.ts
+init_api();
+init_key();
+init_redact();
+init_server_names();
+init_storage();
+init_runtime_install();
 init_runtime_registry();
 init_connect_error();
 
@@ -3123,8 +3712,9 @@ function defaultPromptIo() {
 }
 
 // src/runtime.ts
+init_local_mcp_runtime();
 init_runtime_manifest();
-var CONNECTOR_VERSION = "0.1.29-alpha.0";
+var CONNECTOR_VERSION = "0.1.31-alpha.0";
 var CONNECT_OUTCOME_SCHEMA_VERSION = 1;
 async function runConnect(options, deps = {}) {
   assertSupportedNodeVersion(deps.nodeVersion, MCP_RUNTIME_MANIFEST.minimumNodeVersion);
@@ -3149,7 +3739,14 @@ async function runConnect(options, 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. Nothing was written and the Haven setup token is still unused.`,
-      "rerun_connect_with_explicit_runtime"
+      "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).
+      { allowedRuntimes: RUNTIME_FLAG_VALUE_LIST }
     );
   }
   const runtime = selection.runtime;
@@ -3171,11 +3768,16 @@ async function runConnect(options, deps = {}) {
     log(`runtime: ${runtime} (chosen at the prompt \u2014 nothing was detected in this environment)`);
   }
   log("Warming up your connection to Haven\u2026");
-  const setup = await api.resolveSetup({
-    setupToken: options.setupToken,
-    connectorVersion,
-    runtime
-  });
+  let setup;
+  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 });
@@ -3200,6 +3802,11 @@ async function runConnect(options, deps = {}) {
       proofSignature,
       apiKeyHash: hashAgentApiKey(localApiKey),
       apiKeyPrefix: agentApiKeyPrefix(localApiKey),
+      // #1878: report the pair we are ACTUALLY wiring, bare pair included, so
+      // the dashboard can name it. Derived here rather than sent as the raw
+      // slug — `serverNamesFor` is the one place the naming rule lives, and
+      // the hosted name is what a user pastes into an MCP config.
+      mcpServerName: serverNamesFor(options.serverName).hosted,
       connectorContext: {
         environment_label: options.environmentLabel ?? "Local workspace",
         config_target: installCapabilities.canWriteRuntimeConfig ? "agent runtime MCP config" : "local credential files"
@@ -3207,6 +3814,8 @@ async function runConnect(options, deps = {}) {
       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 Connect command. Do not reuse or paste credentials."
@@ -3404,7 +4013,17 @@ function failedConnectOutcome(runtimeHint, error) {
       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 }
+    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 } : {}
+    }
   };
 }
 function printSetupSummary(setup, log) {
@@ -3426,16 +4045,20 @@ function assertSetupChallengeIsUsable(expiresAt) {
     "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 Connect 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) => {
-    let safe = redactSecrets(message);
-    if (redactPaths) {
-      safe = safe.replace(/(?:~|\/)[^\s`"']*\/(?:identity|signer|agent)\.json\b/g, "[credential-file-redacted]").replace(/(?:~|\/)[^\s`"']*\/\.env\b/g, "[credential-env-redacted]");
-    }
-    log(safe);
+    log(redactPaths ? redactForAutomation(message) : redactSecrets(message));
   };
 }
 function printRuntimeInstall(result, log) {
@@ -3603,6 +4226,8 @@ function parseArgs(argv, env = process.env) {
   let json = false;
   let doctor = false;
   let repair = false;
+  let rekeyPhase;
+  let newApiKey;
   let tombstoneDir;
   let tombstoneReason;
   let tombstoneReplacedBy;
@@ -3616,6 +4241,12 @@ function parseArgs(argv, env = process.env) {
       doctor = true;
     } else if (arg === "--repair") {
       repair = true;
+    } else if (arg === "--rekey") {
+      rekeyPhase = "start";
+    } else if (arg === "--rekey-finish") {
+      rekeyPhase = "finish";
+    } else if (arg === "--api-key") {
+      newApiKey = requireValue(argv, ++i, arg);
     } else if (arg === "--tombstone") {
       tombstoneDir = requireValue(argv, ++i, arg);
     } else if (arg === "--reason") {
@@ -3653,20 +4284,38 @@ function parseArgs(argv, env = process.env) {
     }
   }
   const tombstone = tombstoneDir ? { directory: tombstoneDir, reason: tombstoneReason, replacedBy: tombstoneReplacedBy } : void 0;
+  const rekey = rekeyPhase ? { phase: rekeyPhase, newApiKey } : void 0;
   if (help) {
-    return { options, help, json, doctor, repair, tombstone };
+    return { options, help, json, doctor, repair, tombstone, rekey };
+  }
+  if (rekey) {
+    if (options.setupToken) {
+      throw new Error("--rekey replaces an existing agent's key; it does not take --setup. Drop one of them.");
+    }
+    if (rekey.phase === "start" && newApiKey !== void 0) {
+      throw new Error(
+        "--api-key belongs to --rekey-finish. --rekey generates the new key here and prints the address to paste into Haven; the API key does not exist yet."
+      );
+    }
+    if (rekey.phase === "finish" && !newApiKey) {
+      throw new Error("--rekey-finish needs --api-key <key> \u2014 the one the Haven agent page showed once.");
+    }
+    return { options, help, json, doctor, repair, tombstone, rekey };
+  }
+  if (newApiKey !== void 0) {
+    throw new Error("--api-key requires --rekey-finish.");
   }
   if (!tombstoneDir && (tombstoneReason !== void 0 || tombstoneReplacedBy !== void 0)) {
     throw new Error("--reason and --replaced-by require --tombstone <dir>.");
   }
   if (tombstone) {
-    return { options, help, json, doctor, repair, tombstone };
+    return { options, help, json, doctor, repair, tombstone, rekey };
   }
   if (doctor || repair) {
     if (!options.runtime) {
       throw new Error("--doctor/--repair need --runtime <runtime> (which config to examine).");
     }
-    return { options, help, json, doctor, repair, tombstone };
+    return { options, help, json, doctor, repair, tombstone, rekey };
   }
   if (!options.setupToken) {
     throw new Error("Missing --setup <hv_setup_...> setup token.");
@@ -3675,7 +4324,7 @@ function parseArgs(argv, env = process.env) {
     throw new Error("Missing --api <Haven API URL>.");
   }
   options.apiBaseUrl = options.apiBaseUrl.replace(/\/+$/, "");
-  return { options, help, json, doctor, repair, tombstone };
+  return { options, help, json, doctor, repair, tombstone, rekey };
 }
 function helpText() {
   return [
@@ -3712,6 +4361,14 @@ function helpText() {
     "  --repair                   Repair, then re-diagnose (implies --doctor): reinstall the pinned signer",
     "                             runtime, rewrite the wrapper and runtime config from stored credentials.",
     "                             Hosted topology only (refuses to touch a --local config). No keys, no token.",
+    "  --rekey                    Replace this agent's signing key (no token). Generates a fresh keypair HERE and",
+    "                             prints its public address to paste into the Haven agent page. Nothing changes",
+    "                             until you finish; the agent keeps working on its old key throughout.",
+    "                             Add --name <slug> for a named agent. Refuses a legacy-rail or revoked agent.",
+    "  --rekey-finish             Second half of --rekey: writes the new key and the API key the agent page",
+    "                             showed once, in place at the same path, and rewrites only this agent's MCP",
+    "                             config pair. Server names do not change, so wired hosts need only a restart.",
+    "  --api-key <key>            The new API key, for --rekey-finish.",
     "  --tombstone <dir>          Retire an agent credential directory in place (no token): replaces its signer",
     "                             wrapper with a diagnostic that names the retirement in MCP stderr logs, and",
     "                             writes TOMBSTONE.json. Touches NO key material and revokes nothing.",
@@ -3742,6 +4399,8 @@ async function runCli(argv, io = {
     parsed = parseArgs(argv);
   } catch (err) {
     if (wantsJson) {
+      io.stderr(`${redactForAutomation(err instanceof Error ? err.message : String(err))}
+`);
       io.stdout(`${JSON.stringify(failedConnectOutcome(void 0, err))}
 `);
     } else {
@@ -3757,13 +4416,13 @@ async function runCli(argv, io = {
   }
   if (parsed.tombstone) {
     const { writeAgentTombstone: writeAgentTombstone2 } = await Promise.resolve().then(() => (init_tombstone(), tombstone_exports));
-    const { readFile: readFile11 } = await import('fs/promises');
+    const { readFile: readFile12 } = await import('fs/promises');
     const { join: join10 } = await import('path');
     try {
       let agentId = "unknown";
       try {
         const identity = JSON.parse(
-          await readFile11(join10(parsed.tombstone.directory, "identity.json"), "utf8")
+          await readFile12(join10(parsed.tombstone.directory, "identity.json"), "utf8")
         );
         agentId = identity.agent_id ?? "unknown";
       } catch {
@@ -3790,6 +4449,64 @@ async function runCli(argv, io = {
       return 0;
     } catch (err) {
       io.stderr(`${redactSecrets(err instanceof Error ? err.message : String(err))}
+`);
+      return 1;
+    }
+  }
+  if (parsed.rekey) {
+    const { startRekey: startRekey2, finishRekey: finishRekey2 } = await Promise.resolve().then(() => (init_rekey(), rekey_exports));
+    const { restartGuidance: restartGuidance2 } = await Promise.resolve().then(() => (init_rekey_restart(), rekey_restart_exports));
+    const common = {
+      serverName: parsed.options.serverName,
+      credentialsDir: parsed.options.credentialsDir,
+      runtime: parsed.options.runtime
+    };
+    try {
+      if (parsed.rekey.phase === "start") {
+        const result2 = await startRekey2(common);
+        if (parsed.json) {
+          io.stdout(
+            `${redactSecrets(
+              JSON.stringify({
+                rekey: "started",
+                agent_id: result2.agentId,
+                new_delegate_address: result2.newDelegateAddress,
+                expires_at: result2.expiresAt
+              })
+            )}
+`
+          );
+        } else {
+          for (const line of result2.messages) io.stdout(redactSecrets(`${line}
+`));
+        }
+        return 0;
+      }
+      const result = await finishRekey2({ ...common, newApiKey: parsed.rekey.newApiKey });
+      const restart = restartGuidance2(parsed.options.runtime);
+      if (parsed.json) {
+        io.stdout(
+          `${redactSecrets(
+            JSON.stringify({
+              rekey: "finished",
+              agent_id: result.agentId,
+              new_delegate_address: result.newDelegateAddress,
+              mcp_servers: result.serverNames,
+              restart_commands: restart.commands
+            })
+          )}
+`
+        );
+      } else {
+        for (const line of result.messages) io.stdout(redactSecrets(`${line}
+`));
+        io.stdout("\n");
+        for (const line of restart.lines) io.stdout(redactSecrets(`${line}
+`));
+      }
+      return 0;
+    } catch (err) {
+      io.stderr(`${redactSecrets(err instanceof Error ? err.message : String(err))}
 `);
       return 1;
     }
@@ -3822,7 +4539,7 @@ async function runCli(argv, io = {
           for (const agent of otherAgents) {
             const name = agent.slug ? `${agent.slug} (${agent.agentId ?? "unknown"})` : agent.agentId ?? "unknown";
             const failed = agent.checks.filter((check) => !check.ok);
-            const verdict = agent.classification === "wired" ? failed.length === 0 ? "wired, all checks passed" : `wired, ${failed.length} check(s) FAILED` : agent.classification;
+            const verdict = agent.classification === "wired" ? failed.length === 0 ? "wired, all checks passed" : `wired, ${failed.length} check(s) FAILED` : agent.classification === "parked" ? "parked re-key only \u2014 no identity.json in this directory, but key material is still there" : agent.classification;
             io.stdout(redactSecrets(`  ${failed.length > 0 ? "\u2717" : "\u2022"} ${name}: ${verdict}
 `));
             for (const check of failed) {
@@ -3864,6 +4581,8 @@ async function runCli(argv, io = {
     return 0;
   } catch (err) {
     if (parsed.json) {
+      io.stderr(`${redactForAutomation(err instanceof Error ? err.message : String(err))}
+`);
       io.stdout(`${JSON.stringify(failedConnectOutcome(parsed.options.runtime, err))}
 `);
     } else {