@haven_ai/connect 0.8.1-alpha.0 → 0.10.0-alpha.0

package/dist/cli.cjs

@@ -3,15 +3,15 @@
 
 var crypto = require('crypto');
 var ethers = require('ethers');
-var promises = require('fs/promises');
-var os = require('os');
-var path = require('path');
 var mcp = require('@haven_ai/mcp');
 var signer = require('@haven_ai/signer');
 var sdk = require('@haven_ai/sdk');
-var yaml = require('yaml');
 var child_process = require('child_process');
+var promises = require('fs/promises');
+var os = require('os');
+var path = require('path');
 var util = require('util');
+var yaml = require('yaml');
 var readline = require('readline');
 var fs = require('fs');
 var url = require('url');
@@ -72,6 +72,25 @@ function createConnectApiClient(baseUrl, fetchImpl = fetch, clientIdentity) {
       method: "GET",
       headers: { Authorization: `Bearer ${apiKey}` }
     }),
+    reportRetiredAgents: async (input) => {
+      try {
+        const body = await send(
+          `${root}/agent-connection-setups/${encodeURIComponent(input.setupId)}/retired-agents`,
+          {
+            method: "POST",
+            headers: { Authorization: `Bearer ${input.apiKey}` },
+            body: JSON.stringify({ retired_agent_ids: input.retiredAgentIds })
+          }
+        );
+        const recorded = body?.recorded_agent_ids;
+        return {
+          recordedAgentIds: Array.isArray(recorded) ? recorded.filter((id) => typeof id === "string") : []
+        };
+      } catch (err) {
+        if (err instanceof ConnectRequestError && err.status === 404) return null;
+        throw err;
+      }
+    },
     updateInstallStatus: async (setupId, apiKey, input) => {
       await send(`${root}/agent-connection-setups/${encodeURIComponent(setupId)}/install-status`, {
         method: "POST",
@@ -241,1086 +260,1538 @@ var init_server_names = __esm({
     SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
   }
 });
-async function preflightCredentialStorage(input = {}) {
-  const directory = defaultCredentialRoot(input.baseDir);
-  await promises.mkdir(directory, { recursive: true, mode: 448 });
-  await restrictPermissions(directory, 448, input.warn);
-  const probePath = path.join(directory, `.haven-connect-preflight-${crypto__default.default.randomBytes(8).toString("hex")}`);
-  try {
-    await writeOwnerOnlyJson(probePath, { ok: true }, input.warn);
-  } finally {
-    await promises.rm(probePath, { force: true }).catch(() => void 0);
-  }
-  return directory;
-}
-async function writeCredentialFiles(input) {
-  const directory = defaultAgentDirectory(input.serverName ?? input.agentId, input.baseDir);
-  await promises.mkdir(directory, { recursive: true, mode: 448 });
-  await restrictPermissions(directory, 448, input.warn);
-  const identityPath = path.join(directory, "identity.json");
-  const signerPath = path.join(directory, "signer.json");
-  const agentPath = path.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 promises.rm(signerPath, { force: true }).catch(() => void 0);
-    throw err;
-  }
-  try {
-    await writeOwnerOnlyJson(agentPath, agentPayload(input), input.warn);
-  } catch (err) {
-    await promises.rm(signerPath, { force: true }).catch(() => void 0);
-    await promises.rm(identityPath, { force: true }).catch(() => void 0);
-    await promises.rm(agentPath, { force: true }).catch(() => void 0);
-    throw err;
-  }
-  return { directory, identityPath, signerPath, agentPath };
-}
-function signerPayload(input) {
-  return {
-    delegate_key: input.delegateKey,
-    delegate_address: input.delegateAddress,
-    agent_id: input.agentId,
-    account_address: input.accountAddress,
-    chain_id: input.chainId,
-    network: input.network,
-    x402_binding_signer: input.x402BindingSigner,
-    note: "Local signer credential. Haven backend never receives this private key."
-  };
+function mcpPackageSpec() {
+  return `${MCP_RUNTIME_MANIFEST.mcpPackage}@${MCP_RUNTIME_MANIFEST.mcpVersion}`;
 }
-function identityPayload(input) {
-  return {
-    api_key: input.apiKey,
-    agent_id: input.agentId,
-    account_address: input.accountAddress,
-    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."
-  };
+function sdkPackageSpec() {
+  return `${MCP_RUNTIME_MANIFEST.sdkPackage}@${MCP_RUNTIME_MANIFEST.sdkVersion}`;
 }
-function agentPayload(input) {
-  return {
-    agent_id: input.agentId,
-    delegate_address: input.delegateAddress,
-    account_address: input.accountAddress,
-    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."
-  };
+function signerPackageSpec() {
+  return `${MCP_RUNTIME_MANIFEST.signerPackage}@${MCP_RUNTIME_MANIFEST.signerVersion}`;
 }
-async function readStoredCredentials(serverName, agentIdOrSlug, baseDir) {
-  const key = serverName ?? agentIdOrSlug;
-  const directory = key ? defaultAgentDirectory(key, baseDir) : await discoverSoleAgentDirectory(baseDir);
-  const identity = await readJsonFile(path.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.`
-    );
+var MCP_RUNTIME_MANIFEST;
+var init_runtime_manifest = __esm({
+  "src/runtime-manifest.ts"() {
+    MCP_RUNTIME_MANIFEST = {
+      mcpPackage: "@haven_ai/mcp",
+      mcpVersion: mcp.MCP_VERSION,
+      sdkPackage: "@haven_ai/sdk",
+      sdkVersion: "0.10.0-alpha.0",
+      signerPackage: "@haven_ai/signer",
+      signerVersion: "0.10.0-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: sdk.HAVEN_MINIMUM_NODE_VERSION,
+      supportedClients: ["codex-cli", "codex-desktop", "claude-code"],
+      requiredTools: mcp.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(signer.toolSchemas)
+    };
   }
-  const agent = await readJsonFile(path.join(directory, "agent.json")) ?? {};
-  const signer = await readJsonFile(path.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.`
-    );
+});
+function resolveRuntimeSpecOverride(env) {
+  const override = {};
+  for (const pkg of Object.keys(RUNTIME_SPEC_ENV)) {
+    const variable = RUNTIME_SPEC_ENV[pkg];
+    const raw = env[variable];
+    if (raw === void 0) continue;
+    override[pkg] = validateSpec(variable, raw);
   }
-  return {
-    directory,
-    agentId,
-    apiKey,
-    apiUrl,
-    hostedMcpUrl,
-    delegateAddress: asString(agent.delegate_address) ?? asString(signer.delegate_address),
-    ...readStoredAccountAddress(identity, agent),
-    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
-  };
-}
-function readStoredAccountAddress(identity, agent) {
-  const fresh = asString(identity.account_address) ?? asString(agent.account_address);
-  if (fresh) return { accountAddress: fresh, accountAddressKey: "account_address" };
-  const legacy = asString(identity.safe_address) ?? asString(agent.safe_address);
-  if (legacy) return { accountAddress: legacy, accountAddressKey: "safe_address" };
-  return {};
+  return Object.keys(override).length > 0 ? override : void 0;
 }
-async function discoverSoleAgentDirectory(baseDir) {
-  const root = defaultCredentialRoot(baseDir);
-  let entries = [];
-  try {
-    entries = await promises.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 = path.join(root, entry);
-    if (!await readJsonFile(path.join(directory, "identity.json"))) continue;
-    if (await readJsonFile(path.join(directory, "TOMBSTONE.json"))) continue;
-    candidates.push(directory);
+function validateSpec(variable, raw) {
+  if (raw.length === 0 || raw.trim().length === 0) {
+    throw new RuntimeSpecOverrideError(variable, "it is empty");
   }
-  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.`);
+  if (/\s/.test(raw)) {
+    throw new RuntimeSpecOverrideError(variable, "it contains whitespace");
   }
-  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 = path.join(directory, "identity.json");
-  const signerPath = path.join(directory, "signer.json");
-  const agentPath = path.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));
+  if (/[\u0000-\u001f\u007f]/.test(raw)) {
+    throw new RuntimeSpecOverrideError(variable, "it contains a control character");
   }
-  const temps = [];
-  try {
-    for (const { path, payload } of targets) {
-      const temp = `${path}.rekey-${crypto__default.default.randomBytes(6).toString("hex")}.tmp`;
-      await writeOwnerOnlyJson(temp, payload, input.warn);
-      temps.push({ from: temp, to: path });
-    }
-    for (const { from, to } of temps) {
-      await promises.rename(from, to);
-    }
-  } catch (err) {
-    for (const { from } of temps) await promises.rm(from, { force: true }).catch(() => void 0);
-    for (const [path, contents] of originals) {
-      if (contents === null) {
-        await promises.rm(path, { force: true }).catch(() => void 0);
-      } else {
-        await promises.writeFile(path, contents, { mode: 384 }).catch(() => void 0);
-      }
-    }
-    throw err;
+  const meta = SHELL_METACHARACTERS.exec(raw);
+  if (meta) {
+    throw new RuntimeSpecOverrideError(variable, `it contains the shell metacharacter ${JSON.stringify(meta[0])}`);
   }
-  return { directory, identityPath, signerPath, agentPath };
+  return raw;
 }
-async function writeRekeyPending(directory, pending, warn) {
-  const path$1 = path.join(directory, REKEY_PENDING_FILENAME);
-  await promises.rm(path$1, { force: true }).catch(() => void 0);
-  await writeOwnerOnlyJson(path$1, { ...pending }, warn);
-  return path$1;
+function runtimeSpecOverrideDirectoryKey(resolvedSpecs) {
+  const digest = crypto.createHash("sha256").update(resolvedSpecs.join("\n")).digest("hex");
+  return `override-${digest.slice(0, 12)}`;
 }
-async function readRekeyPending(directory, now = Date.now()) {
-  const path$1 = path.join(directory, REKEY_PENDING_FILENAME);
-  const raw = await readJsonFile(path$1);
-  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.`
-    );
+function overrideApplies(override, packages) {
+  return override !== void 0 && packages.some((pkg) => override[pkg] !== void 0);
+}
+function runtimeSpecOverrideNotice(runtimeLabel, override, pinned, runtimeDirectory) {
+  const lines = [`RUNTIME SPEC OVERRIDE ACTIVE for the local Haven ${runtimeLabel} \u2014 this is NOT the pinned manifest.`];
+  for (const pkg of Object.keys(RUNTIME_SPEC_ENV)) {
+    const spec = override[pkg];
+    if (spec === void 0) continue;
+    const pin = pinned[pkg];
+    lines.push(`  ${RUNTIME_SPEC_ENV[pkg]}=${spec}${pin ? ` (instead of ${pin})` : ""}`);
   }
-  const pending = raw;
-  if (!pending.new_delegate_key || !pending.new_delegate_address || !pending.agent_id) {
-    throw new Error(`The pending re-key at ${path$1} 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;
+  lines.push(`  Installing into ${runtimeDirectory} \u2014 the pinned runtime directory is untouched.`);
+  lines.push("  Unset the variable(s) and re-run to return to the pinned manifest.");
+  return lines;
 }
-async function inspectRekeyPending(directory, now = Date.now()) {
-  const path$1 = path.join(directory, REKEY_PENDING_FILENAME);
-  const raw = await readJsonFile(path$1);
-  if (!raw) {
-    const present = await readRawFile(path$1) !== null;
-    return present ? { state: "unreadable", path: path$1 } : null;
+function describeRuntimeSpecOverride(override) {
+  return Object.keys(RUNTIME_SPEC_ENV).filter((pkg) => override[pkg] !== void 0).map((pkg) => `${RUNTIME_SPEC_ENV[pkg]}=${override[pkg]}`).join(" ");
+}
+var RUNTIME_SPEC_ENV, SHELL_METACHARACTERS, RuntimeSpecOverrideError;
+var init_runtime_spec_override = __esm({
+  "src/runtime-spec-override.ts"() {
+    RUNTIME_SPEC_ENV = {
+      signer: "HAVEN_SIGNER_SPEC",
+      sdk: "HAVEN_SDK_SPEC",
+      mcp: "HAVEN_MCP_SPEC"
+    };
+    SHELL_METACHARACTERS = /[;&|<>$`'"()!#*?[\]{}\\]/;
+    RuntimeSpecOverrideError = class extends Error {
+      code = "runtime_spec_override_invalid";
+      variable;
+      constructor(variable, reason) {
+        super(`${variable} is set but not usable as an npm package spec: ${reason}. Unset it, or set it to a spec npm install accepts (file:/abs/path, a .tgz, or @haven_ai/<pkg>@<version>).`);
+        this.name = "RuntimeSpecOverrideError";
+        this.variable = variable;
+      }
+    };
   }
-  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: path$1, ...startedAt ? { startedAt } : {} };
+});
+async function prepareSignerRuntime(input, deps = {}) {
+  const homeDir = input.homeDir ?? os.homedir();
+  const override = resolveSignerRuntimeOverride(deps.env ?? process.env);
+  const signerSpec = override?.signer ?? signerPackageSpec();
+  const sdkSpec = override?.sdk ?? sdkPackageSpec();
+  const resolvedSpecs = [signerSpec, sdkSpec];
+  const overrideRecord = override ? { specs: override, resolved_specs: resolvedSpecs, directory_key: runtimeSpecOverrideDirectoryKey(resolvedSpecs) } : void 0;
+  const runtimeDirectory = path.resolve(
+    homeDir,
+    ".haven",
+    "signer-runtime",
+    overrideRecord ? overrideRecord.directory_key : MCP_RUNTIME_MANIFEST.signerVersion
+  );
+  const npmCacheDirectory = path.resolve(homeDir, ".haven", "npm-cache");
+  const cliPath = path.join(runtimeDirectory, "node_modules", "@haven_ai", "signer", "dist", "cli.js");
+  const messages = [];
+  if (override) {
+    messages.push(...runtimeSpecOverrideNotice(
+      "signer runtime",
+      override,
+      { signer: signerPackageSpec(), sdk: sdkPackageSpec() },
+      runtimeDirectory
+    ));
   }
-  const expired = expiresAt !== void 0 && Date.parse(expiresAt) < now;
+  await promises.mkdir(runtimeDirectory, { recursive: true, mode: 448 });
+  await promises.chmod(runtimeDirectory, 448).catch(() => void 0);
+  await promises.mkdir(npmCacheDirectory, { recursive: true, mode: 448 });
+  await promises.chmod(npmCacheDirectory, 448).catch(() => void 0);
+  if (override) {
+    await installRuntimePackages(runtimeDirectory, npmCacheDirectory, resolvedSpecs, deps);
+    messages.push(`Installed local Haven signer runtime from override (${resolvedSpecs.join(" ")}).`);
+  } else if (await installedRuntimeMatches(runtimeDirectory, cliPath)) {
+    messages.push(`Using existing local Haven signer runtime ${signerPackageSpec()}.`);
+  } else {
+    await installRuntimePackages(runtimeDirectory, npmCacheDirectory, resolvedSpecs, deps);
+    messages.push(`Installed local Haven signer runtime ${signerPackageSpec()}.`);
+  }
+  await assertFileExists(cliPath, "local Haven signer CLI");
+  const installedVersions = override ? await readInstalledVersions(runtimeDirectory) : void 0;
+  const wrapperPath = path.join(input.credentialDirectory, "bin", "haven-signer.mjs");
+  await writeWrapper({
+    wrapperPath,
+    cliPath,
+    signerPath: input.signerPath,
+    overrideComment: override ? describeRuntimeSpecOverride(override) : void 0
+  });
+  await writeRuntimeSidecar({
+    path: path.join(input.credentialDirectory, "signer-runtime.json"),
+    wrapperPath,
+    runtimeDirectory,
+    npmCacheDirectory,
+    cliPath,
+    serverName: input.serverName,
+    override: overrideRecord,
+    installedVersions
+  });
+  messages.push(`Prepared stable local Haven signer wrapper: ${wrapperPath}`);
   return {
-    state: expired ? "expired" : "pending",
-    path: path$1,
-    agentId,
-    newDelegateAddress,
-    ...startedAt ? { startedAt } : {},
-    ...expiresAt ? { expiresAt } : {}
+    command: wrapperPath,
+    args: [],
+    wrapperPath,
+    runtimeDirectory,
+    npmCacheDirectory,
+    cliPath,
+    messages,
+    ...overrideRecord ? { runtimeSpecOverride: overrideRecord } : {}
   };
 }
-async function clearRekeyPending(directory) {
-  await promises.rm(path.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;
-  }
+function resolveSignerRuntimeOverride(env) {
+  const override = resolveRuntimeSpecOverride(env);
+  if (!overrideApplies(override, ["signer", "sdk"])) return void 0;
+  const { signer, sdk } = override;
+  return { ...signer !== void 0 ? { signer } : {}, ...sdk !== void 0 ? { sdk } : {} };
 }
-async function readRawFile(path) {
+async function installRuntimePackages(runtimeDirectory, npmCacheDirectory, packageSpecs, deps) {
+  const { runCommand, onProgress } = deps;
+  const baseArgs = [
+    "install",
+    "--prefix",
+    runtimeDirectory,
+    "--no-audit",
+    "--no-fund",
+    "--omit=dev",
+    "--prefer-offline",
+    ...packageSpecs
+  ];
+  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 signer 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 execFileAsync("npm", args, { timeout: SIGNER_INSTALL_TIMEOUT_MS, maxBuffer: 1024 * 1024 });
+    } finally {
+      clearInterval(heartbeat);
+    }
+  };
   try {
-    return await promises.readFile(path, "utf8");
+    await run(baseArgs);
   } catch {
-    return null;
+    try {
+      await run([...baseArgs, "--cache", npmCacheDirectory]);
+    } catch (err) {
+      throw new Error(
+        `Could not install local Haven signer runtime ${packageSpecs.join(" ")}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
   }
 }
-function asString(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
+async function installedRuntimeMatches(runtimeDirectory, cliPath) {
+  return installedRuntimeMatchesVersions(runtimeDirectory, cliPath, {
+    signerVersion: MCP_RUNTIME_MANIFEST.signerVersion,
+    sdkVersion: MCP_RUNTIME_MANIFEST.sdkVersion
+  });
 }
-async function assertServerSlugAvailable(serverName, baseDir) {
-  const directory = defaultAgentDirectory(serverName, baseDir);
+async function installedRuntimeMatchesVersions(runtimeDirectory, cliPath, expected) {
   try {
-    await promises.stat(path.join(directory, "identity.json"));
+    await assertFileExists(cliPath, "local Haven signer CLI");
+    const installed = await readInstalledVersions(runtimeDirectory);
+    return installed.signerVersion === expected.signerVersion && installed.sdkVersion === expected.sdkVersion;
   } catch {
-    return;
+    return false;
   }
-  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 = path.join(os.homedir(), ".haven", "agents")) {
-  return path.resolve(defaultCredentialRoot(baseDir), safePathPart(agentId));
-}
-function defaultCredentialRoot(baseDir = path.join(os.homedir(), ".haven", "agents")) {
-  return path.resolve(baseDir);
-}
-async function writeOwnerOnlyJson(path, value, warn) {
-  const json = JSON.stringify(dropUndefined(value), null, 2);
-  await promises.writeFile(path, `${json}
-`, { mode: 384, flag: "wx" });
-  await restrictPermissions(path, 384, warn);
 }
-function safePathPart(value) {
-  return value.replace(/[^A-Za-z0-9_.-]/g, "_");
+async function readInstalledVersions(runtimeDirectory) {
+  const [signerPackage, sdkPackage] = await Promise.all([
+    readPackageJson(path.join(runtimeDirectory, "node_modules", "@haven_ai", "signer", "package.json")),
+    readPackageJson(path.join(runtimeDirectory, "node_modules", "@haven_ai", "sdk", "package.json"))
+  ]);
+  return { signerVersion: signerPackage.version ?? "", sdkVersion: sdkPackage.version ?? "" };
 }
-function dropUndefined(value) {
-  return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== void 0));
+async function readPackageJson(path) {
+  return JSON.parse(await promises.readFile(path, "utf8"));
 }
-async function assertDoesNotExist(path) {
-  try {
-    await promises.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 writeWrapper(input) {
+  await promises.mkdir(path.dirname(input.wrapperPath), { recursive: true, mode: 448 });
+  await promises.chmod(path.dirname(input.wrapperPath), 448).catch(() => void 0);
+  const source = [
+    "#!/usr/bin/env node",
+    ...input.overrideComment ? [`// HAVEN RUNTIME SPEC OVERRIDE (#2424): ${input.overrideComment} \u2014 this wrapper launches a NON-pinned signer build.`] : [],
+    "import { spawn } from 'node:child_process'",
+    "",
+    `const cliPath = ${JSON.stringify(input.cliPath)}`,
+    `const signerPath = ${JSON.stringify(input.signerPath)}`,
+    "",
+    "const child = spawn(process.execPath, [cliPath, '--credentials', 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 promises.writeFile(input.wrapperPath, source, { mode: 448 });
+  await promises.chmod(input.wrapperPath, 448).catch(() => void 0);
 }
-async function restrictPermissions(path, mode, warn) {
+async function readRuntimeSidecar(credentialDirectory) {
   try {
-    await promises.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)}`
+    return JSON.parse(
+      await promises.readFile(path.join(credentialDirectory, "signer-runtime.json"), "utf8")
     );
+  } catch {
+    return null;
   }
 }
-async function writeConnectOutcomeRecord(directory, outcome, warn) {
-  const path$1 = path.join(directory, CONNECT_OUTCOME_FILENAME);
-  await promises.writeFile(path$1, `${JSON.stringify(outcome, null, 2)}
+async function writeRuntimeSidecar(input) {
+  const value = {
+    ...input.serverName ? { server_name: input.serverName } : {},
+    signer_package: MCP_RUNTIME_MANIFEST.signerPackage,
+    signer_version: input.installedVersions?.signerVersion ?? MCP_RUNTIME_MANIFEST.signerVersion,
+    sdk_package: MCP_RUNTIME_MANIFEST.sdkPackage,
+    sdk_version: input.installedVersions?.sdkVersion ?? MCP_RUNTIME_MANIFEST.sdkVersion,
+    wrapper_path: input.wrapperPath,
+    runtime_directory: input.runtimeDirectory,
+    npm_cache_directory: input.npmCacheDirectory,
+    cli_path: input.cliPath,
+    ...input.override ? { runtime_spec_override: input.override } : {}
+  };
+  await promises.writeFile(input.path, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
-  await restrictPermissions(path$1, 384, warn);
-  return path$1;
+  await promises.chmod(input.path, 384).catch(() => void 0);
 }
-async function readConnectOutcomeRuntime(directory) {
+async function assertFileExists(path, label) {
   try {
-    const parsed = JSON.parse(await promises.readFile(path.join(directory, CONNECT_OUTCOME_FILENAME), "utf8"));
-    if (typeof parsed !== "object" || parsed === null) return null;
-    const runtime = parsed.runtime;
-    return typeof runtime === "string" && runtime.length > 0 ? runtime : null;
+    await promises.access(path);
   } catch {
-    return null;
+    throw new Error(`Missing ${label}: ${path}`);
   }
 }
-async function writeMcpServerBinding(directory, binding) {
-  const path$1 = path.join(directory, MCP_SERVER_BINDING_FILENAME);
-  await promises.writeFile(path$1, `${JSON.stringify(binding, null, 2)}
-`, { mode: 384 });
-  return path$1;
-}
-async function readMcpServerBinding(directory) {
-  try {
-    const parsed = JSON.parse(await promises.readFile(path.join(directory, MCP_SERVER_BINDING_FILENAME), "utf8"));
-    if (typeof parsed !== "object" || parsed === null) return null;
-    const record = parsed;
-    if (record.version !== 1 || typeof record.server_name !== "string" || typeof record.agent_id !== "string" || typeof record.api_url !== "string" || typeof record.bound_at !== "string") return null;
-    return record;
-  } catch {
-    return null;
+var execFileAsync, SIGNER_INSTALL_TIMEOUT_MS, SIGNER_INSTALL_HEARTBEAT_MS;
+var init_signer_runtime = __esm({
+  "src/signer-runtime.ts"() {
+    init_runtime_manifest();
+    init_runtime_spec_override();
+    execFileAsync = util.promisify(child_process.execFile);
+    SIGNER_INSTALL_TIMEOUT_MS = 6e5;
+    SIGNER_INSTALL_HEARTBEAT_MS = 15e3;
   }
+});
+
+// src/connect-error.ts
+function isConnectError(err) {
+  return err instanceof ConnectError;
 }
-async function clearMcpServerBinding(directory) {
-  try {
-    await promises.rm(path.join(directory, MCP_SERVER_BINDING_FILENAME));
-    return true;
-  } catch {
-    return false;
+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/tombstone.ts
+var tombstone_exports = {};
+__export(tombstone_exports, {
+  ROOT_TOMBSTONES_DIRNAME: () => ROOT_TOMBSTONES_DIRNAME,
+  TOMBSTONE_FILENAME: () => TOMBSTONE_FILENAME,
+  TOMBSTONE_MARKER: () => TOMBSTONE_MARKER,
+  defaultTombstonesDir: () => defaultTombstonesDir,
+  readAgentTombstone: () => readAgentTombstone,
+  readTombstoneRecords: () => readTombstoneRecords,
+  tombstonesDirForAgentDirectory: () => tombstonesDirForAgentDirectory,
+  tombstonesDirForCredentialRoot: () => tombstonesDirForCredentialRoot,
+  writeAgentTombstone: () => writeAgentTombstone
+});
+function defaultTombstonesDir(baseDir) {
+  return path.join(baseDir ?? path.join(os.homedir(), ".haven"), "tombstones");
 }
-async function listMcpServerBindings(baseDir, excludeDirectory) {
-  const root = defaultCredentialRoot(baseDir);
+function tombstonesDirForCredentialRoot(credentialRoot, homeDir = os.homedir()) {
+  if (!credentialRoot) return defaultTombstonesDir(path.join(homeDir, ".haven"));
+  const root = path.resolve(credentialRoot);
+  if (root === path.resolve(homeDir, ".haven", "agents")) return defaultTombstonesDir(path.join(homeDir, ".haven"));
+  return path.join(root, ROOT_TOMBSTONES_DIRNAME);
+}
+function tombstonesDirForAgentDirectory(directory, homeDir = os.homedir()) {
+  return tombstonesDirForCredentialRoot(path.dirname(path.resolve(directory)), homeDir);
+}
+async function readTombstoneRecords(tombstonesDir) {
+  const root = tombstonesDir ?? defaultTombstonesDir();
   let entries = [];
   try {
     entries = await promises.readdir(root);
   } catch {
     return [];
   }
-  const out = [];
+  const records = [];
   for (const entry of entries) {
-    const directory = path.join(root, entry);
-    const binding = await readMcpServerBinding(directory);
-    if (binding) out.push({ directory, binding });
+    if (!entry.endsWith(".json")) continue;
+    const recordPath = path.join(root, entry);
+    try {
+      const parsed = JSON.parse(await promises.readFile(recordPath, "utf8"));
+      if (typeof parsed?.agent_id === "string") {
+        records.push({ ...parsed, recordPath });
+      }
+    } catch {
+    }
   }
-  return out;
+  return records;
 }
-var REKEY_PENDING_FILENAME, REKEY_PENDING_TTL_MS, CONNECT_OUTCOME_FILENAME, MCP_SERVER_BINDING_FILENAME;
-var init_storage = __esm({
-  "src/storage.ts"() {
-    REKEY_PENDING_FILENAME = "rekey-pending.json";
-    REKEY_PENDING_TTL_MS = 24 * 60 * 60 * 1e3;
-    CONNECT_OUTCOME_FILENAME = "last-connect-outcome.json";
-    MCP_SERVER_BINDING_FILENAME = "mcp-server-binding.json";
-  }
-});
-function mcpPackageSpec() {
-  return `${MCP_RUNTIME_MANIFEST.mcpPackage}@${MCP_RUNTIME_MANIFEST.mcpVersion}`;
+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: ${sdk.connectorRerunCommand("--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");
 }
-function sdkPackageSpec() {
-  return `${MCP_RUNTIME_MANIFEST.sdkPackage}@${MCP_RUNTIME_MANIFEST.sdkVersion}`;
+async function writeAgentTombstone(input) {
+  const dirStat = await promises.stat(input.directory).catch(() => null);
+  if (!dirStat?.isDirectory()) {
+    throw new ConnectError(
+      "tombstone_directory_not_found",
+      `Not a directory: ${input.directory} \u2014 nothing to tombstone. Agent directories are named by their wiring SLUG when the agent has one, and by the agent id otherwise \u2014 so a path built from an agent id will not exist for a named agent. List ~/.haven/agents (or read the directories from --doctor --json) and pass one of those.`,
+      "retry_with_an_existing_agent_directory"
+    );
+  }
+  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 = path.join(input.directory, "bin");
+  await promises.mkdir(binDir, { recursive: true });
+  const wrapperPath = path.join(binDir, "haven-signer.mjs");
+  await promises.writeFile(wrapperPath, tombstoneScript(info), "utf8");
+  await promises.chmod(wrapperPath, 493);
+  const record = JSON.stringify(info, null, 2) + "\n";
+  await promises.writeFile(path.join(input.directory, TOMBSTONE_FILENAME), record, "utf8");
+  const root = input.tombstonesDir ?? defaultTombstonesDir();
+  const recordPath = path.join(root, `${info.agent_id}.json`);
+  try {
+    await promises.mkdir(root, { recursive: true, mode: 448 });
+    await promises.writeFile(recordPath, record, { mode: MIRROR_MODE });
+  } catch (err) {
+    const code = err?.code;
+    return { ...info, recordPath: null, mirrorError: typeof code === "string" && /^E[A-Z]+$/.test(code) ? code : "mirror_write_failed" };
+  }
+  return { ...info, recordPath };
 }
-function signerPackageSpec() {
-  return `${MCP_RUNTIME_MANIFEST.signerPackage}@${MCP_RUNTIME_MANIFEST.signerVersion}`;
+async function readAgentTombstone(directory) {
+  try {
+    const parsed = JSON.parse(await promises.readFile(path.join(directory, TOMBSTONE_FILENAME), "utf8"));
+    if (typeof parsed?.agent_id !== "string") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
 }
-var MCP_RUNTIME_MANIFEST;
-var init_runtime_manifest = __esm({
-  "src/runtime-manifest.ts"() {
-    MCP_RUNTIME_MANIFEST = {
-      mcpPackage: "@haven_ai/mcp",
-      mcpVersion: mcp.MCP_VERSION,
-      sdkPackage: "@haven_ai/sdk",
-      sdkVersion: "0.8.1-alpha.0",
-      signerPackage: "@haven_ai/signer",
-      signerVersion: "0.8.1-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: sdk.HAVEN_MINIMUM_NODE_VERSION,
-      supportedClients: ["codex-cli", "codex-desktop", "claude-code"],
-      requiredTools: mcp.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(signer.toolSchemas)
-    };
+var TOMBSTONE_FILENAME, ROOT_TOMBSTONES_DIRNAME, MIRROR_MODE, TOMBSTONE_MARKER;
+var init_tombstone = __esm({
+  "src/tombstone.ts"() {
+    init_redact();
+    init_connect_error();
+    TOMBSTONE_FILENAME = "TOMBSTONE.json";
+    ROOT_TOMBSTONES_DIRNAME = ".tombstones";
+    MIRROR_MODE = 384;
+    TOMBSTONE_MARKER = "HAVEN-TOMBSTONE";
   }
 });
-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"
-      };
+
+// src/storage.ts
+var storage_exports = {};
+__export(storage_exports, {
+  CONNECT_OUTCOME_FILENAME: () => CONNECT_OUTCOME_FILENAME,
+  MCP_SERVER_BINDING_FILENAME: () => MCP_SERVER_BINDING_FILENAME,
+  REKEY_PENDING_FILENAME: () => REKEY_PENDING_FILENAME,
+  REKEY_PENDING_TTL_MS: () => REKEY_PENDING_TTL_MS,
+  assertDirectoryRecordsSlug: () => assertDirectoryRecordsSlug,
+  assertServerSlugAvailable: () => assertServerSlugAvailable,
+  clearMcpServerBinding: () => clearMcpServerBinding,
+  clearRekeyPending: () => clearRekeyPending,
+  defaultAgentDirectory: () => defaultAgentDirectory,
+  defaultCredentialRoot: () => defaultCredentialRoot,
+  inspectRekeyPending: () => inspectRekeyPending,
+  listMcpServerBindings: () => listMcpServerBindings,
+  preflightCredentialStorage: () => preflightCredentialStorage,
+  readConnectOutcomeRuntime: () => readConnectOutcomeRuntime,
+  readMcpServerBinding: () => readMcpServerBinding,
+  readRekeyPending: () => readRekeyPending,
+  readStoredAccountAddress: () => readStoredAccountAddress,
+  readStoredCredentials: () => readStoredCredentials,
+  resolveAgentDirectoryBySlug: () => resolveAgentDirectoryBySlug,
+  rewriteCredentialFiles: () => rewriteCredentialFiles,
+  writeConnectOutcomeRecord: () => writeConnectOutcomeRecord,
+  writeCredentialFiles: () => writeCredentialFiles,
+  writeMcpServerBinding: () => writeMcpServerBinding,
+  writeRekeyPending: () => writeRekeyPending
+});
+async function preflightCredentialStorage(input = {}) {
+  const directory = defaultCredentialRoot(input.baseDir);
+  await promises.mkdir(directory, { recursive: true, mode: 448 });
+  await restrictPermissions(directory, 448, input.warn);
+  const probePath = path.join(directory, `.haven-connect-preflight-${crypto__default.default.randomBytes(8).toString("hex")}`);
+  try {
+    await writeOwnerOnlyJson(probePath, { ok: true }, input.warn);
+  } finally {
+    await promises.rm(probePath, { force: true }).catch(() => void 0);
   }
+  return directory;
 }
-function buildHostedServer(hostedMcpUrl, apiKey, runtime) {
-  if (runtime === "vscode" || runtime === "vscode-insiders") {
-    return {
-      type: "http",
-      url: hostedMcpUrl,
-      headers: { Authorization: `Bearer ${apiKey}` }
-    };
+async function writeCredentialFiles(input) {
+  const directory = defaultAgentDirectory(input.serverName ?? input.agentId, input.baseDir);
+  await promises.mkdir(directory, { recursive: true, mode: 448 });
+  await restrictPermissions(directory, 448, input.warn);
+  const identityPath = path.join(directory, "identity.json");
+  const signerPath = path.join(directory, "signer.json");
+  const agentPath = path.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 promises.rm(signerPath, { force: true }).catch(() => void 0);
+    throw err;
+  }
+  try {
+    await writeOwnerOnlyJson(agentPath, agentPayload(input), input.warn);
+  } catch (err) {
+    await promises.rm(signerPath, { force: true }).catch(() => void 0);
+    await promises.rm(identityPath, { force: true }).catch(() => void 0);
+    await promises.rm(agentPath, { force: true }).catch(() => void 0);
+    throw err;
   }
+  return { directory, identityPath, signerPath, agentPath };
+}
+function signerPayload(input) {
   return {
-    url: hostedMcpUrl,
-    headers: { Authorization: `Bearer ${apiKey}` }
+    delegate_key: input.delegateKey,
+    delegate_address: input.delegateAddress,
+    agent_id: input.agentId,
+    account_address: input.accountAddress,
+    chain_id: input.chainId,
+    network: input.network,
+    x402_binding_signer: input.x402BindingSigner,
+    note: "Local signer credential. Haven backend never receives this private key."
   };
 }
-function resolveSignerLaunchSpec(input) {
-  return input.signerCommand ?? {
-    command: "npx",
-    args: ["-y", signerPackageSpec(), "--credentials", input.signerPath]
+function identityPayload(input) {
+  return {
+    api_key: input.apiKey,
+    agent_id: input.agentId,
+    account_address: input.accountAddress,
+    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."
   };
 }
-function buildSignerServer(spec, runtime) {
-  const server = {
-    command: spec.command,
-    args: spec.args
+function agentPayload(input) {
+  return {
+    agent_id: input.agentId,
+    delegate_address: input.delegateAddress,
+    account_address: input.accountAddress,
+    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."
   };
-  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
+async function readStoredCredentials(serverName, agentIdOrSlug, baseDir) {
+  const directory = serverName ? await resolveAgentDirectoryBySlug(serverName, { root: baseDir }) : agentIdOrSlug ? defaultAgentDirectory(agentIdOrSlug, baseDir) : await discoverSoleAgentDirectory(baseDir);
+  const identity = await readJsonFile(path.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.`
+    );
+  }
+  let discoveredSlug;
+  if (!serverName && !agentIdOrSlug) {
+    const binding = await readJsonFile(path.join(directory, "mcp-server-binding.json"));
+    const hostedName = binding && typeof binding === "object" ? asString(binding.server_name) : void 0;
+    if (hostedName && hostedName.startsWith("haven-")) {
+      const slug = hostedName.slice("haven-".length);
+      try {
+        assertValidServerSlug(slug);
+        discoveredSlug = slug;
+      } catch {
+      }
+    }
+  }
+  const agent = await readJsonFile(path.join(directory, "agent.json")) ?? {};
+  const signer = await readJsonFile(path.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,
+    ...discoveredSlug ? { discoveredSlug } : {},
+    apiUrl,
+    hostedMcpUrl,
+    delegateAddress: asString(agent.delegate_address) ?? asString(signer.delegate_address),
+    ...readStoredAccountAddress(identity, agent),
+    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
   };
-  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 });
+function readStoredAccountAddress(identity, agent) {
+  const fresh = asString(identity.account_address) ?? asString(agent.account_address);
+  if (fresh) return { accountAddress: fresh, accountAddressKey: "account_address" };
+  const legacy = asString(identity.safe_address) ?? asString(agent.safe_address);
+  if (legacy) return { accountAddress: legacy, accountAddressKey: "safe_address" };
+  return {};
+}
+async function discoverSoleAgentDirectory(baseDir) {
+  const root = defaultCredentialRoot(baseDir);
+  let entries = [];
+  try {
+    entries = await promises.readdir(root);
+  } catch {
+    throw new Error(`No Haven credentials found under ${root}. Connect an agent on this machine first.`);
   }
-  const doc = yaml.parseDocument(existingYaml, { keepSourceTokens: true });
-  if (doc.errors.length > 0 || !yaml.isMap(doc.contents)) {
-    throw new UnreadableRuntimeConfigError(configPath ?? "the Hermes config", "it is not a YAML object");
+  const candidates = [];
+  for (const entry of entries) {
+    const directory = path.join(root, entry);
+    const identity = await readJsonFile(path.join(directory, "identity.json"));
+    if (!identity) continue;
+    if (!asString(identity.api_key)) continue;
+    if (await readJsonFile(path.join(directory, "TOMBSTONE.json"))) continue;
+    candidates.push(directory);
   }
-  const mcpPair = doc.contents.items.find((item) => item.key?.toString() === "mcp_servers");
-  const existingServers = mcpPair && yaml.isMap(mcpPair.value) ? mcpPair.value.toJSON() : {};
-  const servers = isRecord(existingServers) ? existingServers : {};
-  const mergedServers = {
-    ...servers,
-    [names.hosted]: hostedServer,
-    [names.signer]: signerServer
-  };
-  if (!mcpPair) {
-    return appendHermesMcpServers(existingYaml, mergedServers);
+  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.`);
   }
-  if (!mcpPair.value?.range) return replaceEmptyHermesMcpServers(existingYaml, mcpPair.key?.range, mergedServers);
-  return replaceHermesMcpServers(existingYaml, mcpPair.key?.range, mcpPair.value.range, mergedServers);
+  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."
+  );
 }
-function mergeHermesEnv(existingEnv, apiKey, envKey = HERMES_API_KEY_ENV) {
-  if (/[\r\n]/.test(apiKey)) throw new Error("Hermes API key must be a single line");
-  const assignment = `${envKey}=${apiKey}`;
-  if (!existingEnv) return `${assignment}
-`;
-  const lineEnding = existingEnv.includes("\r\n") ? "\r\n" : "\n";
-  const hasTrailingNewline = /\r?\n$/.test(existingEnv);
-  const lines = existingEnv.split(/\r?\n/);
-  if (hasTrailingNewline) lines.pop();
-  let found = false;
-  const merged = lines.flatMap((line) => {
-    if (isHermesEnvAssignment(line, envKey)) {
-      if (found) return [];
-      found = true;
-      return [assignment];
-    }
-    if (isAmbiguousHermesEnvLine(line, envKey)) {
-      throw new Error("Hermes environment contains an ambiguous managed key");
+async function assertDirectoryRecordsSlug(directory, slug) {
+  assertValidServerSlug(slug);
+  const sidecar = await readRuntimeSidecar(directory);
+  const bindingRecord = await readJsonFile(path.join(directory, "mcp-server-binding.json"));
+  const bindingSlug = bindingRecord ? asString(bindingRecord.server_name) : void 0;
+  const claimed = sidecar?.server_name ?? bindingSlug;
+  if (claimed === slug) return;
+  if (!claimed && path.basename(directory) === slug) return;
+  throw new Error(
+    `--name ${slug} and --credentials-dir ${directory} disagree: that directory records ` + (claimed ? `the pair 'haven-${claimed}'` : "no named pair") + `. Pass one of them, not both \u2014 or point --credentials-dir at the directory that records 'haven-${slug}'.`
+  );
+}
+async function resolveAgentDirectoryBySlug(slug, opts = {}) {
+  assertValidServerSlug(slug);
+  const root = defaultCredentialRoot(opts.root);
+  let entries = [];
+  try {
+    entries = await promises.readdir(root);
+  } catch {
+    throw new Error(
+      `No agent directories under ${root} \u2014 nothing records the pair 'haven-${slug}'. Connect this agent first, or pass --credentials-dir <path> for the exact directory.`
+    );
+  }
+  const claims = [];
+  const recordedSlugs = [];
+  let barePairCount = 0;
+  let legacyFolder;
+  for (const entry of entries.sort()) {
+    const directory = path.join(root, entry);
+    const retired = await readJsonFile(path.join(directory, TOMBSTONE_FILENAME)) !== null;
+    const sidecar = await readRuntimeSidecar(directory);
+    const bindingRecord = await readJsonFile(path.join(directory, "mcp-server-binding.json"));
+    const bindingSlug = bindingRecord ? asString(bindingRecord.server_name) : void 0;
+    const claimedSlug = sidecar?.server_name ?? bindingSlug;
+    if (claimedSlug && !recordedSlugs.includes(claimedSlug)) recordedSlugs.push(claimedSlug);
+    if (sidecar && !sidecar.server_name) barePairCount++;
+    if (retired && !opts.allowRetired) continue;
+    if (claimedSlug === slug) {
+      const identity = await readJsonFile(path.join(directory, "identity.json"));
+      claims.push({ directory, agentId: identity ? asString(identity.agent_id) ?? null : null, retired });
     }
-    return [line];
-  });
-  if (!found) {
-    return `${existingEnv}${hasTrailingNewline ? "" : lineEnding}${assignment}${lineEnding}`;
+    if (!claimedSlug && !retired && entry === slug) legacyFolder = directory;
   }
-  return `${merged.join(lineEnding)}${hasTrailingNewline ? lineEnding : ""}`;
-}
-function isHermesEnvAssignment(line, envKey) {
-  return new RegExp(`^\\s*(?:export[ \\t]+)?${envKey}[ \\t]*=`).test(line);
-}
-function isAmbiguousHermesEnvLine(line, envKey) {
-  return new RegExp(`^\\s*(?:export[ \\t]+)?${envKey}\\b`).test(line);
+  if (claims.length > 1) {
+    throw new Error(
+      `${claims.length} agent directories on this machine record the pair 'haven-${slug}' \u2014 the MCP server name changed hands (mcp_server_name_rebound):
+` + claims.map((c) => `  \u2022 ${c.agentId ? `agent ${c.agentId}` : "agent (no agent_id recorded)"} \u2014 ${c.directory}${c.retired ? " (retired)" : ""}`).join("\n") + "\nRetire the earlier one with --unwire, or name the directory exactly with --credentials-dir <path>. Nothing was changed."
+    );
+  }
+  if (claims.length === 1) return claims[0].directory;
+  if (legacyFolder) return legacyFolder;
+  const known = [
+    ...recordedSlugs.map((s) => `'haven-${s}'`),
+    ...barePairCount > 0 ? [`${barePairCount} unnamed 'haven' / 'haven-signer' pair${barePairCount === 1 ? "" : "s"} (no --name)`] : []
+  ];
+  throw new Error(
+    `No agent directory on this machine records the pair 'haven-${slug}'.` + (known.length > 0 ? ` Directories under ${root} record: ${known.join(", ")}.` : ` Nothing under ${root} records a named pair.`) + " Check the agent id against the Haven agent page, or name the directory exactly with --credentials-dir <path>."
+  );
 }
-function removeHermesYaml(existingYaml, names, configPath) {
-  if (!existingYaml?.trim()) return existingYaml ?? "";
-  const doc = yaml.parseDocument(existingYaml, { keepSourceTokens: true });
-  if (doc.errors.length > 0 || !yaml.isMap(doc.contents)) {
-    throw new UnreadableRuntimeConfigError(configPath ?? "the Hermes config", "it is not a YAML object");
+async function rewriteCredentialFiles(input) {
+  const directory = defaultAgentDirectory(input.serverName ?? input.agentId, input.baseDir);
+  const identityPath = path.join(directory, "identity.json");
+  const signerPath = path.join(directory, "signer.json");
+  const agentPath = path.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 mcpPair = doc.contents.items.find((item) => item.key?.toString() === "mcp_servers");
-  if (!mcpPair || !yaml.isMap(mcpPair.value)) return existingYaml;
-  const toRemove = mcpPair.value.items.filter((item) => {
-    const name = item.key?.toString();
-    return name === names.hosted || name === names.signer;
-  });
-  if (toRemove.length === 0) return existingYaml;
-  if (toRemove.length !== mcpPair.value.items.length && toRemove.some((item) => !item.key?.range || !item.value?.range)) {
-    throw new UnreadableRuntimeConfigError(configPath ?? "the Hermes config", "an MCP server entry cannot be safely removed");
-  }
-  let out = existingYaml;
-  const ranges = toRemove.map((item) => {
-    const keyStart = item.key.range[0];
-    const valueEnd = item.value.range[1];
-    const lineStart = existingYaml.lastIndexOf("\n", keyStart - 1) + 1;
-    let end = valueEnd;
-    if (existingYaml.slice(end).startsWith("\r\n")) end += 2;
-    else if (existingYaml[end] === "\n") end += 1;
-    return [lineStart, end];
-  });
-  ranges.sort((a, b) => b[0] - a[0]);
-  for (const [start, end] of ranges) out = out.slice(0, start) + out.slice(end);
-  if (toRemove.length === mcpPair.value.items.length) {
-    const reparsed = yaml.parseDocument(out, { keepSourceTokens: true });
-    if (!reparsed.errors.length && yaml.isMap(reparsed.contents)) {
-      const pair = reparsed.contents.items.find((item) => item.key?.toString() === "mcp_servers");
-      if (pair && pair.key?.range && pair.value?.range) {
-        const keyStart = pair.key.range[0];
-        const valueEnd = pair.value.range[1];
-        const lineStart = out.lastIndexOf("\n", keyStart - 1) + 1;
-        let end = valueEnd;
-        if (out.slice(end).startsWith("\r\n")) end += 2;
-        else if (out[end] === "\n") end += 1;
-        out = out.slice(0, lineStart) + out.slice(end);
+  const temps = [];
+  try {
+    for (const { path, payload } of targets) {
+      const temp = `${path}.rekey-${crypto__default.default.randomBytes(6).toString("hex")}.tmp`;
+      await writeOwnerOnlyJson(temp, payload, input.warn);
+      temps.push({ from: temp, to: path });
+    }
+    for (const { from, to } of temps) {
+      await promises.rename(from, to);
+    }
+  } catch (err) {
+    for (const { from } of temps) await promises.rm(from, { force: true }).catch(() => void 0);
+    for (const [path, contents] of originals) {
+      if (contents === null) {
+        await promises.rm(path, { force: true }).catch(() => void 0);
+      } else {
+        await promises.writeFile(path, contents, { mode: 384 }).catch(() => void 0);
       }
     }
+    throw err;
   }
-  return out;
+  return { directory, identityPath, signerPath, agentPath };
 }
-function removeHermesEnv(existingEnv, envKey) {
-  if (!existingEnv) return "";
-  const lineEnding = existingEnv.includes("\r\n") ? "\r\n" : "\n";
-  const hasTrailingNewline = /\r?\n$/.test(existingEnv);
-  const lines = existingEnv.split(/\r?\n/);
-  if (hasTrailingNewline) lines.pop();
-  let removed = 0;
-  const kept = lines.filter((line) => {
-    if (isHermesEnvAssignment(line, envKey)) {
-      removed += 1;
-      return false;
-    }
-    if (isAmbiguousHermesEnvLine(line, envKey)) {
-      throw new Error("Hermes environment contains an ambiguous managed key");
-    }
-    return true;
-  });
-  if (removed === 0) return existingEnv;
-  const joined = kept.join(lineEnding);
-  return hasTrailingNewline ? `${joined}${lineEnding}` : joined;
+async function writeRekeyPending(directory, pending, warn) {
+  const path$1 = path.join(directory, REKEY_PENDING_FILENAME);
+  await promises.rm(path$1, { force: true }).catch(() => void 0);
+  await writeOwnerOnlyJson(path$1, { ...pending }, warn);
+  return path$1;
 }
-function removeJsonMcpConfig(existingJson, serverRoot, names, configPath) {
-  if (!existingJson?.trim()) return existingJson ?? "";
-  const config = parseJsonObject(existingJson, configPath);
-  const root = config[serverRoot];
-  if (!root || typeof root !== "object" || Array.isArray(root)) return existingJson;
-  const servers = root;
-  let removed = false;
-  for (const name of [names.hosted, names.signer]) {
-    if (name in servers) {
-      delete servers[name];
-      removed = true;
-    }
+async function readRekeyPending(directory, now = Date.now()) {
+  const path$1 = path.join(directory, REKEY_PENDING_FILENAME);
+  const raw = await readJsonFile(path$1);
+  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.`
+    );
   }
-  if (!removed) return existingJson;
-  if (Object.keys(servers).length === 0) delete config[serverRoot];
-  return `${JSON.stringify(config, null, 2)}
-`;
+  const pending = raw;
+  if (!pending.new_delegate_key || !pending.new_delegate_address || !pending.agent_id) {
+    throw new Error(`The pending re-key at ${path$1} 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;
 }
-function removeCodexToml(existingToml, names) {
-  let next = removeTomlTableTree(
-    removeTomlTableTree(existingToml, `mcp_servers.${names.codexHosted}`),
-    `mcp_servers.${names.codexSigner}`
-  );
-  return next;
+async function inspectRekeyPending(directory, now = Date.now()) {
+  const path$1 = path.join(directory, REKEY_PENDING_FILENAME);
+  const raw = await readJsonFile(path$1);
+  if (!raw) {
+    const present = await readRawFile(path$1) !== null;
+    return present ? { state: "unreadable", path: path$1 } : 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: path$1, ...startedAt ? { startedAt } : {} };
+  }
+  const expired = expiresAt !== void 0 && Date.parse(expiresAt) < now;
+  return {
+    state: expired ? "expired" : "pending",
+    path: path$1,
+    agentId,
+    newDelegateAddress,
+    ...startedAt ? { startedAt } : {},
+    ...expiresAt ? { expiresAt } : {}
+  };
 }
-function appendHermesMcpServers(source, servers) {
-  const documentEnd = /(?:^|\n)[ \t]*\.\.\.[ \t]*(?:#[^\n]*)?\r?\n?$/.exec(source);
-  if (documentEnd) {
-    const markerStart = documentEnd.index + (documentEnd[0].startsWith("\n") ? 1 : 0);
-    const beforeMarker = source.slice(0, markerStart);
-    return `${beforeMarker}${beforeMarker.endsWith("\n") ? "" : "\n"}${renderHermesMcpServers(servers, "")}
-${source.slice(markerStart)}`;
+async function clearRekeyPending(directory) {
+  await promises.rm(path.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;
   }
-  const separator = source.endsWith("\n") ? "" : "\n";
-  return `${source}${separator}${renderHermesMcpServers(servers, "")}
-`;
 }
-function replaceHermesMcpServers(source, keyRange, valueRange, servers) {
-  const valueStart = valueRange[0];
-  const valueEnd = valueRange[1];
-  const valueLineStart = source.lastIndexOf("\n", valueStart - 1) + 1;
-  const keyStartsOnValueLine = keyRange?.[0] !== void 0 && keyRange[0] >= valueLineStart;
-  const nestedIndent = `${source.slice(valueLineStart, keyRange?.[0] ?? valueLineStart)}  `;
-  if (keyStartsOnValueLine) {
-    const keyStart = keyRange[0];
-    const keyEnd = keyRange[1];
-    const replacement2 = `${source.slice(keyStart, keyEnd)}:
-${renderHermesMcpServerEntries(servers, nestedIndent)}`;
-    const needsTrailingNewline2 = valueEnd < source.length && !source.slice(valueEnd).startsWith("\n");
-    return `${source.slice(0, keyStart)}${replacement2}${needsTrailingNewline2 ? "\n" : ""}${source.slice(valueEnd)}`;
+async function readRawFile(path) {
+  try {
+    return await promises.readFile(path, "utf8");
+  } catch {
+    return null;
   }
-  const indent = source.slice(valueLineStart, valueStart);
-  const rendered = yaml.stringify(servers, { lineWidth: 120 }).trimEnd();
-  const replacement = rendered.split("\n").map((line, index) => index === 0 ? line : `${indent}${line}`).join("\n");
-  const needsTrailingNewline = valueEnd < source.length && !source.slice(valueEnd).startsWith("\n");
-  return `${source.slice(0, valueStart)}${replacement}${needsTrailingNewline ? "\n" : ""}${source.slice(valueEnd)}`;
 }
-function replaceEmptyHermesMcpServers(source, keyRange, servers) {
-  if (!keyRange) throw new Error("Hermes config mcp_servers key is invalid");
-  const keyStart = keyRange[0];
-  const keyEnd = keyRange[1];
-  const lineStart = source.lastIndexOf("\n", keyStart - 1) + 1;
-  const lineEnd = source.indexOf("\n", keyEnd);
-  const nestedIndent = `${source.slice(lineStart, keyStart)}  `;
-  const replacement = `${source.slice(keyStart, keyEnd)}:
-${renderHermesMcpServerEntries(servers, nestedIndent)}`;
-  return `${source.slice(0, keyStart)}${replacement}${lineEnd === -1 ? "\n" : source.slice(lineEnd)}`;
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function renderHermesYaml(servers) {
-  return `${renderHermesMcpServers(servers, "")}
-`;
+async function assertServerSlugAvailable(serverName, baseDir) {
+  const directory = defaultAgentDirectory(serverName, baseDir);
+  try {
+    await promises.stat(path.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 renderHermesMcpServers(servers, indent) {
-  return `mcp_servers:
-${renderHermesMcpServerEntries(servers, `${indent}  `)}`;
+function defaultAgentDirectory(agentId, baseDir = path.join(os.homedir(), ".haven", "agents")) {
+  return path.resolve(defaultCredentialRoot(baseDir), safePathPart(agentId));
 }
-function renderHermesMcpServerEntries(servers, indent) {
-  return yaml.stringify(servers, { lineWidth: 120 }).trimEnd().split("\n").map((line) => `${indent}${line}`).join("\n");
+function defaultCredentialRoot(baseDir = path.join(os.homedir(), ".haven", "agents")) {
+  return path.resolve(baseDir);
 }
-function isRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+async function writeOwnerOnlyJson(path, value, warn) {
+  const json = JSON.stringify(dropUndefined(value), null, 2);
+  await promises.writeFile(path, `${json}
+`, { mode: 384, flag: "wx" });
+  await restrictPermissions(path, 384, warn);
 }
-function mergeCodexToml(existingToml, localMcpCommand, names = serverNamesFor()) {
-  let next = removeTomlTableTree(
-    removeTomlTableTree(existingToml, `mcp_servers.${names.codexHosted}`),
-    `mcp_servers.${names.codexSigner}`
-  );
-  next = next.trimEnd();
-  const block = [
-    `[mcp_servers.${names.codexHosted}]`,
-    `command = ${tomlString(localMcpCommand)}`,
-    "args = []",
-    "startup_timeout_sec = 120"
-  ].join("\n");
-  validateCodexToml(block, "Generated Codex Haven config");
-  const merged = `${next ? `${next}
-
-` : ""}${block}
-`;
-  return merged;
+function safePathPart(value) {
+  return value.replace(/[^A-Za-z0-9_.-]/g, "_");
 }
-function mergeCodexTomlHosted(existingToml, hostedMcpUrl, apiKey, signerSpec, names = serverNamesFor()) {
-  let next = removeTomlTableTree(
-    removeTomlTableTree(existingToml, `mcp_servers.${names.codexHosted}`),
-    `mcp_servers.${names.codexSigner}`
-  );
-  next = next.trimEnd();
-  const block = [
-    `[mcp_servers.${names.codexHosted}]`,
-    `url = ${tomlString(hostedMcpUrl)}`,
-    `http_headers = { "Authorization" = ${tomlString(`Bearer ${apiKey}`)} }`,
-    "",
-    `[mcp_servers.${names.codexSigner}]`,
-    `command = ${tomlString(signerSpec.command)}`,
-    `args = [${signerSpec.args.map((arg) => tomlString(arg)).join(", ")}]`,
-    "startup_timeout_sec = 120"
-  ].join("\n");
-  validateCodexToml(block, "Generated Codex Haven config");
-  const merged = `${next ? `${next}
-
-` : ""}${block}
-`;
-  return merged;
+function dropUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== void 0));
 }
-async function writeJsonRuntimeConfig(input, target, serverRoot) {
+async function assertDoesNotExist(path) {
   try {
-    const existing = await readOptional(target);
-    const merged = mergeJsonMcpConfig(
-      existing,
-      serverRoot,
-      buildHostedServer(input.hostedMcpUrl, input.apiKey, input.runtime),
-      buildSignerServer(resolveSignerLaunchSpec(input), input.runtime),
-      serverNamesFor(input.serverName),
-      target
-    );
-    await writeOwnerOnlyText(target, merged);
-    return {
-      hostedConfigured: true,
-      signerConfigured: true,
-      localMcpConfigured: false,
-      runtimeMcpMode: "hosted_plus_signer",
-      target: configTargetLabel(input.runtime),
-      changed: existing !== merged,
-      restartRequired: input.runtime === "claude-desktop",
-      messages: [`Updated Haven MCP entries in ${configTargetLabel(input.runtime)}.`]
-    };
+    await promises.access(path);
   } catch (err) {
-    const unreadable = err instanceof UnreadableRuntimeConfigError;
-    return {
-      hostedConfigured: false,
-      signerConfigured: false,
-      localMcpConfigured: false,
-      runtimeMcpMode: "hosted_plus_signer",
-      target: configTargetLabel(input.runtime),
-      changed: false,
-      restartRequired: true,
-      messages: unreadable ? [
-        `Could not update ${configTargetLabel(input.runtime)}: ${err.message}.`,
-        `Nothing was written to ${err.configPath}. Fix the JSON there (or move the file aside), then run \`${REPAIR_COMMAND_PREFIX} ${input.runtime}\` to write the Haven entries from the credentials already stored on this machine. Do not re-run the connector command: its setup token is already used.`
-      ] : [`Could not update ${configTargetLabel(input.runtime)}: ${err instanceof Error ? err.message : String(err)}`],
-      errorCode: unreadable ? "runtime_config_unreadable" : "runtime_config_write_failed"
-    };
+    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 writeHermesConfig(input, deps) {
-  const target = hermesConfigPath(input.homeDir);
-  const envTarget = hermesEnvPath(input.homeDir);
+async function restrictPermissions(path, mode, warn) {
   try {
-    const [existing, existingEnv] = await Promise.all([readOptional(target), readOptional(envTarget)]);
-    const names = serverNamesFor(input.serverName);
-    const hostedServer = {
-      ...buildHostedServer(input.hostedMcpUrl, `\${${names.hermesEnvKey}}`, input.runtime),
-      enabled: true
-    };
-    const signerServer = {
-      ...buildSignerServer(resolveSignerLaunchSpec(input), input.runtime),
-      enabled: true
-    };
-    const merged = mergeHermesYaml(
-      existing,
-      hostedServer,
-      signerServer,
-      names,
-      target
-    );
-    const mergedEnv = mergeHermesEnv(existingEnv, input.apiKey, names.hermesEnvKey);
-    const writeText = deps.writeOwnerOnlyText ?? writeOwnerOnlyText;
-    await writeText(envTarget, mergedEnv);
-    try {
-      await writeText(target, merged);
-    } catch (err) {
-      const recovered = await restoreHermesFiles(target, existing, envTarget, existingEnv, writeText);
-      if (!recovered) throw new HermesConfigRecoveryError();
-      throw err;
-    }
-    return {
-      hostedConfigured: true,
-      signerConfigured: true,
-      localMcpConfigured: false,
-      runtimeMcpMode: "hosted_plus_signer",
-      target: "Hermes Agent config",
-      changed: existing !== merged || existingEnv !== mergedEnv,
-      restartRequired: true,
-      messages: [
-        `Updated Haven MCP entries in ${target}; stored the hosted MCP identity in ${envTarget}.`,
-        "Restart Hermes (start a new session; gateway users: /restart), then verify with `hermes mcp list`, `hermes mcp test haven`, and `hermes mcp test haven-signer`.",
-        "If several long-lived Hermes processes are running (a gateway plus TUI workers), restart EVERY one: each loads its MCP wiring at startup, so a process started before this setup keeps using its old snapshot.",
-        "If no mcp_* tools appear after restart, ensure the MCP SDK is installed in Hermes: pip install mcp"
-      ]
-    };
+    await promises.chmod(path, mode);
   } catch (err) {
-    const recoveryIncomplete = err instanceof HermesConfigRecoveryError;
-    const unreadable = err instanceof UnreadableRuntimeConfigError;
-    return {
-      hostedConfigured: false,
-      signerConfigured: false,
-      localMcpConfigured: false,
-      runtimeMcpMode: "hosted_plus_signer",
-      target: "Hermes Agent config",
-      changed: false,
-      restartRequired: true,
-      messages: unreadable ? [
-        `Could not update Hermes Agent config: ${err.message}.`,
-        `Nothing was written to ${err.configPath}. Fix the YAML there (or move the file aside), then run \`${REPAIR_COMMAND_PREFIX} hermes\` to write the Haven entries from the credentials already stored on this machine. Do not re-run the connector command: its setup token is already used.`
-      ] : [recoveryIncomplete ? "Could not update Hermes Agent config. Recovery did not complete; inspect the Hermes configuration before retrying." : "Could not update Hermes Agent config. Existing configuration was left unchanged."],
-      errorCode: unreadable ? "runtime_config_unreadable" : "runtime_config_write_failed"
-    };
+    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)}`
+    );
   }
 }
-async function restoreHermesFiles(configPath, existingConfig, envPath, existingEnv, writeText) {
-  const [envResult, configResult] = await Promise.allSettled([
-    restoreOptionalText(envPath, existingEnv, writeText),
-    restoreOptionalText(configPath, existingConfig, writeText)
-  ]);
-  return envResult.status === "fulfilled" && configResult.status === "fulfilled";
+async function writeConnectOutcomeRecord(directory, outcome, warn) {
+  const path$1 = path.join(directory, CONNECT_OUTCOME_FILENAME);
+  await promises.writeFile(path$1, `${JSON.stringify(outcome, null, 2)}
+`, { mode: 384 });
+  await restrictPermissions(path$1, 384, warn);
+  return path$1;
 }
-async function restoreOptionalText(path, existing, writeText) {
-  if (existing !== null) {
-    await writeText(path, existing);
-    return;
-  }
+async function readConnectOutcomeRuntime(directory) {
   try {
-    await promises.unlink(path);
-  } catch (err) {
-    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") return;
-    throw err;
+    const parsed = JSON.parse(await promises.readFile(path.join(directory, CONNECT_OUTCOME_FILENAME), "utf8"));
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const runtime = parsed.runtime;
+    return typeof runtime === "string" && runtime.length > 0 ? runtime : null;
+  } catch {
+    return null;
   }
 }
-async function writeCodexConfig(input) {
-  const target = codexConfigPath(input.homeDir);
-  const local = input.mode === "local";
+async function writeMcpServerBinding(directory, binding) {
+  const path$1 = path.join(directory, MCP_SERVER_BINDING_FILENAME);
+  await promises.writeFile(path$1, `${JSON.stringify(binding, null, 2)}
+`, { mode: 384 });
+  return path$1;
+}
+async function readMcpServerBinding(directory) {
   try {
-    const existing = await readOptional(target);
-    if (local) {
-      if (!input.localMcpCommand) {
-        throw new Error("local MCP wrapper command is required");
-      }
-      const merged2 = mergeCodexToml(existing ?? "", input.localMcpCommand, serverNamesFor(input.serverName));
-      await writeOwnerOnlyText(target, merged2);
-      return {
-        hostedConfigured: false,
-        signerConfigured: true,
-        localMcpConfigured: true,
-        runtimeMcpMode: "local_stdio",
-        target: configTargetLabel(input.runtime),
-        changed: existing !== merged2,
-        restartRequired: true,
-        messages: [
-          `Updated local Haven MCP entry in ${configTargetLabel(input.runtime)}.`
-        ]
-      };
-    }
-    const merged = mergeCodexTomlHosted(
-      existing ?? "",
-      input.hostedMcpUrl,
-      input.apiKey,
-      resolveSignerLaunchSpec(input),
-      serverNamesFor(input.serverName)
-    );
-    await writeOwnerOnlyText(target, merged);
-    return {
-      hostedConfigured: true,
-      signerConfigured: true,
-      localMcpConfigured: false,
-      runtimeMcpMode: "hosted_plus_signer",
-      target: configTargetLabel(input.runtime),
-      changed: existing !== merged,
-      restartRequired: true,
-      messages: [
-        `Updated Haven MCP entries in ${configTargetLabel(input.runtime)}.`
-      ]
-    };
-  } catch (err) {
-    const invalidToml = err instanceof InvalidCodexTomlError;
-    return {
-      hostedConfigured: false,
-      signerConfigured: false,
-      localMcpConfigured: false,
-      runtimeMcpMode: local ? "local_stdio" : "hosted_plus_signer",
-      target: configTargetLabel(input.runtime),
-      changed: false,
-      restartRequired: true,
-      messages: [`Could not update ${configTargetLabel(input.runtime)}: ${err instanceof Error ? err.message : String(err)}`],
-      errorCode: invalidToml ? "codex_config_invalid" : "runtime_config_write_failed"
-    };
+    const parsed = JSON.parse(await promises.readFile(path.join(directory, MCP_SERVER_BINDING_FILENAME), "utf8"));
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const record = parsed;
+    if (record.version !== 1 || typeof record.server_name !== "string" || typeof record.agent_id !== "string" || typeof record.api_url !== "string" || typeof record.bound_at !== "string") return null;
+    return record;
+  } catch {
+    return null;
   }
 }
-async function readOptional(path) {
+async function clearMcpServerBinding(directory) {
   try {
-    return await promises.readFile(path, "utf8");
-  } catch (err) {
-    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") return null;
-    throw err;
+    await promises.rm(path.join(directory, MCP_SERVER_BINDING_FILENAME));
+    return true;
+  } catch {
+    return false;
   }
 }
-async function writeOwnerOnlyText(path$1, value) {
-  await promises.mkdir(path.dirname(path$1), { recursive: true, mode: 448 });
-  await promises.writeFile(path$1, value, { mode: 384 });
-  await promises.chmod(path$1, 384).catch(() => void 0);
-}
-function parseJsonObject(value, configPath) {
-  let parsed;
+async function listMcpServerBindings(baseDir, excludeDirectory) {
+  const root = defaultCredentialRoot(baseDir);
+  let entries = [];
   try {
-    parsed = JSON.parse(value);
+    entries = await promises.readdir(root);
   } catch {
-    throw new UnreadableRuntimeConfigError(configPath ?? "the runtime config", "it is not valid JSON");
+    return [];
   }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new UnreadableRuntimeConfigError(configPath ?? "the runtime config", "the top level is not a JSON object");
+  const out = [];
+  for (const entry of entries) {
+    const directory = path.join(root, entry);
+    if (excludeDirectory && directory === excludeDirectory) continue;
+    const binding = await readMcpServerBinding(directory);
+    if (binding) out.push({ directory, binding });
   }
-  return parsed;
+  return out;
 }
-function removeTomlTableTree(toml, table) {
-  const lines = toml.split(/\r?\n/);
-  const kept = [];
-  let skipping = false;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    const tableName = tomlTableName(trimmed);
-    if (tableName) {
-      skipping = tableName === table || tableName.startsWith(`${table}.`);
-      if (skipping) continue;
+var REKEY_PENDING_FILENAME, REKEY_PENDING_TTL_MS, CONNECT_OUTCOME_FILENAME, MCP_SERVER_BINDING_FILENAME;
+var init_storage = __esm({
+  "src/storage.ts"() {
+    init_server_names();
+    init_signer_runtime();
+    init_tombstone();
+    REKEY_PENDING_FILENAME = "rekey-pending.json";
+    REKEY_PENDING_TTL_MS = 24 * 60 * 60 * 1e3;
+    CONNECT_OUTCOME_FILENAME = "last-connect-outcome.json";
+    MCP_SERVER_BINDING_FILENAME = "mcp-server-binding.json";
+  }
+});
+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 = yaml.parseDocument(existingYaml, { keepSourceTokens: true });
+  if (doc.errors.length > 0 || !yaml.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 && yaml.isMap(mcpPair.value) ? mcpPair.value.toJSON() : {};
+  const servers = isRecord(existingServers) ? existingServers : {};
+  const mergedServers = {
+    ...servers,
+    [names.hosted]: hostedServer,
+    [names.signer]: signerServer
+  };
+  if (!mcpPair) {
+    return appendHermesMcpServers(existingYaml, mergedServers);
+  }
+  if (!mcpPair.value?.range) return replaceEmptyHermesMcpServers(existingYaml, mcpPair.key?.range, mergedServers);
+  return replaceHermesMcpServers(existingYaml, mcpPair.key?.range, mcpPair.value.range, mergedServers);
+}
+function mergeHermesEnv(existingEnv, apiKey, envKey = HERMES_API_KEY_ENV) {
+  if (/[\r\n]/.test(apiKey)) throw new Error("Hermes API key must be a single line");
+  const assignment = `${envKey}=${apiKey}`;
+  if (!existingEnv) return `${assignment}
+`;
+  const lineEnding = existingEnv.includes("\r\n") ? "\r\n" : "\n";
+  const hasTrailingNewline = /\r?\n$/.test(existingEnv);
+  const lines = existingEnv.split(/\r?\n/);
+  if (hasTrailingNewline) lines.pop();
+  let found = false;
+  const merged = lines.flatMap((line) => {
+    if (isHermesEnvAssignment(line, envKey)) {
+      if (found) return [];
+      found = true;
+      return [assignment];
+    }
+    if (isAmbiguousHermesEnvLine(line, envKey)) {
+      throw new Error("Hermes environment contains an ambiguous managed key");
+    }
+    return [line];
+  });
+  if (!found) {
+    return `${existingEnv}${hasTrailingNewline ? "" : lineEnding}${assignment}${lineEnding}`;
+  }
+  return `${merged.join(lineEnding)}${hasTrailingNewline ? lineEnding : ""}`;
+}
+function isHermesEnvAssignment(line, envKey) {
+  return new RegExp(`^\\s*(?:export[ \\t]+)?${envKey}[ \\t]*=`).test(line);
+}
+function isAmbiguousHermesEnvLine(line, envKey) {
+  return new RegExp(`^\\s*(?:export[ \\t]+)?${envKey}\\b`).test(line);
+}
+function removeHermesYaml(existingYaml, names, configPath) {
+  if (!existingYaml?.trim()) return existingYaml ?? "";
+  const doc = yaml.parseDocument(existingYaml, { keepSourceTokens: true });
+  if (doc.errors.length > 0 || !yaml.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");
+  if (!mcpPair || !yaml.isMap(mcpPair.value)) return existingYaml;
+  const toRemove = mcpPair.value.items.filter((item) => {
+    const name = item.key?.toString();
+    return name === names.hosted || name === names.signer;
+  });
+  if (toRemove.length === 0) return existingYaml;
+  if (toRemove.length !== mcpPair.value.items.length && toRemove.some((item) => !item.key?.range || !item.value?.range)) {
+    throw new UnreadableRuntimeConfigError(configPath ?? "the Hermes config", "an MCP server entry cannot be safely removed");
+  }
+  let out = existingYaml;
+  const ranges = toRemove.map((item) => {
+    const keyStart = item.key.range[0];
+    const valueEnd = item.value.range[1];
+    const lineStart = existingYaml.lastIndexOf("\n", keyStart - 1) + 1;
+    let end = valueEnd;
+    if (existingYaml.slice(end).startsWith("\r\n")) end += 2;
+    else if (existingYaml[end] === "\n") end += 1;
+    return [lineStart, end];
+  });
+  ranges.sort((a, b) => b[0] - a[0]);
+  for (const [start, end] of ranges) out = out.slice(0, start) + out.slice(end);
+  if (toRemove.length === mcpPair.value.items.length) {
+    const reparsed = yaml.parseDocument(out, { keepSourceTokens: true });
+    if (!reparsed.errors.length && yaml.isMap(reparsed.contents)) {
+      const pair = reparsed.contents.items.find((item) => item.key?.toString() === "mcp_servers");
+      if (pair && pair.key?.range && pair.value?.range) {
+        const keyStart = pair.key.range[0];
+        const valueEnd = pair.value.range[1];
+        const lineStart = out.lastIndexOf("\n", keyStart - 1) + 1;
+        let end = valueEnd;
+        if (out.slice(end).startsWith("\r\n")) end += 2;
+        else if (out[end] === "\n") end += 1;
+        out = out.slice(0, lineStart) + out.slice(end);
+      }
+    }
+  }
+  return out;
+}
+function removeHermesEnv(existingEnv, envKey) {
+  if (!existingEnv) return "";
+  const lineEnding = existingEnv.includes("\r\n") ? "\r\n" : "\n";
+  const hasTrailingNewline = /\r?\n$/.test(existingEnv);
+  const lines = existingEnv.split(/\r?\n/);
+  if (hasTrailingNewline) lines.pop();
+  let removed = 0;
+  const kept = lines.filter((line) => {
+    if (isHermesEnvAssignment(line, envKey)) {
+      removed += 1;
+      return false;
+    }
+    if (isAmbiguousHermesEnvLine(line, envKey)) {
+      throw new Error("Hermes environment contains an ambiguous managed key");
+    }
+    return true;
+  });
+  if (removed === 0) return existingEnv;
+  const joined = kept.join(lineEnding);
+  return hasTrailingNewline ? `${joined}${lineEnding}` : joined;
+}
+function removeJsonMcpConfig(existingJson, serverRoot, names, configPath) {
+  if (!existingJson?.trim()) return existingJson ?? "";
+  const config = parseJsonObject(existingJson, configPath);
+  const root = config[serverRoot];
+  if (!root || typeof root !== "object" || Array.isArray(root)) return existingJson;
+  const servers = root;
+  let removed = false;
+  for (const name of [names.hosted, names.signer]) {
+    if (name in servers) {
+      delete servers[name];
+      removed = true;
+    }
+  }
+  if (!removed) return existingJson;
+  if (Object.keys(servers).length === 0) delete config[serverRoot];
+  return `${JSON.stringify(config, null, 2)}
+`;
+}
+function removeCodexToml(existingToml, names) {
+  let next = removeTomlTableTree(
+    removeTomlTableTree(existingToml, `mcp_servers.${names.codexHosted}`),
+    `mcp_servers.${names.codexSigner}`
+  );
+  return next;
+}
+function appendHermesMcpServers(source, servers) {
+  const documentEnd = /(?:^|\n)[ \t]*\.\.\.[ \t]*(?:#[^\n]*)?\r?\n?$/.exec(source);
+  if (documentEnd) {
+    const markerStart = documentEnd.index + (documentEnd[0].startsWith("\n") ? 1 : 0);
+    const beforeMarker = source.slice(0, markerStart);
+    return `${beforeMarker}${beforeMarker.endsWith("\n") ? "" : "\n"}${renderHermesMcpServers(servers, "")}
+${source.slice(markerStart)}`;
+  }
+  const separator = source.endsWith("\n") ? "" : "\n";
+  return `${source}${separator}${renderHermesMcpServers(servers, "")}
+`;
+}
+function replaceHermesMcpServers(source, keyRange, valueRange, servers) {
+  const valueStart = valueRange[0];
+  const valueEnd = valueRange[1];
+  const valueLineStart = source.lastIndexOf("\n", valueStart - 1) + 1;
+  const keyStartsOnValueLine = keyRange?.[0] !== void 0 && keyRange[0] >= valueLineStart;
+  const nestedIndent = `${source.slice(valueLineStart, keyRange?.[0] ?? valueLineStart)}  `;
+  if (keyStartsOnValueLine) {
+    const keyStart = keyRange[0];
+    const keyEnd = keyRange[1];
+    const replacement2 = `${source.slice(keyStart, keyEnd)}:
+${renderHermesMcpServerEntries(servers, nestedIndent)}`;
+    const needsTrailingNewline2 = valueEnd < source.length && !source.slice(valueEnd).startsWith("\n");
+    return `${source.slice(0, keyStart)}${replacement2}${needsTrailingNewline2 ? "\n" : ""}${source.slice(valueEnd)}`;
+  }
+  const indent = source.slice(valueLineStart, valueStart);
+  const rendered = yaml.stringify(servers, { lineWidth: 120 }).trimEnd();
+  const replacement = rendered.split("\n").map((line, index) => index === 0 ? line : `${indent}${line}`).join("\n");
+  const needsTrailingNewline = valueEnd < source.length && !source.slice(valueEnd).startsWith("\n");
+  return `${source.slice(0, valueStart)}${replacement}${needsTrailingNewline ? "\n" : ""}${source.slice(valueEnd)}`;
+}
+function replaceEmptyHermesMcpServers(source, keyRange, servers) {
+  if (!keyRange) throw new Error("Hermes config mcp_servers key is invalid");
+  const keyStart = keyRange[0];
+  const keyEnd = keyRange[1];
+  const lineStart = source.lastIndexOf("\n", keyStart - 1) + 1;
+  const lineEnd = source.indexOf("\n", keyEnd);
+  const nestedIndent = `${source.slice(lineStart, keyStart)}  `;
+  const replacement = `${source.slice(keyStart, keyEnd)}:
+${renderHermesMcpServerEntries(servers, nestedIndent)}`;
+  return `${source.slice(0, keyStart)}${replacement}${lineEnd === -1 ? "\n" : source.slice(lineEnd)}`;
+}
+function renderHermesYaml(servers) {
+  return `${renderHermesMcpServers(servers, "")}
+`;
+}
+function renderHermesMcpServers(servers, indent) {
+  return `mcp_servers:
+${renderHermesMcpServerEntries(servers, `${indent}  `)}`;
+}
+function renderHermesMcpServerEntries(servers, indent) {
+  return yaml.stringify(servers, { lineWidth: 120 }).trimEnd().split("\n").map((line) => `${indent}${line}`).join("\n");
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mergeCodexToml(existingToml, localMcpCommand, names = serverNamesFor()) {
+  let next = removeTomlTableTree(
+    removeTomlTableTree(existingToml, `mcp_servers.${names.codexHosted}`),
+    `mcp_servers.${names.codexSigner}`
+  );
+  next = next.trimEnd();
+  const block = [
+    `[mcp_servers.${names.codexHosted}]`,
+    `command = ${tomlString(localMcpCommand)}`,
+    "args = []",
+    "startup_timeout_sec = 120"
+  ].join("\n");
+  validateCodexToml(block, "Generated Codex Haven config");
+  const merged = `${next ? `${next}
+
+` : ""}${block}
+`;
+  return merged;
+}
+function mergeCodexTomlHosted(existingToml, hostedMcpUrl, apiKey, signerSpec, names = serverNamesFor()) {
+  let next = removeTomlTableTree(
+    removeTomlTableTree(existingToml, `mcp_servers.${names.codexHosted}`),
+    `mcp_servers.${names.codexSigner}`
+  );
+  next = next.trimEnd();
+  const block = [
+    `[mcp_servers.${names.codexHosted}]`,
+    `url = ${tomlString(hostedMcpUrl)}`,
+    `http_headers = { "Authorization" = ${tomlString(`Bearer ${apiKey}`)} }`,
+    "",
+    `[mcp_servers.${names.codexSigner}]`,
+    `command = ${tomlString(signerSpec.command)}`,
+    `args = [${signerSpec.args.map((arg) => tomlString(arg)).join(", ")}]`,
+    "startup_timeout_sec = 120"
+  ].join("\n");
+  validateCodexToml(block, "Generated Codex Haven config");
+  const merged = `${next ? `${next}
+
+` : ""}${block}
+`;
+  return merged;
+}
+async function writeJsonRuntimeConfig(input, target, serverRoot) {
+  try {
+    const existing = await readOptional(target);
+    const merged = mergeJsonMcpConfig(
+      existing,
+      serverRoot,
+      buildHostedServer(input.hostedMcpUrl, input.apiKey, input.runtime),
+      buildSignerServer(resolveSignerLaunchSpec(input), input.runtime),
+      serverNamesFor(input.serverName),
+      target
+    );
+    await writeOwnerOnlyText(target, merged);
+    return {
+      hostedConfigured: true,
+      signerConfigured: true,
+      localMcpConfigured: false,
+      runtimeMcpMode: "hosted_plus_signer",
+      target: configTargetLabel(input.runtime),
+      changed: existing !== merged,
+      restartRequired: input.runtime === "claude-desktop",
+      messages: [`Updated Haven MCP entries in ${configTargetLabel(input.runtime)}.`]
+    };
+  } catch (err) {
+    const unreadable = err instanceof UnreadableRuntimeConfigError;
+    return {
+      hostedConfigured: false,
+      signerConfigured: false,
+      localMcpConfigured: false,
+      runtimeMcpMode: "hosted_plus_signer",
+      target: configTargetLabel(input.runtime),
+      changed: false,
+      restartRequired: true,
+      messages: unreadable ? [
+        `Could not update ${configTargetLabel(input.runtime)}: ${err.message}.`,
+        `Nothing was written to ${err.configPath}. Fix the JSON there (or move the file aside), then run \`${REPAIR_COMMAND_PREFIX} ${input.runtime}\` to write the Haven entries from the credentials already stored on this machine. Do not re-run the connector command: its setup token is already used.`
+      ] : [`Could not update ${configTargetLabel(input.runtime)}: ${err instanceof Error ? err.message : String(err)}`],
+      errorCode: unreadable ? "runtime_config_unreadable" : "runtime_config_write_failed"
+    };
+  }
+}
+async function writeHermesConfig(input, deps) {
+  const target = hermesConfigPath(input.homeDir);
+  const envTarget = hermesEnvPath(input.homeDir);
+  try {
+    const [existing, existingEnv] = await Promise.all([readOptional(target), readOptional(envTarget)]);
+    const names = serverNamesFor(input.serverName);
+    const hostedServer = {
+      ...buildHostedServer(input.hostedMcpUrl, `\${${names.hermesEnvKey}}`, input.runtime),
+      enabled: true
+    };
+    const signerServer = {
+      ...buildSignerServer(resolveSignerLaunchSpec(input), input.runtime),
+      enabled: true
+    };
+    const merged = mergeHermesYaml(
+      existing,
+      hostedServer,
+      signerServer,
+      names,
+      target
+    );
+    const mergedEnv = mergeHermesEnv(existingEnv, input.apiKey, names.hermesEnvKey);
+    const writeText = deps.writeOwnerOnlyText ?? writeOwnerOnlyText;
+    await writeText(envTarget, mergedEnv);
+    try {
+      await writeText(target, merged);
+    } catch (err) {
+      const recovered = await restoreHermesFiles(target, existing, envTarget, existingEnv, writeText);
+      if (!recovered) throw new HermesConfigRecoveryError();
+      throw err;
     }
-    if (!skipping) kept.push(line);
+    return {
+      hostedConfigured: true,
+      signerConfigured: true,
+      localMcpConfigured: false,
+      runtimeMcpMode: "hosted_plus_signer",
+      target: "Hermes Agent config",
+      changed: existing !== merged || existingEnv !== mergedEnv,
+      restartRequired: true,
+      messages: [
+        `Updated Haven MCP entries in ${target}; stored the hosted MCP identity in ${envTarget}.`,
+        // #3737: name the pair actually written — a bare run prints exactly the
+        // historical sentence; a named run names its own pair.
+        `Restart Hermes (start a new session; gateway users: /restart), then verify with \`hermes mcp list\`, \`hermes mcp test ${names.hosted}\`, and \`hermes mcp test ${names.signer}\`.`,
+        "If several long-lived Hermes processes are running (a gateway plus TUI workers), restart EVERY one: each loads its MCP wiring at startup, so a process started before this setup keeps using its old snapshot.",
+        "If no mcp_* tools appear after restart, ensure the MCP SDK is installed in Hermes: pip install mcp"
+      ]
+    };
+  } catch (err) {
+    const recoveryIncomplete = err instanceof HermesConfigRecoveryError;
+    const unreadable = err instanceof UnreadableRuntimeConfigError;
+    return {
+      hostedConfigured: false,
+      signerConfigured: false,
+      localMcpConfigured: false,
+      runtimeMcpMode: "hosted_plus_signer",
+      target: "Hermes Agent config",
+      changed: false,
+      restartRequired: true,
+      messages: unreadable ? [
+        `Could not update Hermes Agent config: ${err.message}.`,
+        `Nothing was written to ${err.configPath}. Fix the YAML there (or move the file aside), then run \`${REPAIR_COMMAND_PREFIX} hermes\` to write the Haven entries from the credentials already stored on this machine. Do not re-run the connector command: its setup token is already used.`
+      ] : [recoveryIncomplete ? "Could not update Hermes Agent config. Recovery did not complete; inspect the Hermes configuration before retrying." : "Could not update Hermes Agent config. Existing configuration was left unchanged."],
+      errorCode: unreadable ? "runtime_config_unreadable" : "runtime_config_write_failed"
+    };
   }
-  return kept.join("\n");
 }
-function tomlTableName(line) {
-  if (line.startsWith("[[") && line.endsWith("]]")) return line.slice(2, -2).trim();
-  if (line.startsWith("[") && line.endsWith("]")) return line.slice(1, -1).trim();
-  return null;
+async function restoreHermesFiles(configPath, existingConfig, envPath, existingEnv, writeText) {
+  const [envResult, configResult] = await Promise.allSettled([
+    restoreOptionalText(envPath, existingEnv, writeText),
+    restoreOptionalText(configPath, existingConfig, writeText)
+  ]);
+  return envResult.status === "fulfilled" && configResult.status === "fulfilled";
 }
-function validateCodexToml(toml, label = "Codex config") {
-  const lines = toml.split(/\r?\n/);
-  let pendingValue = null;
-  for (let index = 0; index < lines.length; index += 1) {
-    const raw = lines[index];
-    const line = stripTomlComment(raw).trim();
-    if (!line) continue;
-    if (pendingValue) {
-      pendingValue.value = `${pendingValue.value}
-${line}`;
-      if (hasBalancedTomlContainers(pendingValue.value)) {
-        if (!isTomlValue(pendingValue.value)) {
-          throw new InvalidCodexTomlError(`${label} has invalid TOML near line ${pendingValue.line}.`);
-        }
-        pendingValue = null;
-      }
-      continue;
-    }
-    if (isTomlTable(line)) continue;
-    const equalsIndex = line.indexOf("=");
-    if (equalsIndex <= 0) {
-      throw new InvalidCodexTomlError(`${label} has invalid TOML near line ${index + 1}.`);
-    }
-    const key = line.slice(0, equalsIndex).trim();
-    const value = line.slice(equalsIndex + 1).trim();
-    if (!isTomlKey(key)) {
-      throw new InvalidCodexTomlError(`${label} has invalid TOML near line ${index + 1}.`);
-    }
-    if (startsTomlContainer(value) && !hasBalancedTomlContainers(value)) {
-      pendingValue = { value, line: index + 1 };
-      continue;
-    }
-    if (!isTomlValue(value)) {
-      throw new InvalidCodexTomlError(`${label} has invalid TOML near line ${index + 1}.`);
-    }
+async function restoreOptionalText(path, existing, writeText) {
+  if (existing !== null) {
+    await writeText(path, existing);
+    return;
   }
-  if (pendingValue) {
-    throw new InvalidCodexTomlError(`${label} has invalid TOML near line ${pendingValue.line}.`);
+  try {
+    await promises.unlink(path);
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") return;
+    throw err;
   }
 }
-function isTomlTable(line) {
-  const table = tomlTableName(line);
-  return Boolean(table && splitTomlDottedKey(table).every(isTomlKeyPart));
-}
-function isTomlKey(value) {
-  return splitTomlDottedKey(value).every(isTomlKeyPart);
-}
-function splitTomlDottedKey(value) {
-  const parts = [];
-  let current = "";
-  let quote = null;
-  let escaped = false;
-  for (let i = 0; i < value.length; i += 1) {
-    const char = value[i];
-    if (quote) {
-      current += char;
-      if (quote === '"' && char === "\\" && !escaped) {
-        escaped = true;
-        continue;
+async function writeCodexConfig(input) {
+  const target = codexConfigPath(input.homeDir);
+  const local = input.mode === "local";
+  try {
+    const existing = await readOptional(target);
+    if (local) {
+      if (!input.localMcpCommand) {
+        throw new Error("local MCP wrapper command is required");
       }
-      if (char === quote && !escaped) quote = null;
-      escaped = false;
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      quote = char;
-      current += char;
-      continue;
-    }
-    if (char === ".") {
-      parts.push(current.trim());
-      current = "";
-      continue;
+      const merged2 = mergeCodexToml(existing ?? "", input.localMcpCommand, serverNamesFor(input.serverName));
+      await writeOwnerOnlyText(target, merged2);
+      return {
+        hostedConfigured: false,
+        signerConfigured: true,
+        localMcpConfigured: true,
+        runtimeMcpMode: "local_stdio",
+        target: configTargetLabel(input.runtime),
+        changed: existing !== merged2,
+        restartRequired: true,
+        messages: [
+          `Updated local Haven MCP entry in ${configTargetLabel(input.runtime)}.`
+        ]
+      };
     }
-    current += char;
+    const merged = mergeCodexTomlHosted(
+      existing ?? "",
+      input.hostedMcpUrl,
+      input.apiKey,
+      resolveSignerLaunchSpec(input),
+      serverNamesFor(input.serverName)
+    );
+    await writeOwnerOnlyText(target, merged);
+    return {
+      hostedConfigured: true,
+      signerConfigured: true,
+      localMcpConfigured: false,
+      runtimeMcpMode: "hosted_plus_signer",
+      target: configTargetLabel(input.runtime),
+      changed: existing !== merged,
+      restartRequired: true,
+      messages: [
+        `Updated Haven MCP entries in ${configTargetLabel(input.runtime)}.`
+      ]
+    };
+  } catch (err) {
+    const invalidToml = err instanceof InvalidCodexTomlError;
+    return {
+      hostedConfigured: false,
+      signerConfigured: false,
+      localMcpConfigured: false,
+      runtimeMcpMode: local ? "local_stdio" : "hosted_plus_signer",
+      target: configTargetLabel(input.runtime),
+      changed: false,
+      restartRequired: true,
+      messages: [`Could not update ${configTargetLabel(input.runtime)}: ${err instanceof Error ? err.message : String(err)}`],
+      errorCode: invalidToml ? "codex_config_invalid" : "runtime_config_write_failed"
+    };
   }
-  parts.push(current.trim());
-  return quote ? [] : parts;
 }
-function isTomlKeyPart(value) {
-  return isTomlBareKey(value) || isTomlQuotedString(value);
-}
-function isTomlBareKey(value) {
-  return /^[A-Za-z0-9_-]+$/.test(value);
-}
-function isTomlValue(value) {
-  if (!value) return false;
-  if (isTomlQuotedString(value)) return true;
-  if (/^(true|false)$/i.test(value)) return true;
-  if (/^[+-]?(?:inf|nan)$/i.test(value)) return true;
-  if (/^[+-]?(?:0|[1-9][0-9_]*)(?:\.[0-9_]+)?(?:[eE][+-]?[0-9_]+)?$/.test(value)) return true;
-  if (/^\d{4}-\d{2}-\d{2}(?:[Tt ][0-9:.+-Zz]+)?$/.test(value)) return true;
-  if (value.startsWith("[") && value.endsWith("]") || value.startsWith("{") && value.endsWith("}")) {
-    return hasBalancedTomlContainers(value);
+async function readOptional(path) {
+  try {
+    return await promises.readFile(path, "utf8");
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") return null;
+    throw err;
   }
-  return false;
 }
-function startsTomlContainer(value) {
-  return value.startsWith("[") || value.startsWith("{");
+async function writeOwnerOnlyText(path$1, value) {
+  await promises.mkdir(path.dirname(path$1), { recursive: true, mode: 448 });
+  await promises.writeFile(path$1, value, { mode: 384 });
+  await promises.chmod(path$1, 384).catch(() => void 0);
 }
-function isTomlQuotedString(value) {
-  if (value.startsWith('"""') || value.startsWith("'''")) {
-    const marker = value.slice(0, 3);
-    return value.length >= 6 && value.endsWith(marker);
+function parseJsonObject(value, configPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new UnreadableRuntimeConfigError(configPath ?? "the runtime config", "it is not valid JSON");
   }
-  if ((!value.startsWith('"') || !value.endsWith('"')) && (!value.startsWith("'") || !value.endsWith("'"))) {
-    return false;
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new UnreadableRuntimeConfigError(configPath ?? "the runtime config", "the top level is not a JSON object");
   }
-  return hasBalancedTomlContainers(value);
+  return parsed;
+}
+function removeTomlTableTree(toml, table) {
+  const lines = toml.split(/\r?\n/);
+  const kept = [];
+  let skipping = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const tableName = tomlTableName(trimmed);
+    if (tableName) {
+      skipping = tableName === table || tableName.startsWith(`${table}.`);
+      if (skipping) continue;
+    }
+    if (!skipping) kept.push(line);
+  }
+  return kept.join("\n");
+}
+function tomlTableName(line) {
+  if (line.startsWith("[[") && line.endsWith("]]")) return line.slice(2, -2).trim();
+  if (line.startsWith("[") && line.endsWith("]")) return line.slice(1, -1).trim();
+  return null;
 }
-function stripTomlComment(value) {
-  let quote = null;
-  let escaped = false;
-  for (let i = 0; i < value.length; i += 1) {
-    const char = value[i];
-    if (quote) {
-      if (quote === '"' && char === "\\" && !escaped) {
-        escaped = true;
-        continue;
+function validateCodexToml(toml, label = "Codex config") {
+  const lines = toml.split(/\r?\n/);
+  let pendingValue = null;
+  for (let index = 0; index < lines.length; index += 1) {
+    const raw = lines[index];
+    const line = stripTomlComment(raw).trim();
+    if (!line) continue;
+    if (pendingValue) {
+      pendingValue.value = `${pendingValue.value}
+${line}`;
+      if (hasBalancedTomlContainers(pendingValue.value)) {
+        if (!isTomlValue(pendingValue.value)) {
+          throw new InvalidCodexTomlError(`${label} has invalid TOML near line ${pendingValue.line}.`);
+        }
+        pendingValue = null;
       }
-      if (char === quote && !escaped) quote = null;
-      escaped = false;
       continue;
     }
-    if (char === '"' || char === "'") {
-      quote = char;
+    if (isTomlTable(line)) continue;
+    const equalsIndex = line.indexOf("=");
+    if (equalsIndex <= 0) {
+      throw new InvalidCodexTomlError(`${label} has invalid TOML near line ${index + 1}.`);
+    }
+    const key = line.slice(0, equalsIndex).trim();
+    const value = line.slice(equalsIndex + 1).trim();
+    if (!isTomlKey(key)) {
+      throw new InvalidCodexTomlError(`${label} has invalid TOML near line ${index + 1}.`);
+    }
+    if (startsTomlContainer(value) && !hasBalancedTomlContainers(value)) {
+      pendingValue = { value, line: index + 1 };
       continue;
     }
-    if (char === "#") return value.slice(0, i);
+    if (!isTomlValue(value)) {
+      throw new InvalidCodexTomlError(`${label} has invalid TOML near line ${index + 1}.`);
+    }
+  }
+  if (pendingValue) {
+    throw new InvalidCodexTomlError(`${label} has invalid TOML near line ${pendingValue.line}.`);
   }
-  return value;
 }
-function hasBalancedTomlContainers(value) {
-  const stack = [];
+function isTomlTable(line) {
+  const table = tomlTableName(line);
+  return Boolean(table && splitTomlDottedKey(table).every(isTomlKeyPart));
+}
+function isTomlKey(value) {
+  return splitTomlDottedKey(value).every(isTomlKeyPart);
+}
+function splitTomlDottedKey(value) {
+  const parts = [];
+  let current = "";
   let quote = null;
   let escaped = false;
   for (let i = 0; i < value.length; i += 1) {
     const char = value[i];
     if (quote) {
+      current += char;
       if (quote === '"' && char === "\\" && !escaped) {
         escaped = true;
         continue;
@@ -1331,638 +1802,449 @@ function hasBalancedTomlContainers(value) {
     }
     if (char === '"' || char === "'") {
       quote = char;
+      current += char;
       continue;
     }
-    if (char === "[" || char === "{") {
-      stack.push(char);
-      continue;
-    }
-    if (char === "]") {
-      if (stack.pop() !== "[") return false;
+    if (char === ".") {
+      parts.push(current.trim());
+      current = "";
       continue;
     }
-    if (char === "}") {
-      if (stack.pop() !== "{") return false;
-    }
-  }
-  return stack.length === 0 && quote === null;
-}
-function tomlString(value) {
-  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-}
-function runtimeConfigPathFor(runtime, homeDir = os.homedir()) {
-  switch (runtime) {
-    case "cursor":
-      return cursorConfigPath(homeDir);
-    case "codex-cli":
-    case "codex-desktop":
-      return codexConfigPath(homeDir);
-    case "vscode":
-      return vscodeConfigPath(homeDir);
-    case "vscode-insiders":
-      return vscodeInsidersConfigPath(homeDir);
-    case "claude-desktop":
-      return claudeDesktopConfigPath(homeDir);
-    case "hermes":
-      return hermesConfigPath(homeDir);
-    default:
-      return null;
-  }
-}
-function cursorConfigPath(homeDir = os.homedir()) {
-  return path.resolve(homeDir, ".cursor", "mcp.json");
-}
-function codexConfigPath(homeDir = os.homedir()) {
-  return path.resolve(homeDir, ".codex", "config.toml");
-}
-function vscodeConfigPath(homeDir = os.homedir()) {
-  if (os.platform() === "darwin") return path.resolve(homeDir, "Library", "Application Support", "Code", "User", "mcp.json");
-  if (os.platform() === "win32") {
-    return path.resolve(process.env.APPDATA ?? path.join(homeDir, "AppData", "Roaming"), "Code", "User", "mcp.json");
-  }
-  return path.resolve(homeDir, ".config", "Code", "User", "mcp.json");
-}
-function vscodeInsidersConfigPath(homeDir = os.homedir()) {
-  if (os.platform() === "darwin") return path.resolve(homeDir, "Library", "Application Support", "Code - Insiders", "User", "mcp.json");
-  if (os.platform() === "win32") {
-    return path.resolve(process.env.APPDATA ?? path.join(homeDir, "AppData", "Roaming"), "Code - Insiders", "User", "mcp.json");
-  }
-  return path.resolve(homeDir, ".config", "Code - Insiders", "User", "mcp.json");
-}
-function claudeDesktopConfigPath(homeDir = os.homedir()) {
-  if (os.platform() === "darwin") {
-    return path.resolve(homeDir, "Library", "Application Support", "Claude", "claude_desktop_config.json");
-  }
-  if (os.platform() === "win32") {
-    return path.resolve(process.env.APPDATA ?? path.join(homeDir, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
-  }
-  return path.resolve(homeDir, ".config", "Claude", "claude_desktop_config.json");
-}
-function hermesConfigPath(homeDir) {
-  return path.join(hermesHomePath(homeDir), "config.yaml");
-}
-function hermesEnvPath(homeDir) {
-  return path.join(hermesHomePath(homeDir), ".env");
-}
-function hermesHomePath(homeDir) {
-  return process.env.HERMES_HOME ?? path.join(homeDir ?? os.homedir(), ".hermes");
-}
-function configTargetLabel(runtime) {
-  switch (runtime) {
-    case "codex-cli":
-      return "Codex CLI config";
-    case "codex-desktop":
-      return "Codex Desktop config";
-    case "cursor":
-      return "Cursor MCP config";
-    case "vscode":
-      return "VS Code MCP config";
-    case "vscode-insiders":
-      return "VS Code Insiders MCP config";
-    case "claude-desktop":
-      return "Claude Desktop config";
-    default:
-      return "runtime MCP config";
-  }
-}
-var HERMES_API_KEY_ENV, HermesConfigRecoveryError, InvalidCodexTomlError, REPAIR_COMMAND_PREFIX, UnreadableRuntimeConfigError;
-var init_config_writers = __esm({
-  "src/config-writers.ts"() {
-    init_runtime_manifest();
-    init_server_names();
-    HERMES_API_KEY_ENV = "MCP_HAVEN_API_KEY";
-    HermesConfigRecoveryError = class extends Error {
-      constructor() {
-        super("Hermes configuration recovery did not complete");
-        this.name = "HermesConfigRecoveryError";
-      }
-    };
-    InvalidCodexTomlError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "InvalidCodexTomlError";
-      }
-    };
-    REPAIR_COMMAND_PREFIX = sdk.connectorRerunCommand("--doctor --repair --runtime");
-    UnreadableRuntimeConfigError = class extends Error {
-      configPath;
-      constructor(configPath, detail) {
-        super(`${configPath} is not a config Haven can merge into (${detail})`);
-        this.name = "UnreadableRuntimeConfigError";
-        this.configPath = configPath;
-      }
-    };
-  }
-});
-async function acknowledgeLocalMcpConsent(identityPath, signerPath, log) {
-  try {
-    const input = await buildLocalMcpConsentInput(identityPath, signerPath);
-    const decision = await mcp.ensureConsent(input, {
-      credentialsPath: identityPath,
-      writeAck: true,
-      out: log ? { write: (chunk) => writeLogChunk(log, chunk) } : void 0
-    });
-    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 = mcp.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)
-    };
+    current += char;
   }
+  parts.push(current.trim());
+  return quote ? [] : parts;
 }
-function localMcpAckPath(identityPath) {
-  return path.resolve(`${identityPath}.ack.json`);
-}
-async function buildLocalMcpConsentInput(identityPath, signerPath) {
-  const credentials = await mcp.loadCredentials({ identityPath, signerPath });
-  const unavailableDuringSetup = {
-    getAllowances: async () => {
-      throw new Error("Haven approval is not complete yet.");
-    }
-  };
-  return mcp.consentInputFromClient(
-    unavailableDuringSetup,
-    {
-      apiKey: credentials.apiKey,
-      apiUrl: credentials.apiUrl,
-      agentId: credentials.agentId,
-      accountAddress: credentials.accountAddress,
-      delegateAddress: credentials.delegateAddress,
-      chainId: credentials.chainId,
-      allowanceSummary: credentials.allowanceSummary
-    },
-    mcp.registeredToolNames()
-  );
-}
-async function readLocalMcpAckFile(path) {
-  try {
-    const parsed = JSON.parse(await promises.readFile(path, "utf8"));
-    return typeof parsed.ack === "string" ? parsed.ack : null;
-  } catch {
-    return null;
-  }
+function isTomlKeyPart(value) {
+  return isTomlBareKey(value) || isTomlQuotedString(value);
 }
-function writeLogChunk(log, chunk) {
-  const message = String(chunk).trimEnd();
-  if (message) log(message);
+function isTomlBareKey(value) {
+  return /^[A-Za-z0-9_-]+$/.test(value);
 }
-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" };
+function isTomlValue(value) {
+  if (!value) return false;
+  if (isTomlQuotedString(value)) return true;
+  if (/^(true|false)$/i.test(value)) return true;
+  if (/^[+-]?(?:inf|nan)$/i.test(value)) return true;
+  if (/^[+-]?(?:0|[1-9][0-9_]*)(?:\.[0-9_]+)?(?:[eE][+-]?[0-9_]+)?$/.test(value)) return true;
+  if (/^\d{4}-\d{2}-\d{2}(?:[Tt ][0-9:.+-Zz]+)?$/.test(value)) return true;
+  if (value.startsWith("[") && value.endsWith("]") || value.startsWith("{") && value.endsWith("}")) {
+    return hasBalancedTomlContainers(value);
   }
+  return false;
 }
-async function probeHostedMcpTools(apiKey, hostedMcpUrl, fetchImpl = fetch) {
-  let response;
-  try {
-    response = await fetchWithTimeout(fetchImpl, hostedMcpUrl, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json",
-        Accept: "application/json, text/event-stream"
-      },
-      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list" })
-    });
-  } catch {
-    return { status: "network_error" };
-  }
-  if (response.status === 401 || response.status === 403) return { status: "unauthorized" };
-  if (!response.ok) return { status: "bad_response" };
-  try {
-    const payload = parseJsonRpcPayload(await response.text());
-    if (!payload || payload.error) return { status: "bad_response" };
-    const tools = payload.result?.tools;
-    return { status: "ok", toolCount: Array.isArray(tools) ? tools.length : void 0 };
-  } catch {
-    return { status: "bad_response" };
-  }
+function startsTomlContainer(value) {
+  return value.startsWith("[") || value.startsWith("{");
 }
-async function probeLocalSignerCredential(signerPath) {
-  try {
-    const parsed = JSON.parse(await promises.readFile(signerPath, "utf8"));
-    return Boolean(
-      parsed && typeof parsed === "object" && "delegate_key" in parsed && typeof parsed.delegate_key === "string"
-    );
-  } catch {
+function isTomlQuotedString(value) {
+  if (value.startsWith('"""') || value.startsWith("'''")) {
+    const marker = value.slice(0, 3);
+    return value.length >= 6 && value.endsWith(marker);
+  }
+  if ((!value.startsWith('"') || !value.endsWith('"')) && (!value.startsWith("'") || !value.endsWith("'"))) {
     return false;
   }
+  return hasBalancedTomlContainers(value);
 }
-async function probeLocalMcpTools(command, args, requiredTools, timeoutMs = 1e4) {
-  return new Promise((resolve11) => {
-    const child = child_process.spawn(command, args, { stdio: ["pipe", "pipe", "ignore"] });
-    let stdout = "";
-    let settled = false;
-    let sawInitialize = false;
-    let serverInfo;
-    let capabilities;
-    const finish = (result) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeout);
-      child.kill();
-      resolve11(result);
-    };
-    const timeout = setTimeout(() => finish({ status: "timeout" }), timeoutMs);
-    child.on("error", () => finish({ status: "process_error" }));
-    child.on("exit", (code) => {
-      if (!settled && code !== 0) finish({ status: "process_error" });
-    });
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk.toString("utf8");
-      const lines = stdout.split(/\r?\n/);
-      stdout = lines.pop() ?? "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        let payload;
-        try {
-          payload = JSON.parse(trimmed);
-        } catch {
-          continue;
-        }
-        if (payload.error) {
-          finish({ status: "bad_response" });
-          return;
-        }
-        if (payload.id === 1 && !sawInitialize) {
-          sawInitialize = true;
-          const init = payload.result;
-          serverInfo = init?.serverInfo;
-          capabilities = init?.capabilities;
-          writeJsonRpc(child, { jsonrpc: "2.0", method: "notifications/initialized", params: {} });
-          writeJsonRpc(child, { jsonrpc: "2.0", id: 2, method: "tools/list", params: {} });
-          continue;
-        }
-        if (payload.id === 2) {
-          const tools = payload.result?.tools;
-          const toolNames = Array.isArray(tools) ? tools.map((tool) => tool && typeof tool === "object" && "name" in tool ? tool.name : void 0).filter((name) => typeof name === "string") : [];
-          const missing = requiredTools.filter((name) => !toolNames.includes(name));
-          finish({ status: missing.length === 0 ? "ok" : "missing_tools", toolNames, serverInfo, capabilities });
-          return;
-        }
-      }
-    });
-    writeJsonRpc(child, {
-      jsonrpc: "2.0",
-      id: 1,
-      method: "initialize",
-      params: {
-        protocolVersion: "2025-06-18",
-        capabilities: {},
-        clientInfo: { name: "haven-connect-probe", version: "0.0.0" }
+function stripTomlComment(value) {
+  let quote = null;
+  let escaped = false;
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i];
+    if (quote) {
+      if (quote === '"' && char === "\\" && !escaped) {
+        escaped = true;
+        continue;
       }
-    });
-  });
-}
-function writeJsonRpc(child, payload) {
-  child.stdin?.write(`${JSON.stringify(payload)}
-`);
-}
-function parseJsonRpcPayload(raw) {
-  const trimmed = raw.trim();
-  if (!trimmed) return null;
-  if (trimmed.startsWith("{")) {
-    try {
-      return JSON.parse(trimmed);
-    } catch {
-      return null;
+      if (char === quote && !escaped) quote = null;
+      escaped = false;
+      continue;
     }
-  }
-  const dataLines = trimmed.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
-  for (let i = dataLines.length - 1; i >= 0; i -= 1) {
-    try {
-      return JSON.parse(dataLines[i]);
-    } catch {
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
     }
+    if (char === "#") return value.slice(0, i);
   }
-  return null;
+  return value;
 }
-async function fetchWithTimeout(fetchImpl, url, init) {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 3e3);
-  try {
-    return await fetchImpl(url, { ...init, signal: controller.signal });
-  } finally {
-    clearTimeout(timeout);
+function hasBalancedTomlContainers(value) {
+  const stack = [];
+  let quote = null;
+  let escaped = false;
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i];
+    if (quote) {
+      if (quote === '"' && char === "\\" && !escaped) {
+        escaped = true;
+        continue;
+      }
+      if (char === quote && !escaped) quote = null;
+      escaped = false;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === "[" || char === "{") {
+      stack.push(char);
+      continue;
+    }
+    if (char === "]") {
+      if (stack.pop() !== "[") return false;
+      continue;
+    }
+    if (char === "}") {
+      if (stack.pop() !== "{") return false;
+    }
   }
+  return stack.length === 0 && quote === null;
 }
-var init_probes = __esm({
-  "src/probes.ts"() {
-  }
-});
-function resolveRuntimeSpecOverride(env) {
-  const override = {};
-  for (const pkg of Object.keys(RUNTIME_SPEC_ENV)) {
-    const variable = RUNTIME_SPEC_ENV[pkg];
-    const raw = env[variable];
-    if (raw === void 0) continue;
-    override[pkg] = validateSpec(variable, raw);
+function tomlString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function runtimeConfigPathFor(runtime, homeDir = os.homedir()) {
+  switch (runtime) {
+    case "cursor":
+      return cursorConfigPath(homeDir);
+    case "codex-cli":
+    case "codex-desktop":
+      return codexConfigPath(homeDir);
+    case "vscode":
+      return vscodeConfigPath(homeDir);
+    case "vscode-insiders":
+      return vscodeInsidersConfigPath(homeDir);
+    case "claude-desktop":
+      return claudeDesktopConfigPath(homeDir);
+    case "hermes":
+      return hermesConfigPath(homeDir);
+    default:
+      return null;
   }
-  return Object.keys(override).length > 0 ? override : void 0;
 }
-function validateSpec(variable, raw) {
-  if (raw.length === 0 || raw.trim().length === 0) {
-    throw new RuntimeSpecOverrideError(variable, "it is empty");
+function cursorConfigPath(homeDir = os.homedir()) {
+  return path.resolve(homeDir, ".cursor", "mcp.json");
+}
+function codexConfigPath(homeDir = os.homedir()) {
+  return path.resolve(homeDir, ".codex", "config.toml");
+}
+function vscodeConfigPath(homeDir = os.homedir()) {
+  if (os.platform() === "darwin") return path.resolve(homeDir, "Library", "Application Support", "Code", "User", "mcp.json");
+  if (os.platform() === "win32") {
+    return path.resolve(process.env.APPDATA ?? path.join(homeDir, "AppData", "Roaming"), "Code", "User", "mcp.json");
   }
-  if (/\s/.test(raw)) {
-    throw new RuntimeSpecOverrideError(variable, "it contains whitespace");
+  return path.resolve(homeDir, ".config", "Code", "User", "mcp.json");
+}
+function vscodeInsidersConfigPath(homeDir = os.homedir()) {
+  if (os.platform() === "darwin") return path.resolve(homeDir, "Library", "Application Support", "Code - Insiders", "User", "mcp.json");
+  if (os.platform() === "win32") {
+    return path.resolve(process.env.APPDATA ?? path.join(homeDir, "AppData", "Roaming"), "Code - Insiders", "User", "mcp.json");
   }
-  if (/[\u0000-\u001f\u007f]/.test(raw)) {
-    throw new RuntimeSpecOverrideError(variable, "it contains a control character");
+  return path.resolve(homeDir, ".config", "Code - Insiders", "User", "mcp.json");
+}
+function claudeDesktopConfigPath(homeDir = os.homedir()) {
+  if (os.platform() === "darwin") {
+    return path.resolve(homeDir, "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
-  const meta = SHELL_METACHARACTERS.exec(raw);
-  if (meta) {
-    throw new RuntimeSpecOverrideError(variable, `it contains the shell metacharacter ${JSON.stringify(meta[0])}`);
+  if (os.platform() === "win32") {
+    return path.resolve(process.env.APPDATA ?? path.join(homeDir, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
   }
-  return raw;
+  return path.resolve(homeDir, ".config", "Claude", "claude_desktop_config.json");
 }
-function runtimeSpecOverrideDirectoryKey(resolvedSpecs) {
-  const digest = crypto.createHash("sha256").update(resolvedSpecs.join("\n")).digest("hex");
-  return `override-${digest.slice(0, 12)}`;
+function hermesConfigPath(homeDir) {
+  return path.join(hermesHomePath(homeDir), "config.yaml");
 }
-function overrideApplies(override, packages) {
-  return override !== void 0 && packages.some((pkg) => override[pkg] !== void 0);
+function hermesEnvPath(homeDir) {
+  return path.join(hermesHomePath(homeDir), ".env");
 }
-function runtimeSpecOverrideNotice(runtimeLabel, override, pinned, runtimeDirectory) {
-  const lines = [`RUNTIME SPEC OVERRIDE ACTIVE for the local Haven ${runtimeLabel} \u2014 this is NOT the pinned manifest.`];
-  for (const pkg of Object.keys(RUNTIME_SPEC_ENV)) {
-    const spec = override[pkg];
-    if (spec === void 0) continue;
-    const pin = pinned[pkg];
-    lines.push(`  ${RUNTIME_SPEC_ENV[pkg]}=${spec}${pin ? ` (instead of ${pin})` : ""}`);
-  }
-  lines.push(`  Installing into ${runtimeDirectory} \u2014 the pinned runtime directory is untouched.`);
-  lines.push("  Unset the variable(s) and re-run to return to the pinned manifest.");
-  return lines;
+function hermesHomePath(homeDir) {
+  return process.env.HERMES_HOME ?? path.join(homeDir ?? os.homedir(), ".hermes");
 }
-function describeRuntimeSpecOverride(override) {
-  return Object.keys(RUNTIME_SPEC_ENV).filter((pkg) => override[pkg] !== void 0).map((pkg) => `${RUNTIME_SPEC_ENV[pkg]}=${override[pkg]}`).join(" ");
+function configTargetLabel(runtime) {
+  switch (runtime) {
+    case "codex-cli":
+      return "Codex CLI config";
+    case "codex-desktop":
+      return "Codex Desktop config";
+    case "cursor":
+      return "Cursor MCP config";
+    case "vscode":
+      return "VS Code MCP config";
+    case "vscode-insiders":
+      return "VS Code Insiders MCP config";
+    case "claude-desktop":
+      return "Claude Desktop config";
+    default:
+      return "runtime MCP config";
+  }
 }
-var RUNTIME_SPEC_ENV, SHELL_METACHARACTERS, RuntimeSpecOverrideError;
-var init_runtime_spec_override = __esm({
-  "src/runtime-spec-override.ts"() {
-    RUNTIME_SPEC_ENV = {
-      signer: "HAVEN_SIGNER_SPEC",
-      sdk: "HAVEN_SDK_SPEC",
-      mcp: "HAVEN_MCP_SPEC"
+var HERMES_API_KEY_ENV, HermesConfigRecoveryError, InvalidCodexTomlError, REPAIR_COMMAND_PREFIX, UnreadableRuntimeConfigError;
+var init_config_writers = __esm({
+  "src/config-writers.ts"() {
+    init_runtime_manifest();
+    init_server_names();
+    HERMES_API_KEY_ENV = "MCP_HAVEN_API_KEY";
+    HermesConfigRecoveryError = class extends Error {
+      constructor() {
+        super("Hermes configuration recovery did not complete");
+        this.name = "HermesConfigRecoveryError";
+      }
     };
-    SHELL_METACHARACTERS = /[;&|<>$`'"()!#*?[\]{}\\]/;
-    RuntimeSpecOverrideError = class extends Error {
-      code = "runtime_spec_override_invalid";
-      variable;
-      constructor(variable, reason) {
-        super(`${variable} is set but not usable as an npm package spec: ${reason}. Unset it, or set it to a spec npm install accepts (file:/abs/path, a .tgz, or @haven_ai/<pkg>@<version>).`);
-        this.name = "RuntimeSpecOverrideError";
-        this.variable = variable;
+    InvalidCodexTomlError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "InvalidCodexTomlError";
+      }
+    };
+    REPAIR_COMMAND_PREFIX = sdk.connectorRerunCommand("--doctor --repair --runtime");
+    UnreadableRuntimeConfigError = class extends Error {
+      configPath;
+      constructor(configPath, detail) {
+        super(`${configPath} is not a config Haven can merge into (${detail})`);
+        this.name = "UnreadableRuntimeConfigError";
+        this.configPath = configPath;
       }
     };
   }
 });
-async function prepareSignerRuntime(input, deps = {}) {
-  const homeDir = input.homeDir ?? os.homedir();
-  const override = resolveSignerRuntimeOverride(deps.env ?? process.env);
-  const signerSpec = override?.signer ?? signerPackageSpec();
-  const sdkSpec = override?.sdk ?? sdkPackageSpec();
-  const resolvedSpecs = [signerSpec, sdkSpec];
-  const overrideRecord = override ? { specs: override, resolved_specs: resolvedSpecs, directory_key: runtimeSpecOverrideDirectoryKey(resolvedSpecs) } : void 0;
-  const runtimeDirectory = path.resolve(
-    homeDir,
-    ".haven",
-    "signer-runtime",
-    overrideRecord ? overrideRecord.directory_key : MCP_RUNTIME_MANIFEST.signerVersion
-  );
-  const npmCacheDirectory = path.resolve(homeDir, ".haven", "npm-cache");
-  const cliPath = path.join(runtimeDirectory, "node_modules", "@haven_ai", "signer", "dist", "cli.js");
-  const messages = [];
-  if (override) {
-    messages.push(...runtimeSpecOverrideNotice(
-      "signer runtime",
-      override,
-      { signer: signerPackageSpec(), sdk: sdkPackageSpec() },
-      runtimeDirectory
-    ));
+async function acknowledgeLocalMcpConsent(identityPath, signerPath, log) {
+  try {
+    const input = await buildLocalMcpConsentInput(identityPath, signerPath);
+    const decision = await mcp.ensureConsent(input, {
+      credentialsPath: identityPath,
+      writeAck: true,
+      out: log ? { write: (chunk) => writeLogChunk(log, chunk) } : void 0
+    });
+    return {
+      acknowledged: decision.ok,
+      hash: decision.hash,
+      reason: decision.reason
+    };
+  } catch (err) {
+    return {
+      acknowledged: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
   }
-  await promises.mkdir(runtimeDirectory, { recursive: true, mode: 448 });
-  await promises.chmod(runtimeDirectory, 448).catch(() => void 0);
-  await promises.mkdir(npmCacheDirectory, { recursive: true, mode: 448 });
-  await promises.chmod(npmCacheDirectory, 448).catch(() => void 0);
-  if (override) {
-    await installRuntimePackages(runtimeDirectory, npmCacheDirectory, resolvedSpecs, deps);
-    messages.push(`Installed local Haven signer runtime from override (${resolvedSpecs.join(" ")}).`);
-  } else if (await installedRuntimeMatches(runtimeDirectory, cliPath)) {
-    messages.push(`Using existing local Haven signer runtime ${signerPackageSpec()}.`);
-  } else {
-    await installRuntimePackages(runtimeDirectory, npmCacheDirectory, resolvedSpecs, deps);
-    messages.push(`Installed local Haven signer runtime ${signerPackageSpec()}.`);
+}
+async function getLocalMcpConsentStatus(identityPath, signerPath) {
+  try {
+    const input = await buildLocalMcpConsentInput(identityPath, signerPath);
+    const hash = mcp.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)
+    };
   }
-  await assertFileExists(cliPath, "local Haven signer CLI");
-  const installedVersions = override ? await readInstalledVersions(runtimeDirectory) : void 0;
-  const wrapperPath = path.join(input.credentialDirectory, "bin", "haven-signer.mjs");
-  await writeWrapper({
-    wrapperPath,
-    cliPath,
-    signerPath: input.signerPath,
-    overrideComment: override ? describeRuntimeSpecOverride(override) : void 0
-  });
-  await writeRuntimeSidecar({
-    path: path.join(input.credentialDirectory, "signer-runtime.json"),
-    wrapperPath,
-    runtimeDirectory,
-    npmCacheDirectory,
-    cliPath,
-    serverName: input.serverName,
-    override: overrideRecord,
-    installedVersions
-  });
-  messages.push(`Prepared stable local Haven signer wrapper: ${wrapperPath}`);
-  return {
-    command: wrapperPath,
-    args: [],
-    wrapperPath,
-    runtimeDirectory,
-    npmCacheDirectory,
-    cliPath,
-    messages,
-    ...overrideRecord ? { runtimeSpecOverride: overrideRecord } : {}
-  };
 }
-function resolveSignerRuntimeOverride(env) {
-  const override = resolveRuntimeSpecOverride(env);
-  if (!overrideApplies(override, ["signer", "sdk"])) return void 0;
-  const { signer, sdk } = override;
-  return { ...signer !== void 0 ? { signer } : {}, ...sdk !== void 0 ? { sdk } : {} };
+function localMcpAckPath(identityPath) {
+  return path.resolve(`${identityPath}.ack.json`);
 }
-async function installRuntimePackages(runtimeDirectory, npmCacheDirectory, packageSpecs, deps) {
-  const { runCommand, onProgress } = deps;
-  const baseArgs = [
-    "install",
-    "--prefix",
-    runtimeDirectory,
-    "--no-audit",
-    "--no-fund",
-    "--omit=dev",
-    "--prefer-offline",
-    ...packageSpecs
-  ];
-  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 signer 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 execFileAsync("npm", args, { timeout: SIGNER_INSTALL_TIMEOUT_MS, maxBuffer: 1024 * 1024 });
-    } finally {
-      clearInterval(heartbeat);
+async function buildLocalMcpConsentInput(identityPath, signerPath) {
+  const credentials = await mcp.loadCredentials({ identityPath, signerPath });
+  const unavailableDuringSetup = {
+    getAllowances: async () => {
+      throw new Error("Haven approval is not complete yet.");
     }
   };
+  return mcp.consentInputFromClient(
+    unavailableDuringSetup,
+    {
+      apiKey: credentials.apiKey,
+      apiUrl: credentials.apiUrl,
+      agentId: credentials.agentId,
+      accountAddress: credentials.accountAddress,
+      delegateAddress: credentials.delegateAddress,
+      chainId: credentials.chainId,
+      allowanceSummary: credentials.allowanceSummary
+    },
+    mcp.registeredToolNames()
+  );
+}
+async function readLocalMcpAckFile(path) {
   try {
-    await run(baseArgs);
+    const parsed = JSON.parse(await promises.readFile(path, "utf8"));
+    return typeof parsed.ack === "string" ? parsed.ack : null;
   } catch {
-    try {
-      await run([...baseArgs, "--cache", npmCacheDirectory]);
-    } catch (err) {
-      throw new Error(
-        `Could not install local Haven signer runtime ${packageSpecs.join(" ")}: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
+    return null;
   }
 }
-async function installedRuntimeMatches(runtimeDirectory, cliPath) {
-  return installedRuntimeMatchesVersions(runtimeDirectory, cliPath, {
-    signerVersion: MCP_RUNTIME_MANIFEST.signerVersion,
-    sdkVersion: MCP_RUNTIME_MANIFEST.sdkVersion
-  });
+function writeLogChunk(log, chunk) {
+  const message = String(chunk).trimEnd();
+  if (message) log(message);
 }
-async function installedRuntimeMatchesVersions(runtimeDirectory, cliPath, expected) {
+var init_local_mcp_consent = __esm({
+  "src/local-mcp-consent.ts"() {
+  }
+});
+async function probeHostedAgentIdentity(apiKey, apiUrl, fetchImpl = fetch) {
+  let response;
   try {
-    await assertFileExists(cliPath, "local Haven signer CLI");
-    const installed = await readInstalledVersions(runtimeDirectory);
-    return installed.signerVersion === expected.signerVersion && installed.sdkVersion === expected.sdkVersion;
+    response = await fetchWithTimeout(fetchImpl, `${apiUrl.replace(/\/+$/, "")}/machine-payments/agent`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" }
+    });
   } catch {
-    return false;
+    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 readInstalledVersions(runtimeDirectory) {
-  const [signerPackage, sdkPackage] = await Promise.all([
-    readPackageJson(path.join(runtimeDirectory, "node_modules", "@haven_ai", "signer", "package.json")),
-    readPackageJson(path.join(runtimeDirectory, "node_modules", "@haven_ai", "sdk", "package.json"))
-  ]);
-  return { signerVersion: signerPackage.version ?? "", sdkVersion: sdkPackage.version ?? "" };
-}
-async function readPackageJson(path) {
-  return JSON.parse(await promises.readFile(path, "utf8"));
-}
-async function writeWrapper(input) {
-  await promises.mkdir(path.dirname(input.wrapperPath), { recursive: true, mode: 448 });
-  await promises.chmod(path.dirname(input.wrapperPath), 448).catch(() => void 0);
-  const source = [
-    "#!/usr/bin/env node",
-    ...input.overrideComment ? [`// HAVEN RUNTIME SPEC OVERRIDE (#2424): ${input.overrideComment} \u2014 this wrapper launches a NON-pinned signer build.`] : [],
-    "import { spawn } from 'node:child_process'",
-    "",
-    `const cliPath = ${JSON.stringify(input.cliPath)}`,
-    `const signerPath = ${JSON.stringify(input.signerPath)}`,
-    "",
-    "const child = spawn(process.execPath, [cliPath, '--credentials', 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 promises.writeFile(input.wrapperPath, source, { mode: 448 });
-  await promises.chmod(input.wrapperPath, 448).catch(() => void 0);
+async function probeHostedMcpTools(apiKey, hostedMcpUrl, fetchImpl = fetch) {
+  let response;
+  try {
+    response = await fetchWithTimeout(fetchImpl, hostedMcpUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream"
+      },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list" })
+    });
+  } catch {
+    return { status: "network_error" };
+  }
+  if (response.status === 401 || response.status === 403) return { status: "unauthorized" };
+  if (!response.ok) return { status: "bad_response" };
+  try {
+    const payload = parseJsonRpcPayload(await response.text());
+    if (!payload || payload.error) return { status: "bad_response" };
+    const tools = payload.result?.tools;
+    return { status: "ok", toolCount: Array.isArray(tools) ? tools.length : void 0 };
+  } catch {
+    return { status: "bad_response" };
+  }
 }
-async function readRuntimeSidecar(credentialDirectory) {
+async function probeLocalSignerCredential(signerPath) {
   try {
-    return JSON.parse(
-      await promises.readFile(path.join(credentialDirectory, "signer-runtime.json"), "utf8")
+    const parsed = JSON.parse(await promises.readFile(signerPath, "utf8"));
+    return Boolean(
+      parsed && typeof parsed === "object" && "delegate_key" in parsed && typeof parsed.delegate_key === "string"
     );
   } catch {
-    return null;
+    return false;
   }
 }
-async function writeRuntimeSidecar(input) {
-  const value = {
-    ...input.serverName ? { server_name: input.serverName } : {},
-    signer_package: MCP_RUNTIME_MANIFEST.signerPackage,
-    signer_version: input.installedVersions?.signerVersion ?? MCP_RUNTIME_MANIFEST.signerVersion,
-    sdk_package: MCP_RUNTIME_MANIFEST.sdkPackage,
-    sdk_version: input.installedVersions?.sdkVersion ?? MCP_RUNTIME_MANIFEST.sdkVersion,
-    wrapper_path: input.wrapperPath,
-    runtime_directory: input.runtimeDirectory,
-    npm_cache_directory: input.npmCacheDirectory,
-    cli_path: input.cliPath,
-    ...input.override ? { runtime_spec_override: input.override } : {}
-  };
-  await promises.writeFile(input.path, `${JSON.stringify(value, null, 2)}
-`, { mode: 384 });
-  await promises.chmod(input.path, 384).catch(() => void 0);
+async function probeLocalMcpTools(command, args, requiredTools, timeoutMs = 1e4) {
+  return new Promise((resolve11) => {
+    const child = child_process.spawn(command, args, { stdio: ["pipe", "pipe", "ignore"] });
+    let stdout = "";
+    let settled = false;
+    let sawInitialize = false;
+    let serverInfo;
+    let capabilities;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      child.kill();
+      resolve11(result);
+    };
+    const timeout = setTimeout(() => finish({ status: "timeout" }), timeoutMs);
+    child.on("error", () => finish({ status: "process_error" }));
+    child.on("exit", (code) => {
+      if (!settled && code !== 0) finish({ status: "process_error" });
+    });
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+      const lines = stdout.split(/\r?\n/);
+      stdout = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let payload;
+        try {
+          payload = JSON.parse(trimmed);
+        } catch {
+          continue;
+        }
+        if (payload.error) {
+          finish({ status: "bad_response" });
+          return;
+        }
+        if (payload.id === 1 && !sawInitialize) {
+          sawInitialize = true;
+          const init = payload.result;
+          serverInfo = init?.serverInfo;
+          capabilities = init?.capabilities;
+          writeJsonRpc(child, { jsonrpc: "2.0", method: "notifications/initialized", params: {} });
+          writeJsonRpc(child, { jsonrpc: "2.0", id: 2, method: "tools/list", params: {} });
+          continue;
+        }
+        if (payload.id === 2) {
+          const tools = payload.result?.tools;
+          const toolNames = Array.isArray(tools) ? tools.map((tool) => tool && typeof tool === "object" && "name" in tool ? tool.name : void 0).filter((name) => typeof name === "string") : [];
+          const missing = requiredTools.filter((name) => !toolNames.includes(name));
+          finish({ status: missing.length === 0 ? "ok" : "missing_tools", toolNames, serverInfo, capabilities });
+          return;
+        }
+      }
+    });
+    writeJsonRpc(child, {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: {
+        protocolVersion: "2025-06-18",
+        capabilities: {},
+        clientInfo: { name: "haven-connect-probe", version: "0.0.0" }
+      }
+    });
+  });
 }
-async function assertFileExists(path, label) {
+function writeJsonRpc(child, payload) {
+  child.stdin?.write(`${JSON.stringify(payload)}
+`);
+}
+function parseJsonRpcPayload(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("{")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return null;
+    }
+  }
+  const dataLines = trimmed.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
+  for (let i = dataLines.length - 1; i >= 0; i -= 1) {
+    try {
+      return JSON.parse(dataLines[i]);
+    } catch {
+    }
+  }
+  return null;
+}
+async function fetchWithTimeout(fetchImpl, url, init) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 3e3);
   try {
-    await promises.access(path);
-  } catch {
-    throw new Error(`Missing ${label}: ${path}`);
+    return await fetchImpl(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timeout);
   }
 }
-var execFileAsync, SIGNER_INSTALL_TIMEOUT_MS, SIGNER_INSTALL_HEARTBEAT_MS;
-var init_signer_runtime = __esm({
-  "src/signer-runtime.ts"() {
-    init_runtime_manifest();
-    init_runtime_spec_override();
-    execFileAsync = util.promisify(child_process.execFile);
-    SIGNER_INSTALL_TIMEOUT_MS = 6e5;
-    SIGNER_INSTALL_HEARTBEAT_MS = 15e3;
+var init_probes = __esm({
+  "src/probes.ts"() {
   }
 });
 async function prepareLocalMcpRuntime(input, deps = {}) {
@@ -2272,33 +2554,11 @@ function hermesHome(deps) {
   const env = deps.env ?? process.env;
   return env.HERMES_HOME ?? path.join(deps.homeDir ?? os.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
-function isConnectError(err) {
-  return err instanceof ConnectError;
-}
-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;
-      }
-    };
+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 -->";
   }
 });
 
@@ -3003,9 +3263,23 @@ function installedClientTargets(homeDir = os.homedir(), cwd = process.cwd(), env
       runtime: "claude-code",
       label: "Claude Code",
       // Claude Code is configured through its own CLI (`claude mcp add-json`),
-      // not by writing a file this module owns — so its evidence is the
-      // client directory, never a config path.
+      // not by writing a file this module owns — so `configPath` stays null
+      // and the write still goes through the CLI. But a user-scope
+      // `~/.claude.json` carrying an `mcpServers` key IS config-file
+      // evidence: the user has already pointed Claude Code at some MCP
+      // server. It is not the file the connector would write, hence the
+      // separate evidence path (#3732): without it, a Codex config won by
+      // construction on any machine where the user runs Claude Code.
       configPath: null,
+      evidencePath: path.join(homeDir, ".claude.json"),
+      evidenceMatches: (contents) => {
+        try {
+          const parsed = JSON.parse(contents);
+          return typeof parsed === "object" && parsed !== null && "mcpServers" in parsed;
+        } catch {
+          return false;
+        }
+      },
       markers: [path.join(homeDir, ".claude"), path.join(homeDir, ".claude.json")]
     },
     {
@@ -3037,7 +3311,10 @@ function installedClientTargets(homeDir = os.homedir(), cwd = process.cwd(), env
     },
     {
       runtime: "claude-desktop",
-      label: "Claude Desktop",
+      // The chat app, a separate runtime from Claude Code. Named so a user in
+      // the desktop app's Code tab cannot read this row as "where I am" —
+      // it sorted above Claude Code whenever both had config (#3732).
+      label: "Claude Desktop (chat app)",
       configPath: runtimeConfigPathFor("claude-desktop", homeDir),
       markers: []
     },
@@ -3052,6 +3329,7 @@ function installedClientTargets(homeDir = os.homedir(), cwd = process.cwd(), env
 }
 async function scanInstalledClients(options = {}) {
   const exists = options.exists ?? pathExists;
+  const readFile15 = options.readFile ?? ((path) => promises.readFile(path, "utf8"));
   const targets = installedClientTargets(options.homeDir, options.cwd, options.env ?? process.env);
   const found = [];
   for (const target of targets) {
@@ -3061,6 +3339,18 @@ async function scanInstalledClients(options = {}) {
         label: target.label,
         detail: `MCP config found at ${target.configPath}`,
         configPath: target.configPath,
+        evidencePath: target.configPath,
+        evidence: "config-file"
+      });
+      continue;
+    }
+    if (target.evidencePath && await hasConfigEvidence(target, exists, readFile15)) {
+      found.push({
+        runtime: target.runtime,
+        label: target.label,
+        detail: `MCP config found at ${target.evidencePath}`,
+        configPath: target.configPath,
+        evidencePath: target.evidencePath,
         evidence: "config-file"
       });
       continue;
@@ -3072,6 +3362,7 @@ async function scanInstalledClients(options = {}) {
         label: target.label,
         detail: `installed (${marker})`,
         configPath: target.configPath,
+        evidencePath: null,
         evidence: "client-directory"
       });
       break;
@@ -3082,6 +3373,16 @@ async function scanInstalledClients(options = {}) {
     return SCAN_ORDER.indexOf(a.runtime) - SCAN_ORDER.indexOf(b.runtime);
   });
 }
+async function hasConfigEvidence(target, exists, readFile15) {
+  const path = target.evidencePath;
+  if (!await exists(path)) return false;
+  if (!target.evidenceMatches) return true;
+  try {
+    return target.evidenceMatches(await readFile15(path));
+  } catch {
+    return false;
+  }
+}
 function installedClientHint(candidates) {
   const installedClients = candidates.map((candidate) => candidate.runtime);
   if (candidates.length === 1) {
@@ -3092,18 +3393,24 @@ function installedClientHint(candidates) {
 }
 async function promptForInstalledClient(candidates, io = defaultPromptIo()) {
   if (candidates.length === 0) throw noInstalledClientsError();
+  const hint = installedClientHint(candidates);
   io.write("Haven could not detect which agent runtime this is.\n");
   io.write("These agent clients are installed on this machine:\n");
   candidates.forEach((candidate, index) => {
-    io.write(`  ${index + 1}) ${candidate.label} \u2014 ${candidate.detail}
+    const suggested = hint.suggestedRuntime === candidate.runtime ? " (suggested)" : "";
+    io.write(`  ${index + 1}) ${candidate.label}${suggested} \u2014 ${candidate.detail}
 `);
   });
   io.write("Haven writes an API key and a signing key into the client you pick, so pick the one your agent actually runs in.\n");
   for (let attempt = 0; attempt < MAX_PROMPT_ATTEMPTS; attempt += 1) {
-    const answer = await io.question(`Which one? [1-${candidates.length}] (default 1 \u2014 ${candidates[0].label}): `);
+    const answer = await io.question(`Which one? [1-${candidates.length}]: `);
     if (answer === null) throw promptAbortedError("the prompt was cancelled");
     const trimmed = answer.trim();
-    if (trimmed === "") return candidates[0].runtime;
+    if (trimmed === "") {
+      io.write(`Type the number of the client to configure (1-${candidates.length}).
+`);
+      continue;
+    }
     const picked = Number.parseInt(trimmed, 10);
     if (Number.isInteger(picked) && picked >= 1 && picked <= candidates.length) {
       return candidates[picked - 1].runtime;
@@ -3176,138 +3483,6 @@ var init_installed_clients = __esm({
     MAX_PROMPT_ATTEMPTS = 3;
   }
 });
-
-// src/tombstone.ts
-var tombstone_exports = {};
-__export(tombstone_exports, {
-  ROOT_TOMBSTONES_DIRNAME: () => ROOT_TOMBSTONES_DIRNAME,
-  TOMBSTONE_FILENAME: () => TOMBSTONE_FILENAME,
-  TOMBSTONE_MARKER: () => TOMBSTONE_MARKER,
-  defaultTombstonesDir: () => defaultTombstonesDir,
-  readAgentTombstone: () => readAgentTombstone,
-  readTombstoneRecords: () => readTombstoneRecords,
-  tombstonesDirForAgentDirectory: () => tombstonesDirForAgentDirectory,
-  tombstonesDirForCredentialRoot: () => tombstonesDirForCredentialRoot,
-  writeAgentTombstone: () => writeAgentTombstone
-});
-function defaultTombstonesDir(baseDir) {
-  return path.join(baseDir ?? path.join(os.homedir(), ".haven"), "tombstones");
-}
-function tombstonesDirForCredentialRoot(credentialRoot, homeDir = os.homedir()) {
-  if (!credentialRoot) return defaultTombstonesDir(path.join(homeDir, ".haven"));
-  const root = path.resolve(credentialRoot);
-  if (root === path.resolve(homeDir, ".haven", "agents")) return defaultTombstonesDir(path.join(homeDir, ".haven"));
-  return path.join(root, ROOT_TOMBSTONES_DIRNAME);
-}
-function tombstonesDirForAgentDirectory(directory, homeDir = os.homedir()) {
-  return tombstonesDirForCredentialRoot(path.dirname(path.resolve(directory)), homeDir);
-}
-async function readTombstoneRecords(tombstonesDir) {
-  const root = tombstonesDir ?? defaultTombstonesDir();
-  let entries = [];
-  try {
-    entries = await promises.readdir(root);
-  } catch {
-    return [];
-  }
-  const records = [];
-  for (const entry of entries) {
-    if (!entry.endsWith(".json")) continue;
-    const recordPath = path.join(root, entry);
-    try {
-      const parsed = JSON.parse(await promises.readFile(recordPath, "utf8"));
-      if (typeof parsed?.agent_id === "string") {
-        records.push({ ...parsed, recordPath });
-      }
-    } catch {
-    }
-  }
-  return records;
-}
-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: ${sdk.connectorRerunCommand("--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 promises.stat(input.directory).catch(() => null);
-  if (!dirStat?.isDirectory()) {
-    throw new ConnectError(
-      "tombstone_directory_not_found",
-      `Not a directory: ${input.directory} \u2014 nothing to tombstone. Agent directories are named by their wiring SLUG when the agent has one, and by the agent id otherwise \u2014 so a path built from an agent id will not exist for a named agent. List ~/.haven/agents (or read the directories from --doctor --json) and pass one of those.`,
-      "retry_with_an_existing_agent_directory"
-    );
-  }
-  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 = path.join(input.directory, "bin");
-  await promises.mkdir(binDir, { recursive: true });
-  const wrapperPath = path.join(binDir, "haven-signer.mjs");
-  await promises.writeFile(wrapperPath, tombstoneScript(info), "utf8");
-  await promises.chmod(wrapperPath, 493);
-  const record = JSON.stringify(info, null, 2) + "\n";
-  await promises.writeFile(path.join(input.directory, TOMBSTONE_FILENAME), record, "utf8");
-  const root = input.tombstonesDir ?? defaultTombstonesDir();
-  const recordPath = path.join(root, `${info.agent_id}.json`);
-  try {
-    await promises.mkdir(root, { recursive: true, mode: 448 });
-    await promises.writeFile(recordPath, record, { mode: MIRROR_MODE });
-  } catch (err) {
-    const code = err?.code;
-    return { ...info, recordPath: null, mirrorError: typeof code === "string" && /^E[A-Z]+$/.test(code) ? code : "mirror_write_failed" };
-  }
-  return { ...info, recordPath };
-}
-async function readAgentTombstone(directory) {
-  try {
-    const parsed = JSON.parse(await promises.readFile(path.join(directory, TOMBSTONE_FILENAME), "utf8"));
-    if (typeof parsed?.agent_id !== "string") return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-var TOMBSTONE_FILENAME, ROOT_TOMBSTONES_DIRNAME, MIRROR_MODE, TOMBSTONE_MARKER;
-var init_tombstone = __esm({
-  "src/tombstone.ts"() {
-    init_redact();
-    init_connect_error();
-    TOMBSTONE_FILENAME = "TOMBSTONE.json";
-    ROOT_TOMBSTONES_DIRNAME = ".tombstones";
-    MIRROR_MODE = 384;
-    TOMBSTONE_MARKER = "HAVEN-TOMBSTONE";
-  }
-});
 async function detectWiringCollision(input) {
   const root = defaultCredentialRoot(input.credentialsDir);
   let entries = [];
@@ -3345,17 +3520,45 @@ async function detectWiringCollision(input) {
     suggestedServerName: proposeServerSlug(input.agentName, taken)
   };
 }
-function proposeServerSlug(agentName, taken) {
-  let base = agentName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").slice(0, 32).replace(/-+$/g, "");
+function proposeServerSlug(agentName, taken, maxBaseLength = 32) {
+  let base = agentName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").slice(0, maxBaseLength).replace(/-+$/g, "");
   if (!slugIsValid(base)) base = "agent";
   if (!taken.has(base)) return base;
   for (let n = 2; n < 1e3; n += 1) {
     const suffix = `-${n}`;
-    const candidate = `${base.slice(0, 32 - suffix.length).replace(/-+$/g, "")}${suffix}`;
+    const candidate = `${base.slice(0, maxBaseLength - suffix.length).replace(/-+$/g, "")}${suffix}`;
     if (slugIsValid(candidate) && !taken.has(candidate)) return candidate;
   }
   throw new Error(`Could not propose an unused server name for ${JSON.stringify(agentName)}.`);
 }
+function deriveServerSlug(agentName, taken, markNonProduction) {
+  const mark = "-dev";
+  if (!markNonProduction) return proposeServerSlug(agentName, taken);
+  const base = proposeServerSlug(agentName, taken, 32 - mark.length);
+  if (base.endsWith(mark)) return base;
+  const marked = `${base}${mark}`;
+  if (!taken.has(marked)) return marked;
+  return proposeServerSlug(marked, taken);
+}
+async function listTakenDirectoryNames(credentialsDir) {
+  const root = defaultCredentialRoot(credentialsDir);
+  let entries = [];
+  try {
+    entries = await promises.readdir(root);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+  const taken = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    try {
+      if (!(await promises.stat(path.join(root, entry))).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    taken.add(entry);
+  }
+  return taken;
+}
 function slugIsValid(slug) {
   try {
     assertValidServerSlug(slug);
@@ -3371,7 +3574,7 @@ async function promptWiringCollisionResolution(collision, agentName, io) {
   io.write(`Setting up "${agentName}" on the bare haven / haven-signer pair would replace that wiring.
 `);
   io.write("  r) replace \u2014 re-point haven / haven-signer at the new agent and retire the previous directory locally\n");
-  io.write("     (tombstoned, local key files removed; you still revoke it on the Haven agent page)\n");
+  io.write("     (tombstoned, local key files removed; you still use Remove agent\u2026 on the Haven agent page)\n");
   io.write(`  a) alongside \u2014 install as a named agent (suggested: ${collision.suggestedServerName}) with its own
 `);
   io.write(`     haven-<name> / haven-signer-<name> pair, leaving the current wiring untouched
@@ -3594,7 +3797,7 @@ async function decideTeardown(identity, input) {
         status: "retained",
         probe: "ok",
         detail: "This agent is still ACTIVE on the backend: its API key and delegate key still carry spend authority, so destroying them would be a live spend-authority change. Key material kept in this directory (0o600); its MCP wiring above is gone.",
-        remedy: `Revoke the agent on the Haven agent page (connect never revokes), then re-run --unwire; or, to delete the key anyway, re-run with ${DESTROY_FLAG}.`
+        remedy: `Use Remove agent\u2026 on the Haven agent page (connect never revokes), then re-run --unwire; or, to delete the key anyway, re-run with ${DESTROY_FLAG}.`
       };
     case "unauthorized":
       return {
@@ -3755,7 +3958,16 @@ async function executeConnect(options, deps, trace) {
   log("Checked local credential storage \u2014 all clear.");
   let serverName = options.serverName;
   let replacing;
-  if (!serverName) {
+  if (!serverName && options.deriveServerName) {
+    const taken = await listTakenDirectoryNames(options.credentialsDir);
+    const nonProduction = setup.haven_wallet.chain_id !== PRODUCTION_CHAIN_ID;
+    serverName = deriveServerSlug(setup.agent.name, taken, nonProduction);
+    await assertServerSlugAvailable(serverName, options.credentialsDir);
+    const derivedNames = serverNamesFor(serverName);
+    log(
+      `Naming this agent's MCP pair from its display name: ${derivedNames.hosted} / ${derivedNames.signer}. Nothing was displaced; to wire the bare haven / haven-signer pair instead, re-run with --bare, or choose the name yourself with --name <slug>.`
+    );
+  } else if (!serverName) {
     const collision = await detectWiringCollision({
       credentialsDir: options.credentialsDir,
       agentName: setup.agent.name
@@ -3981,15 +4193,15 @@ async function executeConnect(options, deps, trace) {
     if (supersededAgentsRetiredLocally === true) {
       log("");
       log(
-        `Replaced: previous agent(s) ${supersededIds(replacing)} are retired on this machine but NOT revoked \u2014 revoke them on the Haven agent page, then restart EVERY long-lived host (gateways, TUI workers, editors): each holds the MCP wiring snapshot from its own start time, and the tombstone speaks only when a stale host next probes the old path.`
+        `Replaced: previous agent(s) ${supersededIds(replacing)} are retired on this machine but NOT revoked \u2014 use Remove agent\u2026 on the Haven agent page for each (it ends their live budgets), then restart EVERY long-lived host (gateways, TUI workers, editors): each holds the MCP wiring snapshot from its own start time, and the tombstone speaks only when a stale host next probes the old path.`
       );
     } else if (supersededAgentIds.length > 0) {
       log("");
       log(
-        `Heads-up: this setup created a NEW agent. Your previous agent(s) \u2014 ${supersededAgentIds.join(", ")} \u2014 still exist with their own keys, and any host that was already running keeps acting as them.`
+        `Heads-up: other agent directories on this machine \u2014 ${supersededAgentIds.join(", ")}. This setup created a NEW agent and revoked none of them; any not revoked in Haven keep their own keys and any budgets.`
       );
       log(
-        `If you meant to replace them: revoke them on the Haven agent page, then restart EVERY long-lived host (gateways, TUI workers, editors) \u2014 each holds the MCP wiring snapshot from its own start time, so after repeated setups each can be stuck on a DIFFERENT old agent. Then remove their directories under ~/.haven/agents (or ${RERUN_HINT} --tombstone <dir> to leave a diagnostic in their place). Run ${RERUN_HINT} --doctor to check whether their keys are still live.`
+        `To retire one you no longer use: use Remove agent\u2026 on its Haven agent page (it ends its live budget), restart any long-lived host (gateways, TUI workers, editors) still wired to it \u2014 each holds the MCP wiring snapshot from its own start time \u2014 and remove its directory under ~/.haven/agents (or ${RERUN_HINT} --tombstone <dir> to leave a diagnostic in its place). To rewire the bare haven / haven-signer pair instead of adding an agent, re-run with --replace. Run ${RERUN_HINT} --doctor to check which keys are still live.`
       );
     }
   } catch {
@@ -4020,6 +4232,18 @@ async function executeConnect(options, deps, trace) {
   } catch (err) {
     log(`Could not report install status to Haven: ${err instanceof Error ? err.message : String(err)}`);
   }
+  const reportableRetiredIds = [...new Set(retiredAgentIds.filter((id) => UUID_SHAPE.test(id)))];
+  if (reportableRetiredIds.length > 0 && api.reportRetiredAgents) {
+    try {
+      await api.reportRetiredAgents({
+        setupId: registration.setup_id,
+        apiKey: localApiKey,
+        retiredAgentIds: reportableRetiredIds
+      });
+    } catch (err) {
+      log(`Could not tell Haven which agents were retired: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
   let approval;
   const narrateApprovalWait = options.waitForApproval === true || options.waitForApproval === void 0 && (deps.isStdoutTty ?? Boolean(process.stdout.isTTY));
   if (narrateApprovalWait && !runtimeInstall.errorCode) {
@@ -4030,12 +4254,29 @@ async function executeConnect(options, deps, trace) {
     runtimeInstall,
     delegateAddress: registration.delegate_address,
     hostedMcpUrl: registration.hosted_mcp_url,
+    // #3737: the resolved name — derived, explicit, or the bare pair — rides
+    // the machine-readable outcome alongside the prose completion text.
+    serverName,
     supersededAgentIds,
     supersededAgentsRetiredLocally,
     ...replacing ? { retiredAgentIds } : {},
     ...Object.keys(retirementMirrorErrors).length > 0 ? { retirementMirrorErrors } : {},
     existingAgentsBeforeWrite: existingAgents.map((a) => ({ agent_id: a.agentId, account_address: a.accountAddress })),
     ...reboundFrom ? { serverNameReboundFrom: reboundFrom } : {},
+    // #3772: only when the install completed. An install that ended with an
+    // error code may not have written the wiring, and on --replace it leaves the
+    // old agent's wiring as possibly the only working one (retirement is skipped
+    // on the same condition) — so it gets no such sentence. That includes
+    // manual_runtime_setup_required, deliberately: the connector wrote nothing
+    // and the manual instruction already says to start a fresh session. A
+    // --replace names every displaced agent even when no binding record exists
+    // (pre-0.4.0 wiring, or a failed best-effort write).
+    ...!runtimeInstall.errorCode && (replacing || reboundFrom) ? {
+      staleSession: {
+        agentIds: [.../* @__PURE__ */ new Set([...replacing?.superseded.map((entry) => entry.agentId) ?? [], ...reboundFrom ? [reboundFrom.agent_id] : []])],
+        ...reboundFrom?.backend_changed ? { otherBackendAgentId: reboundFrom.agent_id } : {}
+      }
+    } : {},
     setupChallengeExpiresAt: setup.challenge.expires_at,
     approvalRequired: registration.agent_status === "pending_approval",
     approvalUrl: registration.approval_url
@@ -4051,6 +4292,10 @@ async function executeConnect(options, deps, trace) {
     outcome
   };
 }
+function staleSessionNotice(previousAgentIds, otherBackendAgentId) {
+  const one = previousAgentIds.length === 1;
+  return `Any session that was already running keeps acting as the previous agent${one ? "" : "s"} (${previousAgentIds.join(", ")}) until it is restarted, and ${one ? "that agent" : "they"} may still be active in Haven` + (otherBackendAgentId ? ` (${otherBackendAgentId} is on the backend it was created on, not this one)` : "") + `: if ${one ? "it" : "they"} should no longer spend, use Remove agent\u2026 on the Haven agent page (it ends ${one ? "its" : "their"} live budgets).`;
+}
 function completionOutcome(input) {
   const { runtimeInstall } = input;
   const manualSetup = runtimeInstall.errorCode === "manual_runtime_setup_required";
@@ -4068,7 +4313,10 @@ function completionOutcome(input) {
     probe: { result: runtimeInstall.probeResult },
     activation: {
       restart_required: runtimeInstall.restartRequired,
-      instruction: manualSetup ? "Finish the manual MCP setup using the secret-free references shown in normal Connect output, then start a fresh session." : runtimeProfile(runtimeInstall.runtime).activationInstruction
+      instruction: (manualSetup ? "Finish the manual MCP setup using the secret-free references shown in normal Connect output, then start a fresh session." : runtimeProfile(runtimeInstall.runtime).activationInstruction) + // #3772: a rebind changes which agent the server name means, but a
+      // session that is already running keeps the config it loaded — it
+      // goes on acting as the previous agent, which Connect never revokes.
+      (input.staleSession && input.staleSession.agentIds.length > 0 ? ` ${staleSessionNotice(input.staleSession.agentIds, input.staleSession.otherBackendAgentId)}` : "")
     },
     next_action: nextAction2,
     approval: {
@@ -4104,6 +4352,9 @@ function completionOutcome(input) {
     // #3122: always emitted on a completed run (empty list included), for the
     // same reason as superseded_agent_ids above.
     existing_agents_before_write: input.existingAgentsBeforeWrite ?? [],
+    // #3737: the resolved hosted server name — always present on a completed
+    // run, bare pair included, so a caller never has to parse the prose.
+    server_name: serverNamesFor(input.serverName).hosted,
     ...input.serverNameReboundFrom ? { server_name_rebound_from: input.serverNameReboundFrom } : {},
     ...input.setupChallengeExpiresAt ? { setup_challenge_expires_at: input.setupChallengeExpiresAt } : {},
     ...runtimeInstall.errorCode ? { error: { code: runtimeInstall.errorCode, next_action: nextAction2 } } : {}
@@ -4127,7 +4378,8 @@ function installedClientProse(hint) {
 }
 function runtimeSelectionPrompt(options, deps) {
   if (!interactivePromptAllowed(options, deps)) return void 0;
-  return deps.promptRuntime ?? (() => resolveRuntimeByInstalledClientPrompt());
+  if (deps.promptRuntime) return deps.promptRuntime;
+  return () => (deps.promptRuntimeByInstalledClient ?? resolveRuntimeByInstalledClientPrompt)({ env: deps.env });
 }
 function interactivePromptAllowed(options, deps) {
   if (options.interactive !== true) return false;
@@ -4153,7 +4405,7 @@ async function resolveWiringCollision(collision, agentName, options, deps) {
   }
   throw new ConnectError(
     "wiring_collision",
-    `This machine is already wired to a Haven agent with a live key (${supersededIds(collision)}), and setting up "${agentName}" on the bare haven / haven-signer pair would replace that wiring. Nothing was written and the Haven setup token is still unused. If you are an AI agent running this command: do NOT add a flag yourself \u2014 relay this to your user and stop. Your user decides: REPLACE the existing wiring (re-run the same command with --replace added, which re-points the pair at the new agent and retires the previous directory locally \u2014 they still revoke the old agent on the Haven agent page), or install ALONGSIDE it (re-run with --name <slug> added, e.g. --name ${collision.suggestedServerName}, which gives the new agent its own haven-<slug> / haven-signer-<slug> pair). Re-run only with the flag your user chooses.`,
+    `This machine is already wired to a Haven agent with a live key (${supersededIds(collision)}), and setting up "${agentName}" on the bare haven / haven-signer pair would replace that wiring. Nothing was written and the Haven setup token is still unused. If you are an AI agent running this command: do NOT add a flag yourself \u2014 relay this to your user and stop. Your user decides: REPLACE the existing wiring (re-run the same command with --replace added, which re-points the pair at the new agent and retires the previous directory locally \u2014 they still use Remove agent\u2026 on the Haven agent page to end the old agent\u2019s budgets), or install ALONGSIDE it (re-run with --name <slug> added, e.g. --name ${collision.suggestedServerName}, which gives the new agent its own haven-<slug> / haven-signer-<slug> pair). Re-run only with the flag your user chooses.`,
     "relay_wiring_collision_to_user",
     { supersededAgentIds: collision.superseded.map((e) => e.agentId), suggestedServerName: collision.suggestedServerName }
   );
@@ -4434,7 +4686,7 @@ async function listOtherAgentIds(baseDir, currentDirectory) {
 function printNextSteps(result, log, approval, approvalUrl) {
   for (const line of completionHandoffLines(result, approval, approvalUrl)) log(line);
 }
-var CONNECTOR_VERSION, CONNECTOR_CLIENT_IDENTITY, CONNECT_OUTCOME_SCHEMA_VERSION, failureOutcomesByError, RERUN_HINT;
+var CONNECTOR_VERSION, PRODUCTION_CHAIN_ID, UUID_SHAPE, CONNECTOR_CLIENT_IDENTITY, CONNECT_OUTCOME_SCHEMA_VERSION, failureOutcomesByError, RERUN_HINT;
 var init_runtime = __esm({
   "src/runtime.ts"() {
     init_api();
@@ -4451,7 +4703,9 @@ var init_runtime = __esm({
     init_tombstone();
     init_local_mcp_runtime();
     init_runtime_manifest();
-    CONNECTOR_VERSION = "0.8.1-alpha.0";
+    CONNECTOR_VERSION = "0.10.0-alpha.0";
+    PRODUCTION_CHAIN_ID = 8453;
+    UUID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
     CONNECTOR_CLIENT_IDENTITY = `@haven_ai/connect/${CONNECTOR_VERSION}`;
     CONNECT_OUTCOME_SCHEMA_VERSION = 1;
     failureOutcomesByError = /* @__PURE__ */ new WeakMap();
@@ -4661,9 +4915,10 @@ async function startRekey(options, deps = {}) {
     started_at: startedAt,
     expires_at: expiresAt
   });
+  const finishName = options.serverName ?? stored.discoveredSlug;
   const finishCommand = [
     sdk.connectorRerunCommand("--rekey-finish"),
-    options.serverName ? `--name ${options.serverName}` : void 0,
+    finishName ? `--name ${finishName}` : void 0,
     "--api-key <the key the dashboard showed you>",
     options.runtime ? `--runtime ${options.runtime}` : "--runtime <your runtime>"
   ].filter(Boolean).join(" ");
@@ -4931,6 +5186,40 @@ function rollUpLevel(checks) {
   if (checks.some((check) => check.level === "advisory")) return "advisory";
   return "ok";
 }
+function runWrapperAck(wrapperPath, timeoutMs = 3e4) {
+  return new Promise((resolve11, reject) => {
+    const child = child_process.spawn(wrapperPath, ["--ack"], { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill();
+      reject(new Error(`signer --ack timed out after ${Math.round(timeoutMs / 1e3)}s`));
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (code === 0) resolve11({ stdout });
+      else reject(new Error(`signer --ack exited ${code ?? "abnormally"}`));
+    });
+  });
+}
+function repairCommandNamedFor(runtime, slug) {
+  const nameFlag = ` --name ${slug}`;
+  if (normalizeRuntimeName(runtime)) return `Run: ${RERUN} --doctor --repair --runtime ${runtime}${nameFlag}`;
+  return `Run: ${RERUN} --doctor --repair --runtime <runtime>${nameFlag} \u2014 --repair needs the runtime named; one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`;
+}
 function runtimeFlagFor(runtime) {
   return normalizeRuntimeName(runtime) ? ` --runtime ${runtime}` : "";
 }
@@ -5012,6 +5301,35 @@ async function discoverCredentialDirectory(homeDir, explicit) {
     identityDirectories
   };
 }
+async function readClaudeCodeWiringEvidence(homeDir) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await promises.readFile(path.join(homeDir, ".claude.json"), "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const blocks = [parsed.mcpServers];
+  const projects = parsed.projects;
+  if (typeof projects === "object" && projects !== null) {
+    for (const project of Object.values(projects)) {
+      if (typeof project === "object" && project !== null) blocks.push(project.mcpServers);
+    }
+  }
+  const lines = [];
+  for (const block of blocks) {
+    if (typeof block !== "object" || block === null) continue;
+    for (const [name, server] of Object.entries(block)) {
+      const entry = typeof server === "object" && server !== null ? server : {};
+      const parts = [JSON.stringify(name) + ":"];
+      if (typeof entry.command === "string") parts.push(entry.command);
+      if (Array.isArray(entry.args)) parts.push(...entry.args.filter((arg) => typeof arg === "string"));
+      if (typeof entry.url === "string") parts.push(entry.url);
+      lines.push(parts.join(" "));
+    }
+  }
+  return lines.length > 0 ? lines.join("\n") : null;
+}
 function agentIsWired(configText, names, slug, identity, sidecar, isPrimary, bareOwnerExists) {
   if (configText === null) return isPrimary;
   if (slug) {
@@ -5257,8 +5575,11 @@ async function verdictsForAgent(entry, input, deps) {
         id: "signer_process",
         label: "Signer stdio handshake",
         level: "failed",
-        detail: "The local-tools consent is not acknowledged, so the signer refuses to start (by design).",
-        repair: `Run: ${RERUN} --ack-local-tools --setup <token>  (or re-run your original connector command with --ack-local-tools).`
+        // #3799: honest about what the mismatch does and does not prove. The
+        // stored ack covers a tool SET; a doctor bundled with a newer signer
+        // reports exactly this against an older, still-working install.
+        detail: "The stored local-tools consent does not match the tool set this connector bundles \u2014 by design a signer with a different tool set refuses to start. This does not prove the currently running signer is broken: a doctor newer than the installed signer reports exactly this mismatch.",
+        repair: `Run: ${sidecar.wrapper_path} --ack < /dev/null \u2014 re-acknowledge consent with the installed signer, no setup token needed. Or re-run repair with --ack-local-tools: ${repairCommandFor(input.runtime, " --ack-local-tools", input.repairDir)}.`
       });
     } else {
       const probe = await (deps.probeSignerTools ?? probeLocalMcpTools)(
@@ -5289,12 +5610,21 @@ async function verdictsForAgent(entry, input, deps) {
   }
   return { checks, ...signerCapabilities ? { signerCapabilities } : {} };
 }
+async function resolveNamedDirectory(input, homeDir) {
+  if (!input.serverName) return input.credentialsDir;
+  if (input.credentialsDir) {
+    await assertDirectoryRecordsSlug(input.credentialsDir, input.serverName);
+    return input.credentialsDir;
+  }
+  return resolveAgentDirectoryBySlug(input.serverName, { root: path.join(homeDir, ".haven", "agents") });
+}
 async function runDoctor(input, deps = {}) {
   const homeDir = deps.homeDir ?? os.homedir();
   const checks = [];
   let signerCapabilities;
-  const { directory, others, parkedOnly, identityDirectories } = await discoverCredentialDirectory(homeDir, input.credentialsDir);
-  const nameRepairDir = identityDirectories.length > 1 || Boolean(input.credentialsDir);
+  const namedDir = await resolveNamedDirectory(input, homeDir);
+  const { directory, others, parkedOnly, identityDirectories } = await discoverCredentialDirectory(homeDir, namedDir);
+  const nameRepairDir = identityDirectories.length > 1 || Boolean(namedDir);
   const resolution = await resolveDoctorRuntime(input, directory);
   const runtime = resolution.runtime;
   const input2 = { ...input, runtime };
@@ -5308,6 +5638,7 @@ async function runDoctor(input, deps = {}) {
       configText = null;
     }
   }
+  const claudeCodeWiring = configText === null && normalizedRuntime === "claude-code" ? await readClaudeCodeWiringEvidence(homeDir) : null;
   const allDirectories = directory ? [directory, ...others] : others;
   let bareOwnerExists = false;
   for (const dir of allDirectories) {
@@ -5341,7 +5672,10 @@ async function runDoctor(input, deps = {}) {
       });
       continue;
     }
-    const wired = agentIsWired(configText, names, slug, identity, sidecar, dir === directory, bareOwnerExists);
+    const wired = agentIsWired(configText, names, slug, identity, sidecar, dir === directory, bareOwnerExists) || // Additive only: a name or wrapper path in ~/.claude.json proves this
+    // directory is wired; its absence proves nothing (#3830), so the
+    // fallback verdict above is never downgraded.
+    claudeCodeWiring !== null && agentIsWired(claudeCodeWiring, names, slug, identity, sidecar, false, false);
     const entry = {
       ...slug ? { slug } : {},
       ...identity.agent_id ? { agentId: identity.agent_id } : {},
@@ -5409,15 +5743,20 @@ async function runDoctor(input, deps = {}) {
       id: "runtime_config",
       label: "Runtime MCP config",
       level: "failed",
-      detail: `Runtime is unknown \u2014 no runtime flag was given and the connector's record in ${primaryDirectory ?? input.credentialsDir ?? "~/.haven/agents"} carries no resolvable ${CONNECT_OUTCOME_FILENAME} runtime. The runtime config was NOT checked. Re-run the doctor naming the runtime \u2014 one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`,
+      detail: `Runtime is unknown \u2014 no runtime flag was given and the connector's record in ${primaryDirectory ?? namedDir ?? "~/.haven/agents"} carries no resolvable ${CONNECT_OUTCOME_FILENAME} runtime. The runtime config was NOT checked. Re-run the doctor naming the runtime \u2014 one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`,
       repair: `Re-run the doctor naming the runtime \u2014 one of: ${RUNTIME_FLAG_VALUE_LIST.join(", ")}.`
     });
   } else if (configPath === null) {
+    const claudePairSuffix = input2.runtime === "claude-code" && primaryDirectory ? await (async () => {
+      const sidecar = await readRuntimeSidecar(primaryDirectory);
+      const names = serverNamesFor(sidecar?.server_name);
+      return ` The MCP pair recorded for this folder is ${names.hosted} / ${names.signer} \u2014 confirm with \`claude mcp get ${names.signer}\`.`;
+    })() : "";
     checks.push({
       id: "runtime_config",
       label: "Runtime MCP config",
       level: "ok",
-      detail: `Runtime '${input2.runtime}' is configured through its own CLI or by hand (${input2.runtime === "other" ? "manual runtime" : "CLI-managed"}) and has no file-based config the connector owns \u2014 skipping the file check.`
+      detail: `Runtime '${input2.runtime}' is configured through its own CLI or by hand (${input2.runtime === "other" ? "manual runtime" : "CLI-managed"}) and has no file-based config the connector owns \u2014 skipping the file check.${claudePairSuffix}`
     });
   } else if (configText === null) {
     checks.push({
@@ -5491,13 +5830,17 @@ async function runDoctor(input, deps = {}) {
     const supersededLevel = supersededLive.length === 0 ? "ok" : classificationUnreliable ? "advisory" : "failed";
     checks.push({
       id: "superseded_agents",
-      label: "Superseded agent credentials",
+      // #3830: an advisory means the connector could not tell wired from
+      // superseded, so its label must not assert "superseded" either. The
+      // inventory `classification` stays as is (#3121 decision 5); the label
+      // is what a person reads.
+      label: supersededLevel === "advisory" ? "Other agent credentials (wiring not verifiable)" : "Superseded agent credentials",
       level: supersededLevel,
-      detail: supersededLevel === "failed" ? `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}. A host started before your latest setup keeps authenticating (and spending) as the old agent.` : supersededLevel === "advisory" ? `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}. Runtime '${input2.runtime}' has no config file the connector can read, so which of these agents are wired cannot be verified from this machine: a live key here may be an agent you use deliberately, or one a host started before your latest setup is still spending as.` : `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}.`,
+      detail: supersededLevel === "failed" ? `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}. A host started before your latest setup keeps authenticating (and spending) as the old agent.` : supersededLevel === "advisory" ? `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}. Runtime '${input2.runtime}' has no config file the connector writes, and none it can read names these agents, so which of them are wired cannot be verified from this machine: a live key here may be an agent you use deliberately, or one a host started before your latest setup is still spending as.` : `${otherEntries.length} other credential dir(s) found \u2014 ${parts.join("; ")}.`,
       ...supersededLevel === "failed" ? {
-        repair: `Revoke ${supersededLive.join(", ")} on the Haven agent page, then remove the old director(y/ies) under ~/.haven/agents. Connect never revokes or deletes for you.`
+        repair: `Use Remove agent\u2026 on the Haven agent page for ${supersededLive.join(", ")} (it ends each one\u2019s live budgets), then remove the old director(y/ies) under ~/.haven/agents. Connect never revokes or deletes for you.`
       } : supersededLevel === "advisory" ? {
-        repair: `Check ${supersededLive.join(", ")} on the Haven agent page: revoke the ones you no longer use, then remove their director(y/ies) under ~/.haven/agents. Connect never revokes or deletes for you.`
+        repair: `Check ${supersededLive.join(", ")} on the Haven agent page: use Remove agent\u2026 on the ones you no longer use, then remove their director(y/ies) under ~/.haven/agents. Connect never revokes or deletes for you.`
       } : {}
     });
   }
@@ -5522,7 +5865,7 @@ async function runDoctor(input, deps = {}) {
       label: "MCP server names bound more than once",
       level: "advisory",
       detail: `${rebound.length} MCP server name${rebound.length === 1 ? "" : "s"} changed hands on this machine (locally recorded bindings; the backend's own record is the authority for the same backend): ${parts.join("; ")}. A saved session, script or document naming the server may still mean the earlier agent.`,
-      repair: `Retire the earlier director(y/ies) with ${RERUN} --unwire <dir> to release the name, or keep both and address them by --name.`
+      repair: `Retire the earlier director(y/ies) with ${RERUN} --unwire <dir> to release the name, or keep both and address them by --name \u2014 --doctor --repair --name <slug> now selects the pair directly.`
     });
   }
   const parkedElsewhere = inventory.filter((entry) => entry.directory !== primaryDirectory && entry.rekeyPending).map((entry) => ({ entry, pending: entry.rekeyPending }));
@@ -5582,20 +5925,24 @@ async function runDoctor(input, deps = {}) {
 async function runRepair(input, deps = {}) {
   const homeDir = deps.homeDir ?? os.homedir();
   const messages = [];
-  const { directory, others, identityDirectories } = await discoverCredentialDirectory(homeDir, input.credentialsDir);
-  if (!input.credentialsDir && identityDirectories.length > 1) {
+  const namedDir = await resolveNamedDirectory(input, homeDir);
+  const { directory, others, identityDirectories } = await discoverCredentialDirectory(homeDir, namedDir);
+  if (!namedDir && identityDirectories.length > 1) {
     const lines = await Promise.all(
       identityDirectories.map(async (dir) => {
         const identity2 = await readIdentity(dir);
         const who = identity2?.agent_id ? `agent ${identity2.agent_id}` : "agent (no agent_id recorded)";
         const retired = !identity2?.api_key || await pathExists3(path.join(dir, TOMBSTONE_FILENAME));
-        return retired ? `  \u2022 ${who} (${dir}): retired \u2014 not a repair target` : `  \u2022 ${who}: ${repairCommandFor(input.runtime, "", dir).replace(/^Run: /, "")}`;
+        const sidecar = await readRuntimeSidecar(dir);
+        const slug = sidecar?.server_name;
+        const pair = slug ? `${serverNamesFor(slug).hosted} / ${serverNamesFor(slug).signer}` : "the bare haven / haven-signer pair";
+        return retired ? `  \u2022 ${who} \u2014 ${pair} (${dir}): retired \u2014 not a repair target` : slug ? `  \u2022 ${who} \u2014 owns ${pair}: ${repairCommandNamedFor(input.runtime, slug).replace(/^Run: /, "")}` : `  \u2022 ${who} \u2014 owns ${pair}: ${repairCommandFor(input.runtime, "", dir).replace(/^Run: /, "")}`;
       })
     );
     return {
       ok: false,
       messages: [
-        `${identityDirectories.length} agent credential directories exist on this machine, and a repair rewrites the runtime config from ONE of them. Name the agent to repair with --credentials-dir \u2014 nothing was changed:`,
+        `${identityDirectories.length} agent credential directories exist on this machine, and a repair rewrites the runtime config from ONE of them. Name the agent to repair with --name <slug> (its recorded pair) or --credentials-dir \u2014 nothing was changed:`,
         ...lines,
         "Not sure which agent is which? Compare the agent ids against the Haven agent page, or run --doctor first."
       ]
@@ -5653,13 +6000,62 @@ async function runRepair(input, deps = {}) {
   const existingSidecar = await readRuntimeSidecar(directory);
   const serverName = existingSidecar?.server_name;
   const signerPath = path.join(directory, "signer.json");
+  const consent = await getLocalSignerConsentStatus(signerPath);
+  const consentMismatch = !consent.acknowledged && (consent.reason === "ack_file_missing" || consent.reason === "ack_file_mismatch");
+  if (consentMismatch && !input.ackLocalTools) {
+    const wrapperPath = existingSidecar?.wrapper_path ?? path.join(directory, "bin", "haven-signer.mjs");
+    return {
+      ok: false,
+      messages: [
+        "Repair stopped before writing anything: the signer it installs would refuse to start until local-tools consent is re-acknowledged \u2014 the stored acknowledgement does not match the tool set of the signer this connector pins.",
+        "The mismatch does not prove the currently running signer is broken; a newer tool set is enough to explain it.",
+        `Re-consent without a setup token, produced by the installed signer: ${wrapperPath} --ack < /dev/null`,
+        `Or re-run repair with --ack-local-tools to re-consent during the repair: ${repairCommandFor(input2.runtime, " --ack-local-tools", directory)}`
+      ]
+    };
+  }
   const prepared = await prepareSignerRuntime(
     { credentialDirectory: directory, signerPath, homeDir, serverName },
     { runCommand: deps.runCommand, env: deps.env }
   );
   messages.push(...prepared.messages);
   const names = serverNamesFor(serverName);
-  messages.push(`Rewriting MCP entries ${names.hosted} / ${names.signer}${serverName ? ` (agent "${serverName}")` : " (unnamed pair)"} \u2014 no other pair is touched.`);
+  const rewritesConfig = runtimeConfigPathFor(normalizeRuntimeName(input2.runtime) ?? input2.runtime, homeDir) !== null;
+  if (rewritesConfig) {
+    messages.push(`Rewriting MCP entries ${names.hosted} / ${names.signer}${serverName ? ` (agent "${serverName}")` : " (unnamed pair)"} \u2014 no other pair is touched.`);
+  } else {
+    messages.push(
+      `Re-pointed ${prepared.wrapperPath} at signer ${signerPackageSpec()}. ` + (input2.runtime === "claude-code" ? `Claude Code's MCP entries were not touched \u2014 the entry that launches this wrapper uses the new signer after a restart. Confirm with \`claude mcp get ${names.signer}\`.` : `No MCP config was written \u2014 '${input2.runtime}' is configured through its own CLI or by hand; the entry that launches this wrapper uses the new signer after a restart.`)
+    );
+  }
+  if (consentMismatch && input.ackLocalTools) {
+    messages.push(`Re-acknowledging local-tools consent with the installed signer (${signerPackageSpec()}):`);
+    try {
+      const ack = await (deps.runSignerAck ?? runWrapperAck)(prepared.wrapperPath);
+      for (const line of ack.stdout.split("\n")) {
+        if (line.trim()) messages.push(`  ${line}`);
+      }
+    } catch (err) {
+      return {
+        ok: false,
+        messages: [
+          ...messages,
+          `The re-acknowledgement failed: ${err instanceof Error ? err.message : String(err)} \u2014 consent was NOT written; the runtime config was not rewritten.`
+        ]
+      };
+    }
+    const after = await getLocalSignerConsentStatus(signerPath);
+    if (!after.acknowledged) {
+      return {
+        ok: false,
+        messages: [
+          ...messages,
+          `Consent still does not match after the re-acknowledgement (${after.reason ?? after.error}). The runtime config was not rewritten.`
+        ]
+      };
+    }
+    messages.push("Local-tools consent acknowledged for the installed signer.");
+  }
   const configResult = await writeRuntimeConfig({
     // Normalized for the WRITE too (#3145 review round 3): `writeRuntimeConfig`
     // switches on the id, and the raw alias fell to its "manual runtime" arm
@@ -5722,6 +6118,7 @@ function parseArgs(argv, env = process.env) {
   let dryRun = false;
   let unwireDir;
   let replace = false;
+  let bare = false;
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
     if (arg === "--help" || arg === "-h") {
@@ -5769,6 +6166,8 @@ function parseArgs(argv, env = process.env) {
       options.credentialsDir = requireValue(argv, ++i, arg);
     } else if (arg === "--replace") {
       replace = true;
+    } else if (arg === "--bare") {
+      bare = true;
     } else if (arg === "--name") {
       options.serverName = requireValue(argv, ++i, arg);
       assertValidServerSlug(options.serverName);
@@ -5794,16 +6193,23 @@ function parseArgs(argv, env = process.env) {
   if (help) {
     return { options, help, json, doctor, repair, tombstone, rekey };
   }
-  if (replace) {
+  if (replace || bare) {
     if (rekeyPhase || tombstoneDir || unwire || doctor || repair || pruneSignerRuntimes2) {
-      throw new Error("--replace belongs to a --setup run: it says what to do when the bare haven / haven-signer pair is already wired to another agent.");
+      throw new Error(`${replace ? "--replace" : "--bare"} belongs to a --setup run: it says what to do when the bare haven / haven-signer pair is already wired to another agent.`);
     }
-    if (options.serverName) {
+    if (bare && options.serverName) {
       throw new Error(
-        "--replace and --name contradict each other: --replace overwrites the bare haven / haven-signer wiring, --name installs alongside it under its own pair. Pass one of them."
+        "--bare and --name contradict each other: --bare wires the bare haven / haven-signer pair, --name installs a named haven-<slug> pair. Pass one of them."
       );
     }
-    options.replaceExistingWiring = true;
+    if (replace) {
+      if (options.serverName) {
+        throw new Error(
+          "--replace and --name contradict each other: --replace overwrites the bare haven / haven-signer wiring, --name installs alongside it under its own pair. Pass one of them."
+        );
+      }
+      options.replaceExistingWiring = true;
+    }
   }
   if (destroyKeyMaterial && !unwire) {
     throw new Error("--destroy-key-material only applies to --unwire.");
@@ -5869,6 +6275,11 @@ function parseArgs(argv, env = process.env) {
         "--repair needs --runtime <runtime>: it rewrites that runtime's config, so the runtime is named explicitly rather than inherited from the setup record. --doctor alone resolves it from the record."
       );
     }
+    if (options.ackLocalTools && !repair) {
+      throw new Error(
+        "--ack-local-tools does nothing with --doctor alone: the doctor is read-only. Re-consent during a repair (--repair --ack-local-tools), or token-free with the recorded wrapper: <agent dir>/bin/haven-signer.mjs --ack"
+      );
+    }
     return { options, help, json, doctor, repair, tombstone, rekey };
   }
   if (!options.setupToken) {
@@ -5877,6 +6288,9 @@ function parseArgs(argv, env = process.env) {
   if (!options.apiBaseUrl) {
     throw new Error("Missing --api <Haven API URL>.");
   }
+  if (!options.serverName && !bare && !replace) {
+    options.deriveServerName = true;
+  }
   options.apiBaseUrl = options.apiBaseUrl.replace(/\/+$/, "");
   return { options, help, json, doctor, repair, tombstone, rekey };
 }
@@ -5904,14 +6318,22 @@ function helpText() {
     "  --replace                  When this machine is already wired to a different Haven agent on the bare",
     "                             haven / haven-signer pair, re-point that pair at the new agent and retire the",
     "                             previous agent directory locally (tombstoned, local key files removed).",
-    "                             Nothing is revoked \u2014 revoke the old agent on the Haven agent page. Without",
-    "                             this flag a non-interactive run REFUSES such a collision (wiring_collision)",
-    "                             and an interactive terminal is asked; --name installs alongside instead.",
+    "                             Nothing is revoked \u2014 use Remove agent\u2026 on the Haven agent page. Implies",
+    "                             the bare pair. Without it (or --bare) a non-interactive run REFUSES such a",
+    "                             collision (wiring_collision) and an interactive terminal is asked.",
+    "  --bare                     Wire the bare haven / haven-signer pair. Without --name a setup now names",
+    "                             its pair from the agent's display name (haven-<slug> /",
+    "                             haven-signer-<slug>, de-collided against this machine, ending -dev on a",
+    "                             non-production backend), so adding an agent never has to displace anyone;",
+    "                             --bare is the explicit opt-in to the unnamed pair. --name overrides it.",
     "  --name <slug>              Wiring slug for a NAMED agent: writes haven-<slug> / haven-signer-<slug>",
     "                             MCP entries and stores credentials at ~/.haven/agents/<slug>/, so several",
     "                             agents can run side by side in one runtime. 1-32 lowercase letters, digits,",
-    "                             single hyphens; immutable once wired. Omit for the bare haven / haven-signer pair.",
-    "  --ack-local-tools          Write the one-time local Haven tools acknowledgement during setup.",
+    "                             single hyphens; immutable once wired. Without it the pair is named from the",
+    "                             agent's display name; --bare wires the bare haven / haven-signer pair.",
+    "  --ack-local-tools          Write the local Haven tools acknowledgement: during setup, or (with --repair)",
+    "                             re-acknowledge consent for the signer the repair installs \u2014 no setup token.",
+    "                             With a bare --doctor it is refused: --doctor is read-only.",
     "  --ack-signer               Backward-compatible alias for --ack-local-tools.",
     "  --local                    Advanced: install the fully-local Haven MCP (no hosted dependency).",
     "                             Only available for Claude Code and Codex. Default is hosted MCP + local signer.",
@@ -5920,10 +6342,13 @@ function helpText() {
     "                             signer runtime, hosted MCP, and a live signer handshake. Exits non-zero only on a failed check; an advisory (!) exits 0.",
     "                             --runtime is optional: without it the doctor checks the runtime the setup recorded,",
     "                             and reports a failure (not a pass) when no record names one.",
+    "                             --name <slug> selects the agent directory by its recorded MCP pair.",
     "  --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.",
     "                             Requires --runtime <runtime>: it rewrites that config, so the runtime is never inherited.",
+    "                             --name <slug> selects the agent to repair by its recorded pair; --ack-local-tools",
+    "                             re-consents the installed signer (the old token-free path: <agent dir>/bin/haven-signer.mjs --ack).",
     "  --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.",
@@ -6056,7 +6481,7 @@ async function runCli(argv, io = {
         io.stdout(redactSecrets(`Tombstoned agent ${info.agent_id} at ${parsed.tombstone.directory}.
 `));
         io.stdout(
-          "Key files were NOT touched and nothing was revoked \u2014 revoke the agent on the Haven agent page if you have not already.\n"
+          "Key files were NOT touched and nothing was revoked \u2014 on the Haven agent page, use Remove agent\u2026 (or Stop budget) if you have not already.\n"
         );
         io.stdout(
           info.recordPath !== null ? `A surviving tombstone record was mirrored to ${redactSecrets(info.recordPath)}
@@ -6084,11 +6509,12 @@ async function runCli(argv, io = {
   if (parsed.unwire) {
     const { unwireAgent: unwireAgent2 } = await Promise.resolve().then(() => (init_unwire(), unwire_exports));
     const { tombstonesDirForAgentDirectory: tombstonesDirForAgentDirectory2 } = await Promise.resolve().then(() => (init_tombstone(), tombstone_exports));
+    const { resolveAgentDirectoryBySlug: resolveAgentDirectoryBySlug2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
     const { homedir: homedir11 } = await import('os');
     const { join: join13 } = await import('path');
     const homeDir = homedir11();
     const root = parsed.options.credentialsDir ?? join13(homeDir, ".haven", "agents");
-    const directory = parsed.unwireDir ?? (parsed.options.serverName ? join13(root, parsed.options.serverName) : root);
+    const directory = parsed.unwireDir ?? (parsed.options.serverName ? await resolveAgentDirectoryBySlug2(parsed.options.serverName, { root, allowRetired: true }) : root);
     const ledgerDir = tombstonesDirForAgentDirectory2(directory, homeDir);
     try {
       const result = await unwireAgent2({
@@ -6165,7 +6591,7 @@ async function runCli(argv, io = {
           failures.length > 0 ? "  Some entries were NOT removed (\u2717 above). Re-run `--unwire` after resolving each refusal \u2014\n  it is idempotent.\n" : retained ? "  The wiring is gone; the key material is not (\u2717 above). `--doctor` will keep reporting this directory\n  as `superseded` until the key is revoked or destroyed \u2014 that is the honest state.\n" : "  Verify: `--doctor --runtime <runtime>` per host should report this agent as `retired` with a\n  clean runtime-config check.\n"
         );
         io.stdout(
-          "Restart EVERY long-lived MCP host (gateway, TUI workers, editors): each holds the wiring snapshot\nfrom its own start time. " + (retained ? "This directory\u2019s local key material was KEPT (see above); the tombstone\n" : "This directory\u2019s local key material was removed and the tombstone\n") + "record + #2155 mirror survive \u2014 but nothing was REVOKED on the backend. If you have not\nalready, revoke the agent on the Haven agent page to stop it spending entirely.\n"
+          "Restart EVERY long-lived MCP host (gateway, TUI workers, editors): each holds the wiring snapshot\nfrom its own start time. " + (retained ? "This directory\u2019s local key material was KEPT (see above); the tombstone\n" : "This directory\u2019s local key material was removed and the tombstone\n") + "record + #2155 mirror survive \u2014 but nothing was REVOKED on the backend. If you have not\nalready, use Remove agent\u2026 on the Haven agent page to end its budgets on-chain and stop it spending.\n"
         );
       }
       return failures.length > 0 || retained ? 1 : 0;
@@ -6290,14 +6716,16 @@ async function runCli(argv, io = {
     const { runDoctor: runDoctor2, runRepair: runRepair2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
     const runtime = parsed.options.runtime ?? "";
     const credentialsDir = parsed.options.credentialsDir;
+    const serverName = parsed.options.serverName;
+    const ackLocalTools = parsed.options.ackLocalTools === true;
     try {
       if (parsed.repair) {
-        const repair = await runRepair2({ runtime, credentialsDir });
+        const repair = await runRepair2({ runtime, credentialsDir, serverName, ackLocalTools });
         for (const message of repair.messages) io.stderr(`${redactSecrets(message)}
 `);
         if (!repair.ok) return 1;
       }
-      const report = await runDoctor2({ runtime, credentialsDir });
+      const report = await runDoctor2({ runtime, credentialsDir, serverName });
       if (parsed.json) {
         io.stdout(`${redactSecrets(JSON.stringify(report))}
 `);
@@ -6309,13 +6737,16 @@ async function runCli(argv, io = {
 `));
         }
         const otherAgents = report.agents.filter((agent) => agent.directory !== report.credentialDirectory);
+        const wiringUnverifiable = report.checks.some(
+          (check) => check.id === "superseded_agents" && check.level === "advisory"
+        );
         if (otherAgents.length > 0) {
           io.stdout("\nOther agents on this machine:\n");
           for (const agent of otherAgents) {
             const name = agent.slug ? `${agent.slug} (${agent.agentId ?? "unknown"})` : agent.agentId ?? "unknown";
             const failed = agent.checks.filter((check) => check.level === "failed");
             const advised = agent.checks.filter((check) => check.level === "advisory");
-            const verdict = agent.classification === "wired" ? failed.length > 0 ? `wired, ${failed.length} check(s) FAILED` : advised.length > 0 ? `wired, ${advised.length} advisory finding(s)` : "wired, all checks passed" : agent.classification === "parked" ? "parked re-key only \u2014 no identity.json in this directory, but key material is still there" : agent.classification;
+            const verdict = agent.classification === "wired" ? failed.length > 0 ? `wired, ${failed.length} check(s) FAILED` : advised.length > 0 ? `wired, ${advised.length} advisory finding(s)` : "wired, all checks passed" : agent.classification === "parked" ? "parked re-key only \u2014 no identity.json in this directory, but key material is still there" : agent.classification === "superseded" && wiringUnverifiable ? "not verified as wired \u2014 no config the connector can read names it" : agent.classification;
             io.stdout(redactSecrets(`  ${failed.length > 0 ? "\u2717" : advised.length > 0 ? "!" : "\u2022"} ${name}: ${verdict}
 `));
             for (const check of [...failed, ...advised]) {