@haven_ai/connect 0.0.0-dev.202609230656.9b1d80a → 0.0.0-dev.202609232125.72f3d20

package/README.md

@@ -159,7 +159,9 @@ minutes. Two rules follow:
    This replaces the directory's signer wrapper with a diagnostic that logs the
    retirement (agent id, date, reason, restart guidance) to the host's MCP
    stderr log on every probe, and records it in `TOMBSTONE.json` for
-   `--doctor`. It touches no key material and revokes nothing — revoke the
+   `--doctor` — with a copy in `~/.haven/tombstones/` (or `.tombstones/` inside
+   a custom credentials root), so the retirement stays visible after the
+   directory is deleted. It touches no key material and revokes nothing — revoke the
    agent on the Haven agent page yourself. Delete the tombstone only once every
    long-lived host has been restarted.
 
@@ -173,7 +175,12 @@ minutes. Two rules follow:
    and a refusal is `{"tombstoned": false, "error": {"code", "next_action"}}`
    with exit 1 — so check the result rather than assuming silence means success
    (#2175). The `message` field is present only for connector-authored refusals;
-   an unexpected filesystem error keeps its raw text on stderr alone.
+   an unexpected filesystem error keeps its raw text on stderr alone. If only the
+   surviving copy fails — the directory IS tombstoned — the run still succeeds
+   with `"recordPath": null` and `"mirrorError"` set to the errno code (or
+   `mirror_write_failed` when there is none), and `--unwire --json` carries the
+   same as `mirror_error`; `--replace` still removes the old directory's key
+   files and names the failure in `retirement_mirror_errors` (#3259).
 
 ### Unwiring an agent (`--unwire`, #2169)
 
@@ -350,7 +357,8 @@ read-only verification tools, `hosted_mcp_url`, `superseded_agent_ids`,
 `existing_agents_before_write` (#3122 — the other live-keyed directories named
 before the first write, each with the account it spends from), and — on a run
 that replaced existing wiring — `superseded_agents_retired_locally` with
-`retired_agent_ids`; `server_name_rebound_from` (#3122) appears only when the
+`retired_agent_ids`, plus `retirement_mirror_errors` (#3259) only when a retired
+directory's surviving ledger record could not be written; `server_name_rebound_from` (#3122) appears only when the
 run took a server name over from another directory's local binding record. It
 contains no API key, private key, credential
 contents, full credential paths, or full delegate address. The same redacted

package/dist/cli.cjs

@@ -619,9 +619,9 @@ var init_runtime_manifest = __esm({
       mcpPackage: "@haven_ai/mcp",
       mcpVersion: mcp.MCP_VERSION,
       sdkPackage: "@haven_ai/sdk",
-      sdkVersion: "0.0.0-dev.202609230656.9b1d80a",
+      sdkVersion: "0.0.0-dev.202609232125.72f3d20",
       signerPackage: "@haven_ai/signer",
-      signerVersion: "0.0.0-dev.202609230656.9b1d80a",
+      signerVersion: "0.0.0-dev.202609232125.72f3d20",
       // 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
@@ -1590,7 +1590,7 @@ async function probeLocalSignerCredential(signerPath) {
   }
 }
 async function probeLocalMcpTools(command, args, requiredTools, timeoutMs = 1e4) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     const child = child_process.spawn(command, args, { stdio: ["pipe", "pipe", "ignore"] });
     let stdout = "";
     let settled = false;
@@ -1602,7 +1602,7 @@ async function probeLocalMcpTools(command, args, requiredTools, timeoutMs = 1e4)
       settled = true;
       clearTimeout(timeout);
       child.kill();
-      resolve10(result);
+      resolve11(result);
     };
     const timeout = setTimeout(() => finish({ status: "timeout" }), timeoutMs);
     child.on("error", () => finish({ status: "process_error" }));
@@ -3000,16 +3000,28 @@ var init_runtime_install = __esm({
 // 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 = [];
@@ -3086,9 +3098,14 @@ async function writeAgentTombstone(input) {
   const record = JSON.stringify(info, null, 2) + "\n";
   await promises.writeFile(path.join(input.directory, TOMBSTONE_FILENAME), record, "utf8");
   const root = input.tombstonesDir ?? defaultTombstonesDir();
-  await promises.mkdir(root, { recursive: true, mode: 448 });
   const recordPath = path.join(root, `${info.agent_id}.json`);
-  await promises.writeFile(recordPath, record, { mode: MIRROR_MODE });
+  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) {
@@ -3100,12 +3117,13 @@ async function readAgentTombstone(directory) {
     return null;
   }
 }
-var TOMBSTONE_FILENAME, MIRROR_MODE, TOMBSTONE_MARKER;
+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";
   }
@@ -3156,7 +3174,7 @@ async function unwireAgent(input) {
   const slug = input.slug ?? sidecar?.server_name;
   const names = serverNamesFor(slug);
   const runtimes = [];
-  const tombstoned = await tombstoneDirectoryIfAbsent({
+  const { written: tombstoned, mirrorError } = await tombstoneDirectoryIfAbsent({
     directory: input.directory,
     agentId,
     reason: input.reason ?? "unwired via --unwire",
@@ -3250,7 +3268,16 @@ async function unwireAgent(input) {
   const bindingReleased = await clearMcpServerBinding(input.directory);
   const teardown = await decideTeardown(identity, input);
   if (teardown.status !== "retained") await teardownLocalKeyMaterial(input.directory, identity);
-  return { directory: input.directory, agentId, slug, tombstoned, runtimes, teardown, bindingReleased };
+  return {
+    directory: input.directory,
+    agentId,
+    slug,
+    tombstoned,
+    runtimes,
+    teardown,
+    bindingReleased,
+    ...mirrorError === void 0 ? {} : { mirrorError }
+  };
 }
 async function decideTeardown(identity, input) {
   const ended = "Local recovery of a stranded delegate balance ends with it: the sweep-recovery routes accept only this agent's API key and delegate signature, and neither exists on this machine any more.";
@@ -3295,9 +3322,9 @@ async function decideTeardown(identity, input) {
   }
 }
 async function tombstoneDirectoryIfAbsent(input) {
-  if (await readOptionalText(path.join(input.directory, TOMBSTONE_FILENAME)) !== null) return false;
-  await writeAgentTombstone(input);
-  return true;
+  if (await readOptionalText(path.join(input.directory, TOMBSTONE_FILENAME)) !== null) return { written: false };
+  const { mirrorError } = await writeAgentTombstone(input);
+  return mirrorError === void 0 ? { written: true } : { written: true, mirrorError };
 }
 async function teardownLocalKeyMaterial(directory, identity) {
   await Promise.all([
@@ -4330,7 +4357,8 @@ async function runDoctor(input, deps = {}) {
     if (retired.length > 0) parts.push(`tombstoned (keys removed): ${retired.join(", ")}`);
     if (unverifiable.length > 0) parts.push(`could not verify: ${unverifiable.join(", ")}`);
     const knownIds = new Set([...inventory].map((e) => e.agentId ?? path.basename(e.directory)));
-    const ghostRecords = (await readTombstoneRecords(path.join(homeDir, ".haven", "tombstones"))).filter(
+    const ledgerDir = input.credentialsDir ? tombstonesDirForAgentDirectory(input.credentialsDir, homeDir) : path.join(homeDir, ".haven", "tombstones");
+    const ghostRecords = (await readTombstoneRecords(ledgerDir)).filter(
       (rec) => !knownIds.has(rec.agent_id)
     );
     if (ghostRecords.length > 0) {
@@ -4828,9 +4856,10 @@ async function pathExists2(path) {
 
 // src/runtime.ts
 init_unwire();
+init_tombstone();
 init_local_mcp_runtime();
 init_runtime_manifest();
-var CONNECTOR_VERSION = "0.0.0-dev.202609230656.9b1d80a";
+var CONNECTOR_VERSION = "0.0.0-dev.202609232125.72f3d20";
 var CONNECT_OUTCOME_SCHEMA_VERSION = 1;
 var failureOutcomesByError = /* @__PURE__ */ new WeakMap();
 function failureOutcomeFor(runtimeHint, error) {
@@ -5118,6 +5147,7 @@ async function executeConnect(options, deps, trace) {
   }
   let supersededAgentsRetiredLocally;
   const retiredAgentIds = [];
+  const retirementMirrorErrors = {};
   if (replacing) {
     if (runtimeInstall.errorCode) {
       supersededAgentsRetiredLocally = false;
@@ -5128,12 +5158,21 @@ async function executeConnect(options, deps, trace) {
       supersededAgentsRetiredLocally = true;
       for (const entry of replacing.superseded) {
         try {
-          await tombstoneDirectoryIfAbsent({
+          const { mirrorError } = await tombstoneDirectoryIfAbsent({
             directory: entry.directory,
             agentId: entry.agentId,
             reason: "replaced by a new setup (--replace)",
-            replacedBy: registration.agent_id
+            replacedBy: registration.agent_id,
+            // #3251: the ledger follows this run's credential root (default
+            // root → ~/.haven/tombstones, as before; any other → <root>/.tombstones).
+            tombstonesDir: tombstonesDirForCredentialRoot(options.credentialsDir)
           });
+          if (mirrorError !== void 0) {
+            retirementMirrorErrors[entry.agentId] = mirrorError;
+            log(
+              `Warning: the surviving tombstone record for ${entry.agentId} could not be written to ${tombstonesDirForCredentialRoot(options.credentialsDir)} (${mirrorError}). The in-place TOMBSTONE.json stands; --doctor will not list this retirement once the directory is deleted.`
+            );
+          }
           await teardownLocalKeyMaterial(entry.directory, await readIdentityFile(entry.directory));
           await clearMcpServerBinding(entry.directory);
           retiredAgentIds.push(entry.agentId);
@@ -5205,6 +5244,7 @@ async function executeConnect(options, deps, trace) {
     supersededAgentIds,
     supersededAgentsRetiredLocally,
     ...replacing ? { retiredAgentIds } : {},
+    ...Object.keys(retirementMirrorErrors).length > 0 ? { retirementMirrorErrors } : {},
     existingAgentsBeforeWrite: existingAgents.map((a) => ({ agent_id: a.agentId, account_address: a.accountAddress })),
     ...reboundFrom ? { serverNameReboundFrom: reboundFrom } : {},
     setupChallengeExpiresAt: setup.challenge.expires_at,
@@ -5271,6 +5311,7 @@ function completionOutcome(input) {
     superseded_agent_ids: input.supersededAgentIds ?? [],
     ...input.supersededAgentsRetiredLocally !== void 0 ? { superseded_agents_retired_locally: input.supersededAgentsRetiredLocally } : {},
     ...input.retiredAgentIds ? { retired_agent_ids: input.retiredAgentIds } : {},
+    ...input.retirementMirrorErrors ? { retirement_mirror_errors: input.retirementMirrorErrors } : {},
     // #3122: always emitted on a completed run (empty list included), for the
     // same reason as superseded_agent_ids above.
     existing_agents_before_write: input.existingAgentsBeforeWrite ?? [],
@@ -5459,7 +5500,7 @@ function describeWaitBound(timeoutMs) {
 async function waitForBudgetApproval(api, setupId, apiKey, log, options = {}) {
   const intervalMs = options.intervalMs ?? 5e3;
   const timeoutMs = options.timeoutMs ?? 18e4;
-  const sleep = options.sleep ?? ((ms) => new Promise((resolve10) => setTimeout(resolve10, ms)));
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve11) => setTimeout(resolve11, ms)));
   const maxPolls = Math.max(1, Math.floor(timeoutMs / intervalMs));
   const remindEvery = Math.max(1, Math.floor(3e4 / intervalMs));
   let waitingAnnounced = false;
@@ -5932,7 +5973,7 @@ async function runCli(argv, io = {
     return 0;
   }
   if (parsed.tombstone) {
-    const { writeAgentTombstone: writeAgentTombstone2 } = await Promise.resolve().then(() => (init_tombstone(), tombstone_exports));
+    const { writeAgentTombstone: writeAgentTombstone2, tombstonesDirForAgentDirectory: tombstonesDirForAgentDirectory2 } = await Promise.resolve().then(() => (init_tombstone(), tombstone_exports));
     const { readFile: readFile15 } = await import('fs/promises');
     const { join: join13 } = await import('path');
     try {
@@ -5944,11 +5985,16 @@ async function runCli(argv, io = {
         agentId = identity.agent_id ?? "unknown";
       } catch {
       }
+      const ledgerDir = tombstonesDirForAgentDirectory2(parsed.tombstone.directory);
       const info = await writeAgentTombstone2({
         directory: parsed.tombstone.directory,
         agentId,
         reason: parsed.tombstone.reason ?? "retired by operator via --tombstone",
-        replacedBy: parsed.tombstone.replacedBy
+        replacedBy: parsed.tombstone.replacedBy,
+        // #3251: the ledger of the root that holds the retired directory —
+        // ~/.haven/agents/<x> → ~/.haven/tombstones, exactly as before; a
+        // directory under any other root → <root>/.tombstones.
+        tombstonesDir: ledgerDir
       });
       if (parsed.json) {
         io.stdout(`${redactSecrets(JSON.stringify({ tombstoned: true, ...info }))}
@@ -5960,11 +6006,18 @@ async function runCli(argv, io = {
           "Key files were NOT touched and nothing was revoked \u2014 revoke the agent on the Haven agent page if you have not already.\n"
         );
         io.stdout(
-          `A surviving tombstone record was mirrored to ${redactSecrets(info.recordPath)}
+          info.recordPath !== null ? `A surviving tombstone record was mirrored to ${redactSecrets(info.recordPath)}
+` : (
+            // #3259: the directory IS tombstoned; only the surviving copy failed.
+            redactSecrets(
+              `! The surviving tombstone record could NOT be written to ${ledgerDir} (${info.mirrorError}). The in-place TOMBSTONE.json stands, but --doctor will not list this retirement once the directory is deleted.
 `
+            )
+          )
         );
         io.stdout(
-          "Restart EVERY long-lived MCP host (gateway, TUI workers, editors): each holds the wiring snapshot from its own start time, and the tombstone only speaks when a stale host next probes the old path. The mirrored record keeps this retirement observable even after the agent directory itself is deleted.\n"
+          "Restart EVERY long-lived MCP host (gateway, TUI workers, editors): each holds the wiring snapshot from its own start time, and the tombstone only speaks when a stale host next probes the old path." + // #3259 review: never claim a copy that the line above says was not written.
+          (info.recordPath !== null ? " The mirrored record keeps this retirement observable even after the agent directory itself is deleted." : "") + "\n"
         );
       }
       return 0;
@@ -5977,11 +6030,13 @@ 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 { 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 ledgerDir = tombstonesDirForAgentDirectory2(directory, homeDir);
     try {
       const result = await unwireAgent2({
         directory,
@@ -5989,7 +6044,14 @@ async function runCli(argv, io = {
         reason: parsed.unwire.reason,
         replacedBy: parsed.unwire.replacedBy,
         destroyKeyMaterial: parsed.unwire.destroyKeyMaterial,
-        homeDir
+        homeDir,
+        // #3251: the ledger of the root that holds the directory being
+        // retired. Derived from the RESOLVED directory, not from
+        // --credentials-dir: `--unwire --credentials-dir <path>` names the agent
+        // directory itself, not a root. ~/.haven/agents/<slug> →
+        // ~/.haven/tombstones, exactly as before; any other root →
+        // <root>/.tombstones.
+        tombstonesDir: ledgerDir
       });
       const failures = result.runtimes.filter((r) => r.status === "refused" || r.status === "unreadable");
       const retained = result.teardown.status === "retained";
@@ -6002,6 +6064,8 @@ async function runCli(argv, io = {
               slug: result.slug ?? null,
               directory: result.directory,
               tombstoned: result.tombstoned,
+              // #3259: additive — present only when the surviving ledger record failed.
+              ...result.mirrorError !== void 0 ? { mirror_error: result.mirrorError } : {},
               runtimes: result.runtimes.map((r) => ({
                 runtime: r.runtime,
                 label: r.label,
@@ -6027,6 +6091,12 @@ async function runCli(argv, io = {
         io.stdout(
           result.tombstoned ? "  \xB7 Tombstoned first: any long-lived host still resolving the old wrapper gets the HAVEN-TOMBSTONE diagnosis.\n" : "  \xB7 Directory was already tombstoned.\n"
         );
+        if (result.mirrorError !== void 0) {
+          io.stdout(redactSecrets(
+            `  ! Surviving tombstone record: NOT written to ${ledgerDir} (${result.mirrorError}) \u2014 the in-place tombstone stands; --doctor will not list this retirement once the directory is deleted.
+`
+          ));
+        }
         for (const r of result.runtimes) {
           const mark = r.status === "removed" ? "\u2713" : r.status === "clean" ? "\u2013" : "\u2717";
           io.stdout(redactSecrets(`  ${mark} ${r.label}: ${r.status}${r.detail ? ` \u2014 ${r.detail}` : ""}