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

package/dist/index.cjs

@@ -2,15 +2,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');
@@ -71,6 +71,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",
@@ -165,81 +184,574 @@ var init_key = __esm({
   }
 });
 
-// src/redact.ts
-function redactSecrets(value) {
-  return value.replace(API_KEY_RE, "sk_agent_[redacted]").replace(PRIVATE_KEY_RE, "0x[redacted-private-key]");
+// src/redact.ts
+function redactSecrets(value) {
+  return value.replace(API_KEY_RE, "sk_agent_[redacted]").replace(PRIVATE_KEY_RE, "0x[redacted-private-key]");
+}
+function redactForAutomation(value) {
+  return redactSecrets(value).replace(/(?:~|\/)[^\s`"']*\/(?:identity|signer|agent)\.json\b/g, "[credential-file-redacted]").replace(/(?:~|\/)[^\s`"']*\/\.env\b/g, "[credential-env-redacted]");
+}
+function withoutUserinfo(url) {
+  try {
+    const parsed = new URL(url);
+    parsed.username = "";
+    parsed.password = "";
+    return parsed.toString().replace(/\/+$/, "");
+  } catch {
+    return url;
+  }
+}
+function shortAddress(address) {
+  if (!/^0x[0-9a-fA-F]{40}$/.test(address)) return address;
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+var API_KEY_RE, PRIVATE_KEY_RE;
+var init_redact = __esm({
+  "src/redact.ts"() {
+    API_KEY_RE = /sk_agent_[A-Za-z0-9]+/g;
+    PRIVATE_KEY_RE = /0x[0-9a-fA-F]{64}/g;
+  }
+});
+
+// src/server-names.ts
+function assertValidServerSlug(slug) {
+  if (slug.length === 0 || slug.length > 32 || !SLUG_RE.test(slug)) {
+    throw new Error(
+      `Invalid server name ${JSON.stringify(slug)}: use 1-32 lowercase letters, digits, and single hyphens (e.g. "research").`
+    );
+  }
+  if (slug === "haven" || slug === "haven-signer") {
+    throw new Error(
+      `Invalid server name ${JSON.stringify(slug)}: "haven" and "haven-signer" are the unnamed pair's own names \u2014 omit --name for the bare pair.`
+    );
+  }
+  if (slug === "signer" || slug.startsWith("signer-")) {
+    throw new Error(
+      `Invalid server name ${JSON.stringify(slug)}: "signer" and "signer-*" are reserved \u2014 they would collide with another pair's haven-signer-* entry.`
+    );
+  }
+}
+function serverNamesFor(slug) {
+  if (slug === void 0) {
+    return {
+      hosted: "haven",
+      signer: "haven-signer",
+      // Historical Codex table names — every wired Codex host has these.
+      codexHosted: "haven",
+      codexSigner: "haven_signer",
+      hermesEnvKey: "MCP_HAVEN_API_KEY"
+    };
+  }
+  assertValidServerSlug(slug);
+  return {
+    hosted: `haven-${slug}`,
+    signer: `haven-signer-${slug}`,
+    // Hyphens are valid TOML bare keys, so named Codex tables match the
+    // JSON/YAML names instead of inheriting the legacy underscore.
+    codexHosted: `haven-${slug}`,
+    codexSigner: `haven-signer-${slug}`,
+    hermesEnvKey: `MCP_HAVEN_${slug.toUpperCase().replace(/-/g, "_")}_API_KEY`
+  };
+}
+var SLUG_RE;
+var init_server_names = __esm({
+  "src/server-names.ts"() {
+    SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+  }
+});
+function mcpPackageSpec() {
+  return `${exports.MCP_RUNTIME_MANIFEST.mcpPackage}@${exports.MCP_RUNTIME_MANIFEST.mcpVersion}`;
+}
+function sdkPackageSpec() {
+  return `${exports.MCP_RUNTIME_MANIFEST.sdkPackage}@${exports.MCP_RUNTIME_MANIFEST.sdkVersion}`;
+}
+function signerPackageSpec() {
+  return `${exports.MCP_RUNTIME_MANIFEST.signerPackage}@${exports.MCP_RUNTIME_MANIFEST.signerVersion}`;
+}
+exports.MCP_RUNTIME_MANIFEST = void 0;
+var init_runtime_manifest = __esm({
+  "src/runtime-manifest.ts"() {
+    exports.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)
+    };
+  }
+});
+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 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");
+  }
+  if (/\s/.test(raw)) {
+    throw new RuntimeSpecOverrideError(variable, "it contains whitespace");
+  }
+  if (/[\u0000-\u001f\u007f]/.test(raw)) {
+    throw new RuntimeSpecOverrideError(variable, "it contains a control character");
+  }
+  const meta = SHELL_METACHARACTERS.exec(raw);
+  if (meta) {
+    throw new RuntimeSpecOverrideError(variable, `it contains the shell metacharacter ${JSON.stringify(meta[0])}`);
+  }
+  return raw;
+}
+function runtimeSpecOverrideDirectoryKey(resolvedSpecs) {
+  const digest = crypto.createHash("sha256").update(resolvedSpecs.join("\n")).digest("hex");
+  return `override-${digest.slice(0, 12)}`;
+}
+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})` : ""}`);
+  }
+  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 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;
+      }
+    };
+  }
+});
+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 : exports.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
+    ));
+  }
+  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 {
+    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 } : {} };
+}
+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 {
+    await run(baseArgs);
+  } 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)}`
+      );
+    }
+  }
+}
+async function installedRuntimeMatches(runtimeDirectory, cliPath) {
+  return installedRuntimeMatchesVersions(runtimeDirectory, cliPath, {
+    signerVersion: exports.MCP_RUNTIME_MANIFEST.signerVersion,
+    sdkVersion: exports.MCP_RUNTIME_MANIFEST.sdkVersion
+  });
+}
+async function installedRuntimeMatchesVersions(runtimeDirectory, cliPath, expected) {
+  try {
+    await assertFileExists(cliPath, "local Haven signer CLI");
+    const installed = await readInstalledVersions(runtimeDirectory);
+    return installed.signerVersion === expected.signerVersion && installed.sdkVersion === expected.sdkVersion;
+  } catch {
+    return false;
+  }
+}
+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 readRuntimeSidecar(credentialDirectory) {
+  try {
+    return JSON.parse(
+      await promises.readFile(path.join(credentialDirectory, "signer-runtime.json"), "utf8")
+    );
+  } catch {
+    return null;
+  }
+}
+async function writeRuntimeSidecar(input) {
+  const value = {
+    ...input.serverName ? { server_name: input.serverName } : {},
+    signer_package: exports.MCP_RUNTIME_MANIFEST.signerPackage,
+    signer_version: input.installedVersions?.signerVersion ?? exports.MCP_RUNTIME_MANIFEST.signerVersion,
+    sdk_package: exports.MCP_RUNTIME_MANIFEST.sdkPackage,
+    sdk_version: input.installedVersions?.sdkVersion ?? exports.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 assertFileExists(path, label) {
+  try {
+    await promises.access(path);
+  } catch {
+    throw new Error(`Missing ${label}: ${path}`);
+  }
+}
+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 exports.ConnectError;
+}
+exports.ConnectError = void 0;
+var init_connect_error = __esm({
+  "src/connect-error.ts"() {
+    exports.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");
 }
-function redactForAutomation(value) {
-  return redactSecrets(value).replace(/(?:~|\/)[^\s`"']*\/(?:identity|signer|agent)\.json\b/g, "[credential-file-redacted]").replace(/(?:~|\/)[^\s`"']*\/\.env\b/g, "[credential-env-redacted]");
+function 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 withoutUserinfo(url) {
+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 {
-    const parsed = new URL(url);
-    parsed.username = "";
-    parsed.password = "";
-    return parsed.toString().replace(/\/+$/, "");
+    entries = await promises.readdir(root);
   } catch {
-    return url;
+    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 shortAddress(address) {
-  if (!/^0x[0-9a-fA-F]{40}$/.test(address)) return address;
-  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+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");
 }
-var API_KEY_RE, PRIVATE_KEY_RE;
-var init_redact = __esm({
-  "src/redact.ts"() {
-    API_KEY_RE = /sk_agent_[A-Za-z0-9]+/g;
-    PRIVATE_KEY_RE = /0x[0-9a-fA-F]{64}/g;
-  }
-});
-
-// src/server-names.ts
-function assertValidServerSlug(slug) {
-  if (slug.length === 0 || slug.length > 32 || !SLUG_RE.test(slug)) {
-    throw new Error(
-      `Invalid server name ${JSON.stringify(slug)}: use 1-32 lowercase letters, digits, and single hyphens (e.g. "research").`
-    );
-  }
-  if (slug === "haven" || slug === "haven-signer") {
-    throw new Error(
-      `Invalid server name ${JSON.stringify(slug)}: "haven" and "haven-signer" are the unnamed pair's own names \u2014 omit --name for the bare pair.`
+async function writeAgentTombstone(input) {
+  const dirStat = await promises.stat(input.directory).catch(() => null);
+  if (!dirStat?.isDirectory()) {
+    throw new exports.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"
     );
   }
-  if (slug === "signer" || slug.startsWith("signer-")) {
-    throw new Error(
-      `Invalid server name ${JSON.stringify(slug)}: "signer" and "signer-*" are reserved \u2014 they would collide with another pair's haven-signer-* entry.`
-    );
+  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 serverNamesFor(slug) {
-  if (slug === void 0) {
-    return {
-      hosted: "haven",
-      signer: "haven-signer",
-      // Historical Codex table names — every wired Codex host has these.
-      codexHosted: "haven",
-      codexSigner: "haven_signer",
-      hermesEnvKey: "MCP_HAVEN_API_KEY"
-    };
+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;
   }
-  assertValidServerSlug(slug);
-  return {
-    hosted: `haven-${slug}`,
-    signer: `haven-signer-${slug}`,
-    // Hyphens are valid TOML bare keys, so named Codex tables match the
-    // JSON/YAML names instead of inheriting the legacy underscore.
-    codexHosted: `haven-${slug}`,
-    codexSigner: `haven-signer-${slug}`,
-    hermesEnvKey: `MCP_HAVEN_${slug.toUpperCase().replace(/-/g, "_")}_API_KEY`
-  };
 }
-var SLUG_RE;
-var init_server_names = __esm({
-  "src/server-names.ts"() {
-    SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+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";
   }
 });
+
+// src/storage.ts
+var storage_exports = {};
+__export(storage_exports, {
+  CONNECT_OUTCOME_FILENAME: () => exports.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 });
@@ -316,8 +828,7 @@ function agentPayload(input) {
   };
 }
 async function readStoredCredentials(serverName, agentIdOrSlug, baseDir) {
-  const key = serverName ?? agentIdOrSlug;
-  const directory = key ? defaultAgentDirectory(key, baseDir) : await discoverSoleAgentDirectory(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(
@@ -325,7 +836,7 @@ async function readStoredCredentials(serverName, agentIdOrSlug, baseDir) {
     );
   }
   let discoveredSlug;
-  if (!key) {
+  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-")) {
@@ -396,6 +907,65 @@ async function discoverSoleAgentDirectory(baseDir) {
 ` + candidates.map((d) => `  ${d}`).join("\n") + "\nRe-run with --name <slug> to pick one."
   );
 }
+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 });
+    }
+    if (!claimedSlug && !retired && entry === slug) legacyFolder = directory;
+  }
+  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>."
+  );
+}
 async function rewriteCredentialFiles(input) {
   const directory = defaultAgentDirectory(input.serverName ?? input.agentId, input.baseDir);
   const identityPath = path.join(directory, "identity.json");
@@ -605,6 +1175,7 @@ async function listMcpServerBindings(baseDir, excludeDirectory) {
   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 });
   }
@@ -614,48 +1185,12 @@ var REKEY_PENDING_FILENAME, REKEY_PENDING_TTL_MS; exports.CONNECT_OUTCOME_FILENA
 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;
     exports.CONNECT_OUTCOME_FILENAME = "last-connect-outcome.json";
-    MCP_SERVER_BINDING_FILENAME = "mcp-server-binding.json";
-  }
-});
-function mcpPackageSpec() {
-  return `${exports.MCP_RUNTIME_MANIFEST.mcpPackage}@${exports.MCP_RUNTIME_MANIFEST.mcpVersion}`;
-}
-function sdkPackageSpec() {
-  return `${exports.MCP_RUNTIME_MANIFEST.sdkPackage}@${exports.MCP_RUNTIME_MANIFEST.sdkVersion}`;
-}
-function signerPackageSpec() {
-  return `${exports.MCP_RUNTIME_MANIFEST.signerPackage}@${exports.MCP_RUNTIME_MANIFEST.signerVersion}`;
-}
-exports.MCP_RUNTIME_MANIFEST = void 0;
-var init_runtime_manifest = __esm({
-  "src/runtime-manifest.ts"() {
-    exports.MCP_RUNTIME_MANIFEST = {
-      mcpPackage: "@haven_ai/mcp",
-      mcpVersion: mcp.MCP_VERSION,
-      sdkPackage: "@haven_ai/sdk",
-      sdkVersion: "0.9.0-alpha.0",
-      signerPackage: "@haven_ai/signer",
-      signerVersion: "0.9.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)
-    };
+    MCP_SERVER_BINDING_FILENAME = "mcp-server-binding.json";
   }
 });
 async function writeRuntimeConfig(input, deps = {}) {
@@ -1692,295 +2227,23 @@ function parseJsonRpcPayload(raw) {
   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 {
-    return await fetchImpl(url, { ...init, signal: controller.signal });
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-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);
-  }
-  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");
-  }
-  if (/\s/.test(raw)) {
-    throw new RuntimeSpecOverrideError(variable, "it contains whitespace");
-  }
-  if (/[\u0000-\u001f\u007f]/.test(raw)) {
-    throw new RuntimeSpecOverrideError(variable, "it contains a control character");
-  }
-  const meta = SHELL_METACHARACTERS.exec(raw);
-  if (meta) {
-    throw new RuntimeSpecOverrideError(variable, `it contains the shell metacharacter ${JSON.stringify(meta[0])}`);
-  }
-  return raw;
-}
-function runtimeSpecOverrideDirectoryKey(resolvedSpecs) {
-  const digest = crypto.createHash("sha256").update(resolvedSpecs.join("\n")).digest("hex");
-  return `override-${digest.slice(0, 12)}`;
-}
-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})` : ""}`);
-  }
-  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 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;
-      }
-    };
-  }
-});
-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 : exports.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
-    ));
-  }
-  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 {
-    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 } : {} };
-}
-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 {
-    await run(baseArgs);
-  } 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)}`
-      );
-    }
-  }
-}
-async function installedRuntimeMatches(runtimeDirectory, cliPath) {
-  return installedRuntimeMatchesVersions(runtimeDirectory, cliPath, {
-    signerVersion: exports.MCP_RUNTIME_MANIFEST.signerVersion,
-    sdkVersion: exports.MCP_RUNTIME_MANIFEST.sdkVersion
-  });
-}
-async function installedRuntimeMatchesVersions(runtimeDirectory, cliPath, expected) {
-  try {
-    await assertFileExists(cliPath, "local Haven signer CLI");
-    const installed = await readInstalledVersions(runtimeDirectory);
-    return installed.signerVersion === expected.signerVersion && installed.sdkVersion === expected.sdkVersion;
-  } catch {
-    return false;
-  }
-}
-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 readRuntimeSidecar(credentialDirectory) {
-  try {
-    return JSON.parse(
-      await promises.readFile(path.join(credentialDirectory, "signer-runtime.json"), "utf8")
-    );
-  } catch {
-    return null;
+      return JSON.parse(dataLines[i]);
+    } catch {
+    }
   }
+  return null;
 }
-async function writeRuntimeSidecar(input) {
-  const value = {
-    ...input.serverName ? { server_name: input.serverName } : {},
-    signer_package: exports.MCP_RUNTIME_MANIFEST.signerPackage,
-    signer_version: input.installedVersions?.signerVersion ?? exports.MCP_RUNTIME_MANIFEST.signerVersion,
-    sdk_package: exports.MCP_RUNTIME_MANIFEST.sdkPackage,
-    sdk_version: input.installedVersions?.sdkVersion ?? exports.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 assertFileExists(path, label) {
+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 = {}) {
@@ -2298,28 +2561,6 @@ var init_skill_install = __esm({
   }
 });
 
-// src/connect-error.ts
-function isConnectError(err) {
-  return err instanceof exports.ConnectError;
-}
-exports.ConnectError = void 0;
-var init_connect_error = __esm({
-  "src/connect-error.ts"() {
-    exports.ConnectError = class extends Error {
-      code;
-      nextAction;
-      details;
-      constructor(code, message, nextAction2, details = {}) {
-        super(message);
-        this.name = "ConnectError";
-        this.code = code;
-        this.nextAction = nextAction2;
-        this.details = details;
-      }
-    };
-  }
-});
-
 // src/runtime-registry.ts
 function runtimeProfile(runtime, env = process.env) {
   return RUNTIME_PROFILES[normalizeRuntime(runtime, env)];
@@ -3241,138 +3482,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 exports.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 = [];
@@ -4088,10 +4197,10 @@ async function executeConnect(options, deps, trace) {
     } 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: 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) \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 {
@@ -4122,6 +4231,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) {
@@ -4564,7 +4685,7 @@ async function listOtherAgentIds(baseDir, currentDirectory) {
 function printNextSteps(result, log, approval, approvalUrl) {
   for (const line of completionHandoffLines(result, approval, approvalUrl)) log(line);
 }
-exports.CONNECTOR_VERSION = void 0; var PRODUCTION_CHAIN_ID, CONNECTOR_CLIENT_IDENTITY; exports.CONNECT_OUTCOME_SCHEMA_VERSION = void 0; var failureOutcomesByError, RERUN_HINT;
+exports.CONNECTOR_VERSION = void 0; var PRODUCTION_CHAIN_ID, UUID_SHAPE, CONNECTOR_CLIENT_IDENTITY; exports.CONNECT_OUTCOME_SCHEMA_VERSION = void 0; var failureOutcomesByError, RERUN_HINT;
 var init_runtime = __esm({
   "src/runtime.ts"() {
     init_api();
@@ -4581,8 +4702,9 @@ var init_runtime = __esm({
     init_tombstone();
     init_local_mcp_runtime();
     init_runtime_manifest();
-    exports.CONNECTOR_VERSION = "0.9.0-alpha.0";
+    exports.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/${exports.CONNECTOR_VERSION}`;
     exports.CONNECT_OUTCOME_SCHEMA_VERSION = 1;
     failureOutcomesByError = /* @__PURE__ */ new WeakMap();
@@ -5063,6 +5185,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}` : "";
 }
@@ -5144,6 +5300,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) {
@@ -5389,8 +5574,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)(
@@ -5421,12 +5609,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 };
@@ -5440,6 +5637,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) {
@@ -5473,7 +5671,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 } : {},
@@ -5541,15 +5742,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 ${exports.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 ${exports.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({
@@ -5623,9 +5829,13 @@ 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: `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" ? {
@@ -5654,7 +5864,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 }));
@@ -5714,20 +5924,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."
       ]
@@ -5785,13 +5999,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
@@ -6011,6 +6274,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) {
@@ -6062,7 +6330,9 @@ function helpText() {
     "                             agents can run side by side in one runtime. 1-32 lowercase letters, digits,",
     "                             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 one-time local Haven tools acknowledgement during setup.",
+    "  --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.",
@@ -6071,10 +6341,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.",
@@ -6239,11 +6512,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({
@@ -6445,14 +6719,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))}
 `);
@@ -6464,13 +6740,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]) {
@@ -6561,6 +6840,7 @@ init_installed_clients();
 init_storage();
 init_runtime_manifest();
 
+exports.assertDirectoryRecordsSlug = assertDirectoryRecordsSlug;
 exports.completionOutcome = completionOutcome;
 exports.createConnectApiClient = createConnectApiClient;
 exports.defaultAgentDirectory = defaultAgentDirectory;
@@ -6578,6 +6858,7 @@ exports.parseArgs = parseArgs;
 exports.prepareSignerRuntime = prepareSignerRuntime;
 exports.promptForInstalledClient = promptForInstalledClient;
 exports.redactSecrets = redactSecrets;
+exports.resolveAgentDirectoryBySlug = resolveAgentDirectoryBySlug;
 exports.resolveRuntimeByInstalledClientPrompt = resolveRuntimeByInstalledClientPrompt;
 exports.resolveRuntimeSelection = resolveRuntimeSelection;
 exports.runCli = runCli;