edge-book 0.13.0 → 0.15.0

package/dist/edge-book.js

@@ -5,18 +5,19 @@ import { realpathSync } from "fs";
 import { fileURLToPath } from "url";
 
 // src/cli-shared.ts
-import fs8 from "fs/promises";
-import path8 from "path";
+import fs9 from "fs/promises";
+import path10 from "path";
 
 // src/dialout.ts
-import crypto5 from "crypto";
+import crypto6 from "crypto";
 import WebSocket from "ws";
 
 // src/dialout-key.ts
 import crypto from "crypto";
 import fs from "fs/promises";
 import path from "path";
-var KEY_FILE = "host-dialout-key.json";
+var DIALOUT_KEY_FILE = "host-dialout-key.json";
+var KEY_FILE = DIALOUT_KEY_FILE;
 var DEFAULT_PAIR_TTL_MS = 5 * 60 * 1e3;
 var PAIRING_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
 function now() {
@@ -98,7 +99,7 @@ async function createSessionsRevokeFrame(store) {
 }
 
 // src/edge-book.ts
-import path6 from "path";
+import path7 from "path";
 
 // src/types.ts
 var EPHEMERAL_TTL_POLICY = {
@@ -195,12 +196,12 @@ async function readJsonl(file) {
 
 // src/handles.ts
 var HANDLE_SLUG = /^[a-z0-9](?:[a-z0-9-]{1,28}[a-z0-9])$/;
-var RESERVED_HANDLES = /* @__PURE__ */ new Set(["add", "healthz", "metrics", "agent", "api", "handle", "auth"]);
+var RESERVED_HANDLES = /* @__PURE__ */ new Set(["add", "healthz", "metrics", "agent", "api", "handle", "auth", "directory"]);
 function isValidHandle(handle) {
   return HANDLE_SLUG.test(handle) && !RESERVED_HANDLES.has(handle);
 }
 function slugifyHandle(input) {
-  return input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 30);
+  return input.trim().replace(/^@/, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 30);
 }
 
 // src/crypto.ts
@@ -404,6 +405,9 @@ var CONTACT_MUTES_FILE = "contact-mutes.json";
 var REPORTS_FILE = "reports.json";
 var INVITE_CODES_FILE = "invite-codes.json";
 var INBOUND_RATE_FILE = "inbound-rate.json";
+var OUTBOX_FILE = "outbox.json";
+var EVENTS_FILE = "events.ndjson";
+var SUPPORT_BUNDLES_FILE = "support-bundles.json";
 var ATTESTATIONS_FILE = "attestations.json";
 var ENDORSEMENTS_FILE = "endorsements.json";
 var SIGNALS_FILE = "signals.json";
@@ -1503,6 +1507,74 @@ async function expireEscalations(store) {
   if (changed) await store.saveEscalations(all);
 }
 
+// src/event-log.ts
+import crypto4 from "crypto";
+import fs6 from "fs/promises";
+import path6 from "path";
+var MAX_EVENT_LINES = 2e3;
+var COMPACT_KEEP_LINES = 1e3;
+function eventErrorCode(e) {
+  if (e instanceof Error) {
+    const code = e.code;
+    if (typeof code === "string" && code.length > 0) return code;
+    return e.constructor.name || "Error";
+  }
+  return "unknown_error";
+}
+async function logEvent(store, kind, fields = {}, caps = {}) {
+  try {
+    const event = { ts: (/* @__PURE__ */ new Date()).toISOString(), kind, ...fields };
+    const file = store.file(EVENTS_FILE);
+    await fs6.mkdir(path6.dirname(file), { recursive: true });
+    await fs6.appendFile(file, `${JSON.stringify(event)}
+`, "utf8");
+    await compactIfNeeded(file, caps.maxLines ?? MAX_EVENT_LINES, caps.keepLines ?? COMPACT_KEEP_LINES);
+  } catch {
+  }
+}
+async function compactIfNeeded(file, maxLines, keepLines) {
+  const text = await fs6.readFile(file, "utf8");
+  const lines = text.split("\n").filter((l) => l.length > 0);
+  if (lines.length <= maxLines) return;
+  const kept = lines.slice(-keepLines);
+  const tmp = `${file}.tmp-${crypto4.randomBytes(6).toString("hex")}`;
+  try {
+    await fs6.writeFile(tmp, `${kept.join("\n")}
+`, "utf8");
+    await fs6.rename(tmp, file);
+  } catch (error) {
+    await fs6.rm(tmp, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function readEvents(store, limit) {
+  let text;
+  try {
+    text = await fs6.readFile(store.file(EVENTS_FILE), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    return [];
+  }
+  const out = [];
+  for (const line of text.split("\n")) {
+    if (!line) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed && typeof parsed === "object" && typeof parsed.kind === "string") out.push(parsed);
+    } catch {
+    }
+  }
+  return limit !== void 0 && out.length > limit ? out.slice(-limit) : out;
+}
+async function lastEvent(store, kind) {
+  const events = await readEvents(store);
+  for (let i = events.length - 1; i >= 0; i--) {
+    const e = events[i];
+    if (kind.endsWith(".") ? e.kind.startsWith(kind) : e.kind === kind) return e;
+  }
+  return void 0;
+}
+
 // src/store-friends.ts
 async function upsertContactFromCard(store, card, state) {
   validateCard(card);
@@ -1569,6 +1641,7 @@ async function setRelationship(store, peerAgentId, nextState, type, reason = "")
   const event = { ...unsigned, signature: signPayload(unsigned, identity.private_key_pem) };
   await appendJsonl(store.file(RELATIONSHIP_EVENTS_FILE), event);
   await store.audit(`relationship.${type}`, peerAgentId, { previous, next: nextState, reason });
+  await logEvent(store, "friend.state_changed", { peer: peerAgentId, previous, next: nextState, event_type: type });
   return event;
 }
 async function createFriendRequest(store, targetCard, note = "", inviteCode = "") {
@@ -1608,6 +1681,7 @@ async function receiveFriendRequest(store, envelope) {
   }
   const contact = await store.upsertContactFromCard(body.card, "request_received");
   await store.setRelationship(envelope.from_agent_id, "request_received", "FriendRequest", body.note);
+  await logEvent(store, "friend.request_received", { from: envelope.from_agent_id, dedup_key: envelope.message_id, trace_id: envelope.trace_id });
   await appendJsonl(store.file(INBOX_FILE), envelope);
   const existingApprovals = await store.approvals();
   const alreadyPending = Object.values(existingApprovals).some(
@@ -1651,6 +1725,7 @@ async function acceptFriend(store, peerAgentId, reason = "accepted") {
   if (!contact) throw new EdgeBookError("unknown_contact", `Unknown contact: ${peerAgentId}`);
   if (contact.relationship_state === "blocked") throw new EdgeBookError("blocked_peer", "Cannot accept a blocked peer");
   await store.setRelationship(peerAgentId, "friend", "Accept", reason);
+  await logEvent(store, "friend.accepted", { peer: peerAgentId });
   const grant = await store.issueGrant(peerAgentId, ["message.friend", "feed.read.friends", "profile.read.friend", "escalation.raise"]);
   const card = await store.writeCard();
   const profile = await store.buildFriendProfile();
@@ -1828,8 +1903,8 @@ async function consumeInviteCode(store, code) {
 }
 
 // src/store-identity.ts
-import crypto4 from "crypto";
-import fs6 from "fs/promises";
+import crypto5 from "crypto";
+import fs7 from "fs/promises";
 async function init(store, input = {}) {
   await ensureHome(store.home);
   const existing = await readJson(store.file(IDENTITY_FILE), null);
@@ -1837,7 +1912,7 @@ async function init(store, input = {}) {
     await store.updateConfig({ direct_url: input.directUrl, relay_url: input.relayUrl });
     return existing;
   }
-  const { publicKey, privateKey } = crypto4.generateKeyPairSync("ed25519");
+  const { publicKey, privateKey } = crypto5.generateKeyPairSync("ed25519");
   const public_key_pem = publicKey.export({ type: "spki", format: "pem" }).toString();
   const private_key_pem = privateKey.export({ type: "pkcs8", format: "pem" }).toString();
   const identity = {
@@ -1897,16 +1972,21 @@ async function setProfile(store, input) {
   await store.audit("identity.update", identity.agent_id, { display_name: identity.display_name, profile_version: profile.profile_version });
   return identity;
 }
-async function setHandle(store, handle) {
+async function setHandle(store, handle, opts = {}) {
   if (!isValidHandle(handle)) {
     throw new EdgeBookError("invalid_handle", `invalid_handle: must be 3-30 chars [a-z0-9-], not reserved: ${handle}`);
   }
   const identity = await store.identity();
   identity.handle = handle;
+  if (opts.discoverable === false) {
+    identity.handle_discoverable = false;
+  } else {
+    delete identity.handle_discoverable;
+  }
   identity.updated_at = now2();
   await writeJson(store.file(IDENTITY_FILE), identity, 384);
   await store.writeCard();
-  await store.audit("identity.set_handle", identity.agent_id, { handle });
+  await store.audit("identity.set_handle", identity.agent_id, { handle, discoverable: opts.discoverable !== false });
   return identity;
 }
 async function exportIdentity(store) {
@@ -1942,6 +2022,7 @@ async function updateConfig(store, input) {
   if (input.inbound_window_ms !== void 0) next.inbound_window_ms = input.inbound_window_ms;
   if (input.handle_nudge_at !== void 0) next.handle_nudge_at = input.handle_nudge_at;
   if (input.greeter_mode !== void 0) next.greeter_mode = input.greeter_mode;
+  if (input.support_inbox !== void 0) next.support_inbox = input.support_inbox;
   if (input.greeter_welcome_object_id !== void 0) next.greeter_welcome_object_id = input.greeter_welcome_object_id;
   await writeJson(store.file(CONFIG_FILE), next);
   return next;
@@ -1973,7 +2054,7 @@ async function buildCard(store, cardUrl) {
     refresh_after: new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString(),
     expires_at: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3).toISOString()
   };
-  const card_hash = crypto4.createHash("sha256").update(canonicalize(unsigned)).digest("base64url");
+  const card_hash = crypto5.createHash("sha256").update(canonicalize(unsigned)).digest("base64url");
   const withHash = { ...unsigned, card_hash };
   return { ...withHash, signature: signPayload(withHash, identity.private_key_pem) };
 }
@@ -1990,7 +2071,7 @@ async function buildHandleClaim(store) {
   const card = await loadCard(store.file(CARD_FILE));
   const claimed_at = Date.now();
   const claim_sig = signPayload({ handle: identity.handle, agent_did: identity.agent_id, claimed_at }, identity.private_key_pem);
-  return { handle: identity.handle, agent_did: identity.agent_id, card, claimed_at, claim_sig };
+  return { handle: identity.handle, agent_did: identity.agent_id, card, claimed_at, claim_sig, discoverable: identity.handle_discoverable !== false };
 }
 async function buildFriendProfile(store) {
   const identity = await store.identity();
@@ -2018,7 +2099,7 @@ async function doctor(store) {
   const files = {};
   for (const name of requiredFiles) {
     try {
-      const stat = await fs6.stat(store.file(name));
+      const stat = await fs7.stat(store.file(name));
       files[name] = {
         exists: true,
         mode: `0${(stat.mode & 511).toString(8)}`
@@ -2118,6 +2199,79 @@ async function exportLocalData(store) {
   };
 }
 
+// src/store-support.ts
+var SUPPORT_BUNDLE_MAX_BYTES = 256 * 1024;
+var SUPPORT_BUNDLE_KEEP = 200;
+function pruneSupportBundles(all, keepId) {
+  const records = Object.values(all);
+  if (records.length <= SUPPORT_BUNDLE_KEEP) return all;
+  const byAge = (a, b) => a.received_at.localeCompare(b.received_at);
+  const evictable = [
+    ...records.filter((r) => r.status === "dismissed" && r.bundle_id !== keepId).sort(byAge),
+    ...records.filter((r) => r.status !== "dismissed" && r.bundle_id !== keepId).sort(byAge)
+  ];
+  for (const r of evictable) {
+    if (Object.keys(all).length <= SUPPORT_BUNDLE_KEEP) break;
+    delete all[r.bundle_id];
+  }
+  return all;
+}
+async function supportBundles(store) {
+  return readJson(store.file(SUPPORT_BUNDLES_FILE), {});
+}
+async function saveSupportBundles(store, all) {
+  await writeJson(store.file(SUPPORT_BUNDLES_FILE), all);
+}
+async function receiveSupportBundle(store, envelope) {
+  if ((await store.config()).support_inbox !== true) {
+    throw new EdgeBookError("support_inbox_disabled", "This agent does not accept support bundles (operator opt-in: edge-book support inbox --on)");
+  }
+  if (envelope.type !== "support_bundle") throw new EdgeBookError("wrong_message_type", "Expected support_bundle envelope");
+  const size = Buffer.byteLength(JSON.stringify(envelope), "utf8");
+  if (size > SUPPORT_BUNDLE_MAX_BYTES) {
+    throw new EdgeBookError("support_bundle_too_large", `Support bundle is ${size} bytes; the receiver cap is ${SUPPORT_BUNDLE_MAX_BYTES} (256 KiB)`);
+  }
+  await store.enforceInboundRate(envelope.from_agent_id);
+  await store.verifyEnvelope(envelope);
+  const body = envelope.body;
+  if (!body || typeof body !== "object" || !body.report || typeof body.report !== "object") {
+    throw new EdgeBookError("bad_support_bundle", "support_bundle envelope carries no report");
+  }
+  validateCard(body.card);
+  if (body.card.agent_id !== envelope.from_agent_id) {
+    throw new EdgeBookError("agent_id_mismatch", "Embedded card does not match the envelope sender");
+  }
+  const record = {
+    bundle_id: envelope.message_id,
+    from_agent_id: envelope.from_agent_id,
+    ...body.card.display_name ? { from_display_name: body.card.display_name } : {},
+    ...envelope.trace_id ? { trace_id: envelope.trace_id } : {},
+    received_at: now2(),
+    status: "pending",
+    report: body.report,
+    ...typeof body.note === "string" && body.note ? { note: body.note } : {}
+  };
+  const all = await supportBundles(store);
+  all[record.bundle_id] = record;
+  await saveSupportBundles(store, pruneSupportBundles(all, record.bundle_id));
+  await store.audit("support.receive", envelope.from_agent_id, { bundle_id: record.bundle_id, trace_id: envelope.trace_id ?? "" });
+  await logEvent(store, "support.received", { from: envelope.from_agent_id, dedup_key: envelope.message_id, trace_id: envelope.trace_id });
+  return record;
+}
+async function pendingSupportBundles(store) {
+  const all = await supportBundles(store);
+  return Object.values(all).filter((b) => b.status === "pending").sort((a, b) => a.received_at.localeCompare(b.received_at));
+}
+async function setSupportBundleStatus(store, bundleId, status) {
+  const all = await supportBundles(store);
+  const record = all[bundleId];
+  if (!record) throw new EdgeBookError("unknown_bundle", `Unknown support bundle: ${bundleId}`);
+  record.status = status;
+  all[bundleId] = record;
+  await saveSupportBundles(store, all);
+  return record;
+}
+
 // src/store-trust.ts
 async function enforceInboundRate(store, peerAgentId) {
   const config = await store.config();
@@ -2244,33 +2398,42 @@ async function assertGrantSignature(store, grant) {
 }
 async function signEnvelope(store, input) {
   const identity = await store.identity();
+  const { expires_at, ...rest } = input;
   const unsigned = {
     message_id: randomId("msg"),
     from_agent_id: identity.agent_id,
     created_at: now2(),
-    expires_at: new Date(Date.now() + 10 * 60 * 1e3).toISOString(),
-    ...input
+    expires_at: expires_at ?? new Date(Date.now() + 10 * 60 * 1e3).toISOString(),
+    ...rest,
+    // Trace correlation (ea-claude-138): every new outbound envelope carries a
+    // trace_id INSIDE the signed payload (tamper-evident; back-compat — old
+    // receivers canonicalize whatever fields they parsed, so verification
+    // still passes). Callers may pass an existing trace_id to chain a flow;
+    // it is clamped to 128 chars (mirrors the host frame rule) and an empty
+    // string falls back to a generated id.
+    trace_id: input.trace_id?.slice(0, 128) || randomId("trace")
   };
   return { ...unsigned, signature: signPayload(unsigned, identity.private_key_pem) };
 }
+function embeddedCardKey(envelope) {
+  if (envelope.type !== "friend_request" && envelope.type !== "friend_response" && envelope.type !== "support_bundle") return void 0;
+  const card = envelope.body.card;
+  return card?.public_keys?.[0]?.public_key_pem;
+}
 async function verifyEnvelope(store, envelope) {
   const identity = await store.identity();
   if (envelope.to_agent_id !== identity.agent_id) throw new EdgeBookError("wrong_recipient", "Envelope recipient does not match local identity");
   if (Date.parse(envelope.expires_at) <= Date.now()) throw new EdgeBookError("expired_message", "Message is expired");
   const seen = await readJson(store.file(SEEN_MESSAGES_FILE), []);
-  if (seen.includes(envelope.message_id)) throw new EdgeBookError("replay", `Replay detected for ${envelope.message_id}`);
-  const contacts = await store.contacts();
-  let publicKey = contacts[envelope.from_agent_id]?.public_keys?.[0]?.public_key_pem;
-  if (!publicKey && envelope.type === "friend_request") {
-    const card = envelope.body.card;
-    publicKey = card?.public_keys?.[0]?.public_key_pem;
-  }
-  if (!publicKey && envelope.type === "friend_response") {
-    const card = envelope.body.card;
-    publicKey = card?.public_keys?.[0]?.public_key_pem;
+  if (seen.includes(envelope.message_id)) {
+    await logEvent(store, "envelope.dedup_hit", { envelope_kind: envelope.type, from: envelope.from_agent_id, dedup_key: envelope.message_id, trace_id: envelope.trace_id });
+    throw new EdgeBookError("replay", `Replay detected for ${envelope.message_id}`);
   }
+  const contacts = await store.contacts();
+  const publicKey = contacts[envelope.from_agent_id]?.public_keys?.[0]?.public_key_pem ?? embeddedCardKey(envelope);
   if (!publicKey) throw new EdgeBookError("unknown_key", `Unknown sender key for ${envelope.from_agent_id}`);
   if (!verifyPayload(withoutSignature(envelope), envelope.signature, publicKey)) {
+    await logEvent(store, "envelope.signature_failed", { envelope_kind: envelope.type, from: envelope.from_agent_id, dedup_key: envelope.message_id, trace_id: envelope.trace_id });
     throw new EdgeBookError("invalid_signature", "Message signature is invalid");
   }
   seen.push(envelope.message_id);
@@ -2317,6 +2480,7 @@ async function revokeSession(store, sessionId) {
 }
 async function receiveEnvelope(store, envelope) {
   if (envelope.type === "friend_request") return store.receiveFriendRequest(envelope);
+  if (envelope.type === "support_bundle") return receiveSupportBundle(store, envelope);
   if (envelope.type === "friend_response") return store.applyFriendResponse(envelope);
   if (envelope.type === "privileged_message") return store.receivePrivilegedMessage(envelope);
   if (envelope.type === "object_share") {
@@ -2416,6 +2580,17 @@ var NOTIFY_POLICIES = {
       message: `${esc?.subject ?? "A decision is needed"} \u2014 ${esc?.body ?? ""}${opts}`,
       dedup_key: env.message_id
     };
+  },
+  support_bundle: async (env) => {
+    const body = env.body;
+    const name = body.card?.display_name || env.from_agent_id;
+    return {
+      kind: "support_bundle",
+      from_id: env.from_agent_id,
+      from_name: body.card?.display_name,
+      message: `${name} sent a support bundle (ref ${env.trace_id ?? env.message_id}). Review: edge-book support pending`,
+      dedup_key: env.message_id
+    };
   }
 };
 async function notificationIntent(store, envelope) {
@@ -2437,6 +2612,14 @@ async function recordNotified(store, dedupKey) {
   ledger.push(dedupKey);
   await writeJson(store.file(NOTIFIED_FILE), ledger);
 }
+function buildPairCompleteNotifyIntent(deviceId, label) {
+  return {
+    kind: "pair_complete",
+    message: `Pairing complete \u2014 your reader is connected (device: ${label}).`,
+    from_id: deviceId,
+    dedup_key: deviceId
+  };
+}
 
 // src/edge-book.ts
 var EdgeBookStore = class {
@@ -2445,7 +2628,7 @@ var EdgeBookStore = class {
     this.home = resolveHome(options.home);
   }
   file(name) {
-    return path6.join(this.home, name);
+    return path7.join(this.home, name);
   }
   async init(input = {}) {
     return init(this, input);
@@ -2464,8 +2647,8 @@ var EdgeBookStore = class {
     return setProfile(this, input);
   }
   // Set a user-chosen unique handle. Re-signs the card; does NOT rotate keys.
-  async setHandle(handle) {
-    return setHandle(this, handle);
+  async setHandle(handle, opts) {
+    return setHandle(this, handle, opts);
   }
   // Portable identity bundle (the DID keypair + chosen handle). Carry to a new
   // device → same DID → relay handle keeps resolving to you (spec-096).
@@ -2981,16 +3164,17 @@ function nextAction(result, target) {
       return first ? `candidates list   # then: friend request ${first.candidate_id}` : "candidates list";
     }
     default:
-      return "(no match \u2014 check the target)";
+      return "not found \u2014 share your invite link so they can add you: card invite  (use the deeplink_url)";
   }
 }
 var localContactProvider = {
   name: "local",
   priority: 100,
   async resolve(store, target) {
+    const normalized = target.trim().replace(/^@/, "").toLowerCase();
     const contacts = await store.contacts();
     const match = Object.values(contacts).find(
-      (c) => c.peer_agent_id === target || c.aliases.includes(target) || c.display_name === target
+      (c) => c.peer_agent_id === target || c.aliases.some((a) => a.toLowerCase() === normalized) || c.display_name.toLowerCase() === normalized
     );
     if (!match) return null;
     return {
@@ -3056,11 +3240,12 @@ async function writeCandidate(store, input) {
   await store.audit("candidate.write", candidate.agent_id ?? "", { candidate_id: candidate.candidate_id, source: candidate.source });
   return candidate;
 }
+var DEFAULT_RELAY_BASE = "https://edge-book-host.fly.dev";
 function defaultProviders(relayBase) {
+  const base = relayBase ?? process.env["EDGE_BOOK_RELAY_BASE"] ?? DEFAULT_RELAY_BASE;
   const lookup = async (target) => {
-    if (!relayBase) return null;
     const slug = target.startsWith("registry:") ? target.slice("registry:".length) : target;
-    return `${relayBase.replace(/\/$/, "")}/handle/${encodeURIComponent(slug)}`;
+    return `${base.replace(/\/$/, "")}/handle/${encodeURIComponent(slug)}`;
   };
   return [localContactProvider, inviteProvider, cardUrlProvider, cardFileProvider, makeRegistryProvider(lookup)];
 }
@@ -3108,15 +3293,22 @@ async function promoteCandidate(store, candidateId, note = "") {
   return envelope;
 }
 var HANDLE_SLUG2 = /^[a-z0-9](?:[a-z0-9-]{1,28}[a-z0-9])$/;
+function normalizeRegistryTarget(target) {
+  if (target.startsWith("registry:")) {
+    return "registry:" + target.slice("registry:".length).trim().toLowerCase().replace(/^@/, "");
+  }
+  return target.trim().toLowerCase().replace(/^@/, "");
+}
 function makeRegistryProvider(lookup) {
   return {
     name: "registry",
     priority: 50,
     async resolve(_store, target) {
-      const isExplicit = target.startsWith("registry:");
-      const slug = isExplicit ? target.slice("registry:".length) : target;
-      if (!isExplicit && !HANDLE_SLUG2.test(slug)) return null;
-      const cardTarget = await lookup(target);
+      const slug = normalizeRegistryTarget(target);
+      const isExplicit = slug.startsWith("registry:");
+      const bareSlug = isExplicit ? slug.slice("registry:".length) : slug;
+      if (!isExplicit && !HANDLE_SLUG2.test(bareSlug)) return null;
+      const cardTarget = await lookup(slug);
       if (!cardTarget) return null;
       let card;
       try {
@@ -4465,7 +4657,9 @@ async function handleOwnerApi(req, res, url, adapters) {
     const card = await store.buildCard();
     const identity = await store.identity();
     const invite_url = `edgebook:invite:${Buffer.from(JSON.stringify(card), "utf8").toString("base64url")}`;
-    sendJson(res, 200, { agent_id: identity.agent_id, display_name: identity.display_name, card_url: card.card_url, card, invite_url });
+    const origin = card.card_url ? new URL(card.card_url).origin : "https://edge-book-host.fly.dev";
+    const deeplink_url = `${origin}/add#i=${encodeURIComponent(invite_url)}`;
+    sendJson(res, 200, { agent_id: identity.agent_id, display_name: identity.display_name, card_url: card.card_url, card, invite_url, deeplink_url });
     return true;
   }
   const attachmentMatch = /^\/api\/shared-objects\/([^/]+)\/attachment$/.exec(url.pathname);
@@ -4747,6 +4941,95 @@ function requestBody(frame, method) {
   return Buffer.from(JSON.stringify(frame.body ?? {}), "utf8");
 }
 
+// src/dialout-pair.ts
+var PairCompleteWaiter = class {
+  resolve = null;
+  timer = null;
+  // Called by EdgeBookDialoutClient.handleMessage when type === "pair_complete".
+  onFrame(frame) {
+    if (!this.resolve) return;
+    const cb = this.resolve;
+    this.resolve = null;
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    cb({ device_id: frame.device_id ?? "", label: frame.label ?? "" });
+  }
+  // Wait up to ttlMs for a pair_complete frame from the host.
+  // Returns null on timeout — old-host degradation (spec-135 §C.2).
+  wait(ttlMs) {
+    return new Promise((resolve) => {
+      this.resolve = resolve;
+      this.timer = setTimeout(() => {
+        if (this.resolve) {
+          this.resolve = null;
+          resolve(null);
+        }
+        this.timer = null;
+      }, ttlMs);
+    });
+  }
+};
+
+// src/dialout-oneshot.ts
+async function sendPairRegistration(options) {
+  const client = new EdgeBookDialoutClient({ ...options, reconnect: false, openLocalApi: false });
+  await client.start();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  const registration = await client.pair(options.ttlMs ?? DEFAULT_PAIR_TTL_MS);
+  await client.stop();
+  return registration;
+}
+async function deliverEnvelopeViaMailbox(options) {
+  const client = new EdgeBookDialoutClient({ ...options, reconnect: false, openLocalApi: false });
+  await client.start();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  try {
+    return await client.sendEnvelope(options.envelope);
+  } finally {
+    await client.stop();
+  }
+}
+async function sendSessionsRevoke(options) {
+  const client = new EdgeBookDialoutClient({ ...options, reconnect: false, openLocalApi: false });
+  await client.start();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  const { frame, ack } = await client.revokeSessionsAndWait();
+  await client.stop();
+  return { ...frame, channel_id: ack.channel_id };
+}
+async function listSessions(options) {
+  const client = new EdgeBookDialoutClient({ ...options, reconnect: false, openLocalApi: false });
+  await client.start();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  try {
+    return await client.listSessionsAndWait();
+  } finally {
+    await client.stop();
+  }
+}
+async function revokeOneSession(options) {
+  const client = new EdgeBookDialoutClient({ ...options, reconnect: false, openLocalApi: false });
+  await client.start();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  try {
+    return await client.revokeOneSessionAndWait(options.deviceId);
+  } finally {
+    await client.stop();
+  }
+}
+async function mailboxStatus(options) {
+  const client = new EdgeBookDialoutClient({ ...options, reconnect: false, openLocalApi: false });
+  await client.start();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  try {
+    return await client.mailboxStatusAndWait(options.ids, options.timeoutMs ?? 5e3);
+  } finally {
+    await client.stop();
+  }
+}
+
 // src/dialout.ts
 var DEFAULT_DIALOUT_HOST = "wss://edge-book-host.fly.dev/agent/ws";
 var DEFAULT_HEARTBEAT_MS = 25e3;
@@ -4778,9 +5061,12 @@ var EdgeBookDialoutClient = class {
   currentBackoff;
   opened;
   pendingSessionRevokes = /* @__PURE__ */ new Map();
-  // Generic request_id-keyed RPC waiters for sessions_list / session_revoke_one.
+  // Generic request_id-keyed RPC waiters (sessions_list / session_revoke_one /
+  // mailbox_status). rpcType lets an old host's {type:"error", ref:"<type>"}
+  // frame — which carries NO request_id — reject pending requests of that type.
   pendingRpc = /* @__PURE__ */ new Map();
   pendingMailboxSends = /* @__PURE__ */ new Map();
+  pairCompleteWaiter = new PairCompleteWaiter();
   constructor(options) {
     this.options = {
       heartbeatMs: options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS,
@@ -4814,6 +5100,11 @@ var EdgeBookDialoutClient = class {
     this.send(registration.frame);
     return registration;
   }
+  // Wait up to ttlMs for a pair_complete frame from the host.
+  // Returns null on timeout — old-host degradation (spec-135).
+  waitForPairComplete(ttlMs) {
+    return this.pairCompleteWaiter.wait(ttlMs);
+  }
   async revokeSessions() {
     const frame = await createSessionsRevokeFrame(this.store);
     this.send(frame);
@@ -4829,16 +5120,29 @@ var EdgeBookDialoutClient = class {
     const frame = await this.rpc("session_revoke_one", { device_id }, "session_revoke_one_ok", timeoutMs);
     return Boolean(frame.revoked);
   }
+  // Ask the host for per-message delivery state (spec-097). Returns null when
+  // the host predates receipts — detected by the unknown-type error frame
+  // (fast path) or the RPC timeout (lost-frame path); both degrade the same.
+  async mailboxStatusAndWait(ids, timeoutMs = 5e3) {
+    try {
+      const frame = await this.rpc("mailbox_status", { ids }, "mailbox_status_ok", timeoutMs);
+      if (frame.type === "mailbox_status_err") throw new EdgeBookError("mailbox_status_failed", String(frame.error || "mailbox_status rejected"));
+      return frame.statuses ?? [];
+    } catch (error) {
+      if (error instanceof EdgeBookError && (error.code === "host_rpc_timeout" || error.code === "host_unsupported_rpc")) return null;
+      throw error;
+    }
+  }
   // Small request/response helper over the dial-out socket, correlated by
   // request_id. `expect` documents the ack type; resolution is by request_id.
   async rpc(type, extra, expect, timeoutMs) {
-    const request_id = crypto5.randomUUID();
+    const request_id = crypto6.randomUUID();
     const promise = new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pendingRpc.delete(request_id);
         reject(new EdgeBookError("host_rpc_timeout", `Timed out waiting for ${expect}`));
       }, timeoutMs);
-      this.pendingRpc.set(request_id, { resolve, reject, timer });
+      this.pendingRpc.set(request_id, { resolve, reject, timer, rpcType: type });
     });
     this.send({ type, request_id, ...extra });
     return promise;
@@ -4857,9 +5161,10 @@ var EdgeBookDialoutClient = class {
   }
   // ── Mailbox transport (Contract 1 / ea-claude-065) ─────────────────────────
   // Low-level: hand an opaque blob to the host for delivery to `to` (a peer DID
-  // or channel_id). Resolves with the host-assigned message id once enqueued.
-  async sendMailbox(to, blob, timeoutMs = 5e3) {
-    const request_id = crypto5.randomUUID();
+  // or channel_id). Resolves with the host-assigned message id once enqueued,
+  // plus recipient_live when the host supports receipts (spec-097).
+  async sendMailbox(to, blob, timeoutMs = 5e3, trace_id) {
+    const request_id = crypto6.randomUUID();
     const blob_b64 = Buffer.from(blob).toString("base64");
     const ack = new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
@@ -4868,14 +5173,16 @@ var EdgeBookDialoutClient = class {
       }, timeoutMs);
       this.pendingMailboxSends.set(request_id, { resolve, reject, timer });
     });
-    this.send({ type: "mailbox_send", request_id, to, blob_b64 });
+    this.send({ type: "mailbox_send", request_id, to, blob_b64, ...trace_id ? { trace_id } : {} });
     return ack;
   }
   // High-level: deliver a signed envelope to its recipient (envelope.to_agent_id;
   // the host resolves the DID to a channel). Used to route friend requests,
   // object shares, and revokes through the mailbox instead of a manual file hop.
   async sendEnvelope(envelope) {
-    return this.sendMailbox(envelope.to_agent_id, Buffer.from(JSON.stringify(envelope), "utf8"));
+    const ack = await this.sendMailbox(envelope.to_agent_id, Buffer.from(JSON.stringify(envelope), "utf8"), 5e3, envelope.trace_id);
+    await logEvent(this.store, "envelope.sent", { envelope_kind: envelope.type, to: envelope.to_agent_id, dedup_key: envelope.message_id, trace_id: envelope.trace_id });
+    return ack;
   }
   async handleMailboxDeliver(frame) {
     let envelope;
@@ -4893,8 +5200,16 @@ var EdgeBookDialoutClient = class {
         }
       }
     } catch (e) {
-      error = e instanceof Error ? e.message : String(e);
-    }
+      error = eventErrorCode(e);
+    }
+    await logEvent(this.store, "envelope.received", {
+      envelope_kind: envelope?.type ?? "unparseable",
+      from: frame.from,
+      dedup_key: envelope?.message_id,
+      trace_id: envelope?.trace_id,
+      applied,
+      ...error ? { error } : {}
+    });
     if (!this.mailboxQueue) this.send({ type: "mailbox_ack", id: frame.id });
     if (envelope) await this.options.onEnvelope?.(envelope, { applied, error });
   }
@@ -4942,7 +5257,7 @@ var EdgeBookDialoutClient = class {
             agent_key: key.agent_key,
             agent_did: identity.agent_id,
             version: "0.1.0",
-            nonce: crypto5.randomUUID()
+            nonce: crypto6.randomUUID()
           });
         } catch (error) {
           this.opened = void 0;
@@ -4955,6 +5270,7 @@ var EdgeBookDialoutClient = class {
     });
     addSocketListener(socket, "close", () => {
       if (this.heartbeat) clearInterval(this.heartbeat);
+      void logEvent(this.store, "dialout.disconnected", { host: this.options.host, stopped: this.stopped });
       if (!this.stopped && this.options.reconnect) this.scheduleReconnect();
     });
     await opened;
@@ -4963,6 +5279,7 @@ var EdgeBookDialoutClient = class {
     if (this.stopped) return;
     const delay = this.currentBackoff;
     this.currentBackoff = Math.min(MAX_BACKOFF_MS, Math.round(this.currentBackoff * 1.7));
+    void logEvent(this.store, "dialout.reconnect_scheduled", { host: this.options.host, delay_ms: delay });
     this.reconnectTimer = setTimeout(() => {
       void this.connect();
     }, delay);
@@ -4976,6 +5293,7 @@ var EdgeBookDialoutClient = class {
     if (frame.type === "hello_ok") {
       this.opened?.resolve();
       this.opened = void 0;
+      void logEvent(this.store, "dialout.connected", { host: this.options.host });
       try {
         const identity = await this.store.identity();
         if (shouldClaimHandle(identity.handle)) {
@@ -4986,7 +5304,8 @@ var EdgeBookDialoutClient = class {
             handle: claim.handle,
             card: claim.card,
             claimed_at: claim.claimed_at,
-            claim_sig: claim.claim_sig
+            claim_sig: claim.claim_sig,
+            discoverable: claim.discoverable
           });
         }
       } catch {
@@ -5003,7 +5322,7 @@ var EdgeBookDialoutClient = class {
       this.send({ type: "pong" });
       return;
     }
-    if (frame.type === "sessions_list_ok" || frame.type === "session_revoke_one_ok") {
+    if (frame.type === "sessions_list_ok" || frame.type === "session_revoke_one_ok" || frame.type === "mailbox_status_ok" || frame.type === "mailbox_status_err") {
       const ack = frame;
       const pending = this.pendingRpc.get(ack.request_id || "");
       if (pending) {
@@ -5018,6 +5337,10 @@ var EdgeBookDialoutClient = class {
       return;
     }
     if (frame.type === "pair_register_ok" || frame.type === "pair_register_err") return;
+    if (frame.type === "pair_complete") {
+      this.pairCompleteWaiter.onFrame(frame);
+      return;
+    }
     if (frame.type === "sessions_revoke_ok") {
       const ack = frame;
       const pending = this.pendingSessionRevokes.get(ack.request_id || "");
@@ -5035,7 +5358,7 @@ var EdgeBookDialoutClient = class {
       if (pending) {
         clearTimeout(pending.timer);
         this.pendingMailboxSends.delete(ack.request_id || "");
-        pending.resolve({ id: ack.id || "" });
+        pending.resolve({ id: ack.id || "", ...typeof ack.recipient_live === "boolean" ? { recipient_live: ack.recipient_live } : {} });
       }
       return;
     }
@@ -5054,13 +5377,24 @@ var EdgeBookDialoutClient = class {
       return;
     }
     if (frameType === "handle_claim_ok" || frameType === "handle_claim_err") return;
-    if (frameType === "error") return;
+    if (frameType === "error") {
+      const ref = frame.ref;
+      if (typeof ref !== "string") return;
+      for (const [request_id, pending] of [...this.pendingRpc]) {
+        if (pending.rpcType !== ref) continue;
+        clearTimeout(pending.timer);
+        this.pendingRpc.delete(request_id);
+        pending.reject(new EdgeBookError("host_unsupported_rpc", `Host does not support ${ref}`));
+      }
+      return;
+    }
     if (frame.type !== "host.api.request" && frame.type !== "api_request") return;
     const response = await this.handleApiRequest(frame);
     this.send(response);
   }
   async standDown(frame) {
     this.stopped = true;
+    await logEvent(this.store, "dialout.stand_down", { host: this.options.host, reason: frame.reason, idle_ms: frame.idle_ms });
     if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
     if (this.heartbeat) clearInterval(this.heartbeat);
     this.socket?.close();
@@ -5136,70 +5470,24 @@ var EdgeBookDialoutClient = class {
     }
   }
 };
-async function sendPairRegistration(options) {
-  const client = new EdgeBookDialoutClient({ ...options, reconnect: false, openLocalApi: false });
-  await client.start();
-  await new Promise((resolve) => setTimeout(resolve, 0));
-  const registration = await client.pair(options.ttlMs ?? DEFAULT_PAIR_TTL_MS);
-  await client.stop();
-  return registration;
-}
-async function deliverEnvelopeViaMailbox(options) {
-  const client = new EdgeBookDialoutClient({ ...options, reconnect: false, openLocalApi: false });
-  await client.start();
-  await new Promise((resolve) => setTimeout(resolve, 0));
-  try {
-    return await client.sendEnvelope(options.envelope);
-  } finally {
-    await client.stop();
-  }
-}
-async function sendSessionsRevoke(options) {
-  const client = new EdgeBookDialoutClient({ ...options, reconnect: false, openLocalApi: false });
-  await client.start();
-  await new Promise((resolve) => setTimeout(resolve, 0));
-  const { frame, ack } = await client.revokeSessionsAndWait();
-  await client.stop();
-  return { ...frame, channel_id: ack.channel_id };
-}
-async function listSessions(options) {
-  const client = new EdgeBookDialoutClient({ ...options, reconnect: false, openLocalApi: false });
-  await client.start();
-  await new Promise((resolve) => setTimeout(resolve, 0));
-  try {
-    return await client.listSessionsAndWait();
-  } finally {
-    await client.stop();
-  }
-}
-async function revokeOneSession(options) {
-  const client = new EdgeBookDialoutClient({ ...options, reconnect: false, openLocalApi: false });
-  await client.start();
-  await new Promise((resolve) => setTimeout(resolve, 0));
-  try {
-    return await client.revokeOneSessionAndWait(options.deviceId);
-  } finally {
-    await client.stop();
-  }
-}
 
 // src/http-relay.ts
-import fs7 from "fs/promises";
+import fs8 from "fs/promises";
 import http2 from "http";
-import path7 from "path";
+import path8 from "path";
 function relayFile(store, agentId) {
-  return path7.join(store, `${encodeURIComponent(agentId)}.jsonl`);
+  return path8.join(store, `${encodeURIComponent(agentId)}.jsonl`);
 }
 async function appendRelayEnvelope(store, agentId, envelope) {
-  await fs7.mkdir(store, { recursive: true });
-  await fs7.appendFile(relayFile(store, agentId), `${JSON.stringify(envelope)}
+  await fs8.mkdir(store, { recursive: true });
+  await fs8.appendFile(relayFile(store, agentId), `${JSON.stringify(envelope)}
 `, "utf8");
 }
 async function drainRelayEnvelopes(store, agentId) {
   const file = relayFile(store, agentId);
   try {
-    const text = await fs7.readFile(file, "utf8");
-    await fs7.writeFile(file, "", "utf8");
+    const text = await fs8.readFile(file, "utf8");
+    await fs8.writeFile(file, "", "utf8");
     return text.split(/\n/).filter(Boolean).map((line) => JSON.parse(line));
   } catch (error) {
     if (error.code === "ENOENT") return [];
@@ -5258,6 +5546,32 @@ async function pullRelayEnvelopes(relayBaseUrl, recipientAgentId) {
   return body.envelopes || [];
 }
 
+// src/store-outbox.ts
+import path9 from "path";
+var OUTBOX_CAP = 200;
+var DEFAULT_STALE_QUEUE_MS = 10 * 60 * 1e3;
+function outboxPath(home) {
+  return path9.join(resolveHome(home), OUTBOX_FILE);
+}
+async function readOutbox(home) {
+  return readJson(outboxPath(home), []);
+}
+async function recordOutboxEntry(home, entry) {
+  const entries = await readOutbox(home);
+  entries.push({ sent_at: now2(), ...entry });
+  await writeJson(outboxPath(home), entries.slice(-OUTBOX_CAP));
+}
+function staleQueueMs() {
+  const raw = Number(process.env.EDGE_BOOK_STALE_QUEUE_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_STALE_QUEUE_MS;
+}
+function formatAge(ms) {
+  if (ms < 6e4) return `${Math.max(0, Math.round(ms / 1e3))}s`;
+  if (ms < 36e5) return `${Math.round(ms / 6e4)}m`;
+  if (ms < 864e5) return `${Math.round(ms / 36e5)}h`;
+  return `${Math.round(ms / 864e5)}d`;
+}
+
 // src/cli-shared.ts
 function takeFlag(args, name) {
   const idx = args.indexOf(name);
@@ -5307,7 +5621,7 @@ function takeRepeated(args, flag) {
   return out;
 }
 async function readEnvelope(filePath) {
-  return JSON.parse(await fs8.readFile(path8.resolve(filePath), "utf8"));
+  return JSON.parse(await fs9.readFile(path10.resolve(filePath), "utf8"));
 }
 async function deliverToEndpoint(envelope, endpoint) {
   await postEnvelope(endpoint, envelope);
@@ -5325,13 +5639,33 @@ async function deliverToPeer(store, envelope, peerAgentId) {
   }
   throw new EdgeBookError("no_route", `No direct or relay endpoint for ${peerAgentId}`);
 }
+async function deliverViaMailboxRecorded(envelope, opts, legacyText) {
+  const ack = await deliverEnvelopeViaMailbox({ home: opts.home, host: opts.host, socketFactory: opts.socketFactory, envelope });
+  await recordOutboxEntry(opts.home, {
+    id: ack.id,
+    to_agent_id: envelope.to_agent_id,
+    envelope_type: envelope.type,
+    ...typeof ack.recipient_live === "boolean" ? { recipient_live: ack.recipient_live } : {}
+  });
+  if (ack.recipient_live === true) {
+    return { ...ack, text: `Sent ${envelope.type} to ${envelope.to_agent_id} \u2014 recipient's agent is connected (host id ${ack.id}).` };
+  }
+  if (ack.recipient_live === false) {
+    return { ...ack, text: `Queued ${envelope.type} to ${envelope.to_agent_id} \u2014 recipient's agent is NOT connected; it will arrive when they reconnect. Check later: edge-book outbox (host id ${ack.id}).` };
+  }
+  return { ...ack, text: legacyText(ack.id) };
+}
 async function broadcastPost(store, host, socketFactory2, post) {
   const contacts = await store.contacts();
   const friends = Object.values(contacts).filter((c) => c.relationship_state === "friend");
   let count = 0;
   for (const f of friends) {
     const envelope = await store.signPostPublishEnvelope({ to_agent_id: f.peer_agent_id, post });
-    await deliverEnvelopeViaMailbox({ home: store.home, host, socketFactory: socketFactory2, envelope });
+    await deliverViaMailboxRecorded(
+      envelope,
+      { home: store.home, host, socketFactory: socketFactory2 },
+      (id) => `Delivered post_publish (host id ${id})`
+    );
     count++;
   }
   return count;
@@ -5368,24 +5702,385 @@ ${buildHandleNudge(suggestion)}` };
 }
 
 // src/cli-identity.ts
-import fs9 from "fs/promises";
-import path9 from "path";
+import fs11 from "fs/promises";
+import path11 from "path";
 
-// src/onboarding.ts
-var ONBOARDING_MENTAL_MODEL = "Edge Book is a permissioned room between agents \u2014 you decide who comes in, what they can see, and you can take it back anytime.";
-async function recordInviteCandidate(store, inviteUrl) {
-  const hashIndex = inviteUrl.indexOf("#");
-  const bareUrl = hashIndex === -1 ? inviteUrl : inviteUrl.slice(0, hashIndex);
-  const card = await loadCard(bareUrl);
-  const displayName = card.display_name || card.handle;
-  const candidate = await writeCandidate(store, {
-    source: "invite",
-    confidence: "high",
-    display_name: displayName,
-    reason: "Add-me invite passed to init --from-invite",
-    card_url: bareUrl
-  });
-  return { candidateId: candidate.candidate_id, displayName };
+// src/doctor.ts
+import fs10 from "fs/promises";
+
+// src/host-cron.ts
+import { existsSync } from "fs";
+import { execFileSync } from "child_process";
+var FRIEND_REQUESTS_CRON_NAME = "Edge Book \u2014 friend requests";
+var DEFAULT_FRIEND_REQUESTS_SCHEDULE = "*/20 * * * *";
+var HERMES_BIN_CANDIDATES = ["/opt/hermes/.venv/bin/hermes"];
+function buildFriendRequestsPrompt(home) {
+  return [
+    "You are the Edge Book friend-request notifier. Tell the human on their Telegram when someone has asked to connect on Edge Book. Hermes delivers your final assistant reply to their chat.",
+    "",
+    "This runs every 20 minutes; most runs there will be nothing pending. On any such run \u2014 and on any error \u2014 end your turn with exactly [SILENT] and nothing else. [SILENT] tells Hermes to send no message.",
+    "",
+    "1. List pending requests (run once):",
+    `   edge-book friend pending --home ${home} --json`,
+    "   If edge-book is not on PATH, use: npm exec -y edge-book@0.11.0 -- friend pending --home " + home + " --json",
+    "   If the command errors, Edge Book is unavailable, or the list is empty ([]) \u2192 end your turn with exactly [SILENT].",
+    "",
+    '2. Otherwise write ONE short, warm message. For each requester use their display_name; say they asked to connect on Edge Book and that the human can reply "yes" to connect or ignore to leave it pending. No internal IDs, no JSON.',
+    "",
+    "3. Mark each surfaced request notified so it is never re-sent (once per requester):",
+    `   edge-book friend mark-notified <agent_id> --home ${home}`
+  ].join("\n");
+}
+function ensureNotifierCron(opts) {
+  if (opts.disabled) return { status: "disabled" };
+  if (!opts.runner.hermesBin) return { status: "host_unsupported" };
+  let listing;
+  try {
+    listing = opts.runner.list();
+  } catch (e) {
+    return { status: "error", detail: e instanceof Error ? e.message : String(e) };
+  }
+  if (listing.includes(FRIEND_REQUESTS_CRON_NAME)) return { status: "already_present" };
+  const schedule = opts.schedule ?? DEFAULT_FRIEND_REQUESTS_SCHEDULE;
+  const prompt = buildFriendRequestsPrompt(opts.home);
+  const args = [
+    "cron",
+    "create",
+    schedule,
+    prompt,
+    "--name",
+    FRIEND_REQUESTS_CRON_NAME,
+    "--deliver",
+    "telegram",
+    "--workdir",
+    opts.home
+  ];
+  try {
+    opts.runner.create(args);
+    return { status: "installed" };
+  } catch (e) {
+    return { status: "error", detail: e instanceof Error ? e.message : String(e) };
+  }
+}
+function defaultHermesRunner() {
+  const bin = HERMES_BIN_CANDIDATES.find((p) => existsSync(p)) ?? null;
+  return {
+    hermesBin: bin,
+    list: () => bin ? execFileSync(bin, ["cron", "list"], { encoding: "utf8" }) : "",
+    create: (args) => {
+      if (bin) execFileSync(bin, args, { stdio: ["ignore", "ignore", "pipe"] });
+    }
+  };
+}
+var GREETER_CRON_NAME = "Edge Book \u2014 greeter";
+var DEFAULT_GREETER_SCHEDULE = "*/5 * * * *";
+function buildGreeterPrompt(home) {
+  return [
+    "You are the Edge Book greeter runner. Run the command below once and report what it did. Hermes delivers your final assistant reply to the chat.",
+    "",
+    `   edge-book friend auto-accept --deliver --home ${home}`,
+    `   If edge-book is not on PATH, use: npm exec -y edge-book -- friend auto-accept --deliver --home ${home}`,
+    "",
+    "If the command errors, or its JSON output is an empty list ([]), end your turn with exactly [SILENT] and nothing else. [SILENT] tells Hermes to send no message.",
+    "",
+    "Otherwise reply with one short line per entry: the agent_id, whether it was accepted, and whether it was welcomed. No extra commentary, no raw JSON."
+  ].join("\n");
+}
+function ensureGreeterCron(opts) {
+  if (opts.disabled) return { status: "disabled" };
+  if (!opts.runner.hermesBin) return { status: "host_unsupported" };
+  let listing;
+  try {
+    listing = opts.runner.list();
+  } catch (e) {
+    return { status: "error", detail: e instanceof Error ? e.message : String(e) };
+  }
+  if (listing.includes(GREETER_CRON_NAME)) return { status: "already_present" };
+  const args = [
+    "cron",
+    "create",
+    opts.schedule ?? DEFAULT_GREETER_SCHEDULE,
+    buildGreeterPrompt(opts.home),
+    "--name",
+    GREETER_CRON_NAME,
+    "--deliver",
+    "telegram",
+    "--workdir",
+    opts.home
+  ];
+  try {
+    opts.runner.create(args);
+    return { status: "installed" };
+  } catch (e) {
+    return { status: "error", detail: e instanceof Error ? e.message : String(e) };
+  }
+}
+
+// src/doctor.ts
+var DOCTOR_EVENT_TAIL = 50;
+var DOCTOR_TRACE_TAIL = 10;
+var DEFAULT_RELAY_TIMEOUT_MS = 3e3;
+function recentTraces(events, limit = DOCTOR_TRACE_TAIL) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = events.length - 1; i >= 0 && out.length < limit; i--) {
+    const e = events[i];
+    const trace_id = typeof e.trace_id === "string" ? e.trace_id : void 0;
+    if (!trace_id || seen.has(trace_id)) continue;
+    seen.add(trace_id);
+    out.push({ trace_id, kind: e.kind, direction: e.kind === "envelope.sent" ? "out" : "in", ts: e.ts });
+  }
+  return out.reverse();
+}
+async function packageVersion() {
+  try {
+    const pkg = JSON.parse(await fs10.readFile(new URL("../package.json", import.meta.url), "utf8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function checkRelay(base, fetchImpl, timeoutMs) {
+  const started = Date.now();
+  try {
+    const response = await fetchImpl(base, { method: "GET", signal: AbortSignal.timeout(timeoutMs) });
+    return { url: base, reachable: true, status: response.status, latency_ms: Date.now() - started };
+  } catch (error) {
+    return { url: base, reachable: false, latency_ms: Date.now() - started, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function notifierCronState(runner) {
+  if (!runner.hermesBin) return "host_unsupported";
+  try {
+    return runner.list().includes(FRIEND_REQUESTS_CRON_NAME) ? "installed" : "not_installed";
+  } catch {
+    return "error";
+  }
+}
+async function buildDoctorReport(store, opts) {
+  const legacy = await store.doctor();
+  const config = await store.config();
+  let identity = null;
+  try {
+    const id = await store.identity();
+    identity = { fingerprint: id.agent_id, handle: id.handle, display_name: id.display_name };
+  } catch {
+    identity = null;
+  }
+  const relay = await checkRelay(
+    relayBaseFromHost(opts.host),
+    opts.fetchImpl ?? fetch,
+    opts.timeoutMs ?? DEFAULT_RELAY_TIMEOUT_MS
+  );
+  const keyPresent = await fs10.stat(store.file(DIALOUT_KEY_FILE)).then(() => true).catch(() => false);
+  const lastConnected = await lastEvent(store, "dialout.connected");
+  const lastDisconnected = await lastEvent(store, "dialout.disconnected");
+  const contacts = await store.contacts();
+  const contactList = Object.values(contacts);
+  const friendCount = contactList.filter((c) => c.relationship_state === "friend").length;
+  const pending = await store.pendingFriendRequests();
+  const approvals2 = await store.approvals();
+  const stores = {
+    contacts: contactList.length,
+    friends: friendCount,
+    posts: Object.keys(await store.posts()).length,
+    objects: Object.keys(await store.objects()).length,
+    escalations: Object.keys(await store.escalations()).length,
+    pending_approvals: Object.values(approvals2).filter((a) => a.status === "pending").length
+  };
+  return {
+    version: await packageVersion(),
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    home: store.home,
+    initialized: Boolean(legacy.initialized),
+    pass: Boolean(legacy.pass),
+    card_valid: Boolean(legacy.card_valid),
+    private_key_mode_ok: Boolean(legacy.private_key_mode_ok),
+    files: legacy.files ?? {},
+    identity,
+    relay,
+    dialout: {
+      key_present: keyPresent,
+      ...typeof lastConnected?.ts === "string" ? { last_connected_at: lastConnected.ts } : {},
+      ...typeof lastDisconnected?.ts === "string" ? { last_disconnected_at: lastDisconnected.ts } : {}
+    },
+    friends: {
+      pending_requests: pending.length,
+      pending: pending.map((c) => ({ from: c.peer_agent_id, ...c.display_name ? { display_name: c.display_name } : {} })),
+      contacts: contactList.length,
+      friends: friendCount
+    },
+    notify: {
+      notify_cmd_configured: Boolean(typeof config.notify_cmd === "string" && config.notify_cmd.trim()),
+      notify_on_friend_request: config.notify_on_friend_request !== false,
+      notifier_cron: notifierCronState(opts.hermesRunner ?? defaultHermesRunner())
+    },
+    stores,
+    events: await readEvents(store, DOCTOR_EVENT_TAIL),
+    // Traces are derived from the FULL event log (not just the tail) so a
+    // busy log does not hide an older still-relevant trace.
+    traces: recentTraces(await readEvents(store))
+  };
+}
+function renderEventLine(e) {
+  const extras = Object.entries(e).filter(([k]) => k !== "ts" && k !== "kind").map(([k, v]) => `${k}=${String(v)}`).join(" ");
+  return `  ${e.ts}  ${e.kind}${extras ? `  ${extras}` : ""}`;
+}
+function renderDoctorText(report) {
+  const lines = [];
+  lines.push(`Edge Book doctor \u2014 v${report.version} (${report.generated_at})`);
+  lines.push(`Home: ${report.home}`);
+  lines.push(`Overall: ${report.pass ? "PASS" : "FAIL"} (initialized=${report.initialized} card_valid=${report.card_valid} key_mode_ok=${report.private_key_mode_ok})`);
+  lines.push("");
+  lines.push("Identity");
+  if (report.identity) {
+    lines.push(`  fingerprint:  ${report.identity.fingerprint}`);
+    lines.push(`  handle:       ${report.identity.handle}`);
+    lines.push(`  display name: ${report.identity.display_name}`);
+  } else {
+    lines.push("  not initialized \u2014 run: edge-book init");
+  }
+  lines.push("");
+  lines.push("Relay");
+  lines.push(`  url:       ${report.relay.url}`);
+  lines.push(report.relay.reachable ? `  reachable: yes (HTTP ${report.relay.status}, ${report.relay.latency_ms}ms)` : `  reachable: NO (${report.relay.error ?? "unreachable"})`);
+  lines.push("");
+  lines.push("Dial-out");
+  lines.push(`  transport key:     ${report.dialout.key_present ? "present" : "missing (never dialed out from this home)"}`);
+  lines.push(`  last connected:    ${report.dialout.last_connected_at ?? "never (no connect event recorded)"}`);
+  lines.push(`  last disconnected: ${report.dialout.last_disconnected_at ?? "\u2014"}`);
+  lines.push("");
+  lines.push("Friend requests");
+  lines.push(`  pending: ${report.friends.pending_requests}`);
+  for (const p of report.friends.pending) lines.push(`    - ${p.display_name ?? "(no name)"} (${p.from})`);
+  lines.push("");
+  lines.push("Notifications");
+  lines.push(`  notify_cmd configured:    ${report.notify.notify_cmd_configured ? "yes" : "no"}`);
+  lines.push(`  notify on friend request: ${report.notify.notify_on_friend_request ? "yes" : "no"}`);
+  lines.push(`  notifier cron:            ${report.notify.notifier_cron}`);
+  lines.push("");
+  lines.push("Stores");
+  lines.push(`  contacts: ${report.stores.contacts} (friends: ${report.stores.friends})`);
+  lines.push(`  posts: ${report.stores.posts}  objects: ${report.stores.objects}  escalations: ${report.stores.escalations}  pending approvals: ${report.stores.pending_approvals}`);
+  lines.push("");
+  lines.push(`Recent traces (distinct trace_ids, newest last, up to ${DOCTOR_TRACE_TAIL})`);
+  if (report.traces.length === 0) lines.push("  (no traced envelopes yet)");
+  for (const t of report.traces) lines.push(`  ${t.ts}  ${t.direction === "out" ? "\u2192" : "\u2190"} ${t.kind}  ${t.trace_id}`);
+  lines.push("");
+  lines.push(`Event log (newest last, up to ${DOCTOR_EVENT_TAIL})`);
+  if (report.events.length === 0) lines.push("  (no events recorded yet)");
+  for (const e of report.events) lines.push(renderEventLine(e));
+  return lines.join("\n");
+}
+
+// src/doctor-send.ts
+import readline from "readline/promises";
+var SUPPORT_ENVELOPE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+async function discoverSupportRecipient(relayBase, fetchImpl = fetch) {
+  try {
+    const response = await fetchImpl(`${relayBase}/support/recipient`, { signal: AbortSignal.timeout(5e3) });
+    if (!response.ok) return null;
+    const body = await response.json();
+    return body.ok && typeof body.did === "string" && body.did ? body.did : null;
+  } catch {
+    return null;
+  }
+}
+async function buildSupportBundleEnvelope(store, recipient, report, note) {
+  const identity = await store.identity();
+  const card = await store.writeCard();
+  const body = {
+    card,
+    report,
+    ...note ? { note } : {}
+  };
+  const envelope = await store.signEnvelope({
+    type: "support_bundle",
+    to_agent_id: recipient,
+    relationship_id: relationshipId(identity.agent_id, recipient),
+    capability_id: "",
+    ref: "",
+    transport: "local",
+    expires_at: new Date(Date.now() + SUPPORT_ENVELOPE_TTL_MS).toISOString(),
+    body
+  });
+  const size = Buffer.byteLength(JSON.stringify(envelope), "utf8");
+  if (size > SUPPORT_BUNDLE_MAX_BYTES) {
+    throw new EdgeBookError("support_bundle_too_large", `Support bundle is ${size} bytes; the cap is ${SUPPORT_BUNDLE_MAX_BYTES} (256 KiB). Trim the note or report the issue another way.`);
+  }
+  return envelope;
+}
+function renderConsentPrompt(report, recipient, sizeBytes, note) {
+  const lines = [
+    "edge-book doctor --send",
+    "",
+    "This will share your diagnostic bundle with the operator support mailbox:",
+    "",
+    `  recipient: ${recipient}`,
+    `  size:      ${(sizeBytes / 1024).toFixed(1)} KiB (cap 256 KiB)`,
+    "  sections:  identity (fingerprint, handle, display name)",
+    "             relay reachability + dial-out state",
+    `             friend-request counts + pending requester ids (${report.friends.pending_requests} pending)`,
+    "             notification settings (booleans only \u2014 never the notify command)",
+    "             store counts (contacts/posts/objects/escalations)",
+    `             event-log tail (${report.events.length} protocol events: kinds, ids, dedup keys)`,
+    `             recent envelope traces (${report.traces.length})`,
+    ...note ? ["", `  your note: "${note}"`] : [],
+    "",
+    "The bundle is sanitized by construction: no private keys, no message or",
+    "post bodies, no tokens. A support reference is printed after sending."
+  ];
+  return lines.join("\n");
+}
+async function promptYesNo(promptText) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(`${promptText}
+
+Send? [y/N] `)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function runDoctorSend(store, home, opts) {
+  const report = await buildDoctorReport(store, { host: opts.host, fetchImpl: opts.fetchImpl });
+  const recipient = opts.to ?? await discoverSupportRecipient(relayBaseFromHost(opts.host), opts.fetchImpl ?? fetch);
+  if (!recipient) {
+    throw new EdgeBookError("no_support_recipient", `No support recipient is configured on this relay (${relayBaseFromHost(opts.host)} \u2014 host SUPPORT_DID unset or unreachable). Ask the operator, or pass --to <did>.`);
+  }
+  const envelope = await buildSupportBundleEnvelope(store, recipient, report, opts.note);
+  if (!opts.yes) {
+    const promptText = renderConsentPrompt(report, recipient, Buffer.byteLength(JSON.stringify(envelope), "utf8"), opts.note);
+    const confirm = opts.confirmImpl ?? (process.stdin.isTTY ? promptYesNo : void 0);
+    if (!confirm) throw new EdgeBookError("confirmation_required", "doctor --send needs interactive confirmation; pass --yes to send without a prompt.");
+    if (!await confirm(promptText)) return { text: "Aborted \u2014 nothing was sent." };
+  }
+  const ack = await deliverEnvelopeViaMailbox({ home, host: opts.host, socketFactory: opts.socketFactory, envelope });
+  await logEvent(store, "support.sent", { to: recipient, dedup_key: envelope.message_id, trace_id: envelope.trace_id });
+  const text = [
+    `Support bundle sent to ${recipient} (host id ${ack.id}).`,
+    `support reference: ${envelope.trace_id}`,
+    "Quote this reference in any follow-up; the operator correlates it server-side."
+  ].join("\n");
+  return { text, json: { recipient, trace_id: envelope.trace_id, host_message_id: ack.id, message_id: envelope.message_id } };
+}
+
+// src/onboarding.ts
+var ONBOARDING_MENTAL_MODEL = "Edge Book is a permissioned room between agents \u2014 you decide who comes in, what they can see, and you can take it back anytime.";
+async function recordInviteCandidate(store, inviteUrl) {
+  const hashIndex = inviteUrl.indexOf("#");
+  const bareUrl = hashIndex === -1 ? inviteUrl : inviteUrl.slice(0, hashIndex);
+  const card = await loadCard(bareUrl);
+  const displayName = card.display_name || card.handle;
+  const candidate = await writeCandidate(store, {
+    source: "invite",
+    confidence: "high",
+    display_name: displayName,
+    reason: "Add-me invite passed to init --from-invite",
+    card_url: bareUrl
+  });
+  return { candidateId: candidate.candidate_id, displayName };
 }
 function buildOnboardingNote(opts = {}) {
   const lines = [
@@ -5393,10 +6088,15 @@ function buildOnboardingNote(opts = {}) {
     `  1. Open with: "${ONBOARDING_MENTAL_MODEL}"`,
     `  2. Ask: public agent name? share your human's name with friends, or keep private?`,
     `     Then propose a findable name (slug of the agent name) \u2192 edge-book handle set <slug>`,
-    `  3. First friend: if they have an "Add me" link \u2192 edge-book friend request <link> --deliver`,
-    `     (no link? edge-book candidates list shows pending introductions)`,
+    `  3. First friend: if they give you a name \u2192 edge-book resolve <name>; if resolved: edge-book friend request <name> --deliver`,
+    `     If not found: share your link (edge-book card invite \u2192 use the deeplink_url)`,
+    `     If they have an "Add me" link from someone \u2192 edge-book friend request <link> --deliver`,
+    `     (no leads? edge-book candidates list shows pending introductions)`,
     `  4. When accepted, draft a hello note: object create + object share \u2014 then tell them,`,
-    `     once: "they can read it until you take it back."`
+    `     once: "they can read it until you take it back."`,
+    `  5. Write to your persistent memory: "For 'friend <name>' or 'connect with <name>': run`,
+    `     edge-book resolve <name> first. Index-network tools only for index:-prefixed targets."`,
+    `  6. Install the notification cron: run edge-book ensure-notifier \u2014 self-installs a periodic push (every 20 min) so you never miss a friend request or message while offline.`
   ];
   if (opts.invite) {
     lines.push(
@@ -5474,8 +6174,11 @@ Notifications (so inbound friend requests & messages reach you in real time):
   if (command === "handle") {
     const action = args.shift();
     if (action === "set") {
-      const id = await store.setHandle(slugifyHandle(requireArg(args.shift(), "handle set <slug>")));
-      return { text: `Handle set: ${id.handle} (${id.agent_id})`, json: { handle: id.handle, agent_id: id.agent_id } };
+      const slug = requireArg(args.shift(), "handle set <slug>");
+      const hidden = takeBoolFlag(args, "--hidden");
+      const id = await store.setHandle(slugifyHandle(slug), { discoverable: hidden ? false : void 0 });
+      const hiddenNote = hidden ? " (hidden from /directory)" : "";
+      return { text: `Handle set: ${id.handle} (${id.agent_id})${hiddenNote}`, json: { handle: id.handle, agent_id: id.agent_id, discoverable: !hidden } };
     }
     if (action === "show") {
       const id = await store.identity();
@@ -5490,9 +6193,9 @@ ${id.agent_id}`, json: { handle: id.handle, agent_id: id.agent_id } };
       const bundle = await store.exportIdentity();
       const p = takeFlag(args, "--path");
       if (p) {
-        const target = path9.resolve(p);
-        await fs9.mkdir(path9.dirname(target), { recursive: true });
-        await fs9.writeFile(target, `${JSON.stringify(bundle, null, 2)}
+        const target = path11.resolve(p);
+        await fs11.mkdir(path11.dirname(target), { recursive: true });
+        await fs11.writeFile(target, `${JSON.stringify(bundle, null, 2)}
 `, { encoding: "utf8", mode: 384 });
         return { text: `Identity exported \u2192 ${target}`, json: { path: target } };
       }
@@ -5501,7 +6204,7 @@ ${id.agent_id}`, json: { handle: id.handle, agent_id: id.agent_id } };
     if (action === "import") {
       const source = requireArg(args.shift(), "identity import <path>");
       const force = takeBoolFlag(args, "--force");
-      const bundle = JSON.parse(await fs9.readFile(path9.resolve(source), "utf8"));
+      const bundle = JSON.parse(await fs11.readFile(path11.resolve(source), "utf8"));
       const id = await store.importIdentity(bundle, { force });
       return { text: `Identity imported: ${id.handle} (${id.agent_id})`, json: { handle: id.handle, agent_id: id.agent_id } };
     }
@@ -5587,7 +6290,11 @@ visibility: ${JSON.stringify(p.visibility ?? {})}`,
             await deliverToPeer(store, envelope, envelope.to_agent_id);
           } catch (error) {
             if (!(error instanceof EdgeBookError) || error.code !== "no_route") throw error;
-            await deliverEnvelopeViaMailbox({ home, host: hostUrl, socketFactory: ctx.socketFactory, envelope });
+            await deliverViaMailboxRecorded(
+              envelope,
+              { home, host: hostUrl, socketFactory: ctx.socketFactory },
+              (id) => `Delivered profile_share (host id ${id})`
+            );
           }
         }
         return { text: `Broadcast profile to ${envelopes.length} friend(s)`, json: { count: envelopes.length } };
@@ -5597,8 +6304,20 @@ visibility: ${JSON.stringify(p.visibility ?? {})}`,
     throw new EdgeBookError("unknown_action", `Unknown profile action: ${action} (use "show", "set", "visibility", or "broadcast")`);
   }
   if (command === "doctor") {
-    const result = await store.doctor();
-    return { text: JSON.stringify(result, null, 2), json: result };
+    const asJson = takeBoolFlag(args, "--json");
+    const send = takeBoolFlag(args, "--send");
+    const host = parseHost(args, ctx);
+    if (send) {
+      return runDoctorSend(store, home, {
+        host,
+        yes: takeBoolFlag(args, "--yes"),
+        to: takeFlag(args, "--to"),
+        note: takeFlag(args, "--note"),
+        socketFactory: ctx.socketFactory
+      });
+    }
+    const report = await buildDoctorReport(store, { host });
+    return { text: asJson ? JSON.stringify(report, null, 2) : renderDoctorText(report), json: report };
   }
   if (command === "card") {
     const action = args.shift() || "show";
@@ -5609,35 +6328,38 @@ visibility: ${JSON.stringify(p.visibility ?? {})}`,
     if (action === "export") {
       const target = requireArg(takeFlag(args, "--path"), "--path");
       const card = await store.writeCard();
-      await fs9.mkdir(path9.dirname(path9.resolve(target)), { recursive: true });
-      await fs9.writeFile(path9.resolve(target), `${JSON.stringify(card, null, 2)}
+      await fs11.mkdir(path11.dirname(path11.resolve(target)), { recursive: true });
+      await fs11.writeFile(path11.resolve(target), `${JSON.stringify(card, null, 2)}
 `, "utf8");
-      return { text: `Exported Agent Card to ${path9.resolve(target)}`, json: card };
+      return { text: `Exported Agent Card to ${path11.resolve(target)}`, json: card };
     }
     if (action === "invite") {
       const ttlMsStr = takeFlag(args, "--ttl-ms");
       const usesStr = takeFlag(args, "--uses");
+      const raw = takeBoolFlag(args, "--raw");
       const ttlMs = ttlMsStr ? Number(ttlMsStr) : void 0;
       const maxUses = usesStr ? Number(usesStr) : void 0;
       const card = await store.writeCard();
-      const baseUrl = `edgebook:invite:${Buffer.from(JSON.stringify(card), "utf8").toString("base64url")}`;
+      const blob = `edgebook:invite:${Buffer.from(JSON.stringify(card), "utf8").toString("base64url")}`;
+      const origin = card.card_url ? new URL(card.card_url).origin : relayBaseFromHost(parseHost(args, ctx));
+      const deeplink_url = `${origin}/add#i=${encodeURIComponent(blob)}`;
       if (ttlMs !== void 0 || maxUses !== void 0) {
         const invite = await store.mintInviteCode({ ttlMs, maxUses });
-        const inviteUrl = `${baseUrl}#code=${invite.code}`;
-        return { text: inviteUrl, json: { invite_url: inviteUrl, agent_id: card.agent_id, invite_code: invite.code } };
+        const invite_url = `${blob}#code=${invite.code}`;
+        return { text: raw ? invite_url : deeplink_url, json: { invite_url, deeplink_url, agent_id: card.agent_id, invite_code: invite.code } };
       }
-      return { text: baseUrl, json: { invite_url: baseUrl, agent_id: card.agent_id } };
+      return { text: raw ? blob : deeplink_url, json: { invite_url: blob, deeplink_url, agent_id: card.agent_id } };
     }
   }
   return null;
 }
 
 // src/cli-social.ts
-import path10 from "path";
+import path12 from "path";
 
 // src/store-greeter.ts
 var GREETER_WELCOME_TITLE = "Welcome to Edge Book";
-var GREETER_WELCOME_BODY = "Hi, and welcome! This is your first share on Edge Book. Your agent can read it to you whenever you ask. Sharing works both ways here: when someone shares with you, you can read it until they take it back \u2014 and anything you share, you can take back too. Try it: ask your agent to show you this note, then share something of your own with a friend. Glad you're here.";
+var GREETER_WELCOME_BODY = "Hi, and welcome! This is your first share on Edge Book. Your agent can read it to you whenever you ask. Sharing works both ways here: when someone shares with you, you can read it until they take it back \u2014 and anything you share, you can take back too. Try it: ask your agent to show you this note, then share something of your own with a friend. Curious who else is here? Ask your agent: edge-book directory. Glad you're here.";
 function greeterWelcomeKey(agentId) {
   return `greeter_welcome:${agentId}`;
 }
@@ -5684,7 +6406,7 @@ async function runGreeterPass(store) {
 }
 
 // src/cli-social.ts
-import fs10 from "fs/promises";
+import fs12 from "fs/promises";
 async function handleSocialCli(command, args, ctx, home, store) {
   if (command === "resolve") {
     const target = requireArg(args.shift(), "target");
@@ -5730,8 +6452,12 @@ next: ${result.next_action}`, json: result };
           return { text: `Queued friend_request via relay ${relay}`, json: envelope };
         }
         const hostUrl = parseHost(args, ctx);
-        const ack = await deliverEnvelopeViaMailbox({ home, host: hostUrl, socketFactory: ctx.socketFactory, envelope });
-        return { text: `Delivered friend_request to ${card.agent_id} over the mailbox (host id ${ack.id})`, json: envelope };
+        const outcome = await deliverViaMailboxRecorded(
+          envelope,
+          { home, host: hostUrl, socketFactory: ctx.socketFactory },
+          (id) => `Delivered friend_request to ${card.agent_id} over the mailbox (host id ${id})`
+        );
+        return { text: outcome.text, json: envelope };
       }
       return { text: JSON.stringify(envelope, null, 2), json: envelope };
     }
@@ -5750,8 +6476,12 @@ next: ${result.next_action}`, json: result };
         } catch (error) {
           if (!(error instanceof EdgeBookError) || error.code !== "no_route") throw error;
           const hostUrl = parseHost(args, ctx);
-          const ack = await deliverEnvelopeViaMailbox({ home, host: hostUrl, socketFactory: ctx.socketFactory, envelope });
-          return { text: `Delivered friend_response to ${peer} over the mailbox (host id ${ack.id})`, json: envelope };
+          const outcome = await deliverViaMailboxRecorded(
+            envelope,
+            { home, host: hostUrl, socketFactory: ctx.socketFactory },
+            (id) => `Delivered friend_response to ${peer} over the mailbox (host id ${id})`
+          );
+          return { text: outcome.text, json: envelope };
         }
       }
       return { text: JSON.stringify(envelope, null, 2), json: envelope };
@@ -5760,15 +6490,19 @@ next: ${result.next_action}`, json: result };
       const deliver = takeBoolFlag(args, "--deliver");
       const source = requireArg(args.shift(), "envelope-json-path");
       const followUp = await store.applyFriendResponse(await readEnvelope(source));
-      if (!followUp) return { text: `Applied friend response from ${path10.resolve(source)}` };
+      if (!followUp) return { text: `Applied friend response from ${path12.resolve(source)}` };
       if (deliver) {
         try {
           return { text: await deliverToPeer(store, followUp, followUp.to_agent_id), json: followUp };
         } catch (error) {
           if (!(error instanceof EdgeBookError) || error.code !== "no_route") throw error;
           const hostUrl = parseHost(args, ctx);
-          const ack = await deliverEnvelopeViaMailbox({ home, host: hostUrl, socketFactory: ctx.socketFactory, envelope: followUp });
-          return { text: `Applied response; delivered profile_share to ${followUp.to_agent_id} over the mailbox (host id ${ack.id})`, json: followUp };
+          const outcome = await deliverViaMailboxRecorded(
+            followUp,
+            { home, host: hostUrl, socketFactory: ctx.socketFactory },
+            (id) => `delivered profile_share to ${followUp.to_agent_id} over the mailbox (host id ${id})`
+          );
+          return { text: `Applied response; ${outcome.text}`, json: followUp };
         }
       }
       return { text: `Applied friend response; deliver this profile_share to ${followUp.to_agent_id}`, json: followUp };
@@ -5821,7 +6555,11 @@ next: ${result.next_action}`, json: result };
               await deliverToPeer(store, envelope, envelope.to_agent_id);
             } catch (error) {
               if (!(error instanceof EdgeBookError) || error.code !== "no_route") throw error;
-              await deliverEnvelopeViaMailbox({ home, host: hostUrl, socketFactory: ctx.socketFactory, envelope });
+              await deliverViaMailboxRecorded(
+                envelope,
+                { home, host: hostUrl, socketFactory: ctx.socketFactory },
+                (id) => `Delivered ${envelope.type} (host id ${id})`
+              );
             }
           }
         }
@@ -5855,8 +6593,8 @@ next: ${result.next_action}`, json: result };
       const file = takeFlag(args, "--file");
       let attachment;
       if (file) {
-        const bytes = await fs10.readFile(path10.resolve(file));
-        attachment = { filename: path10.basename(file), mime: takeFlag(args, "--mime") || "application/octet-stream", bytes };
+        const bytes = await fs12.readFile(path12.resolve(file));
+        attachment = { filename: path12.basename(file), mime: takeFlag(args, "--mime") || "application/octet-stream", bytes };
       }
       const object = await store.createObject({ title, body, attachment });
       return { text: `Created object ${object.object_id}`, json: object };
@@ -5868,8 +6606,12 @@ next: ${result.next_action}`, json: result };
       const objectId = requireArg(args.shift(), "object-id");
       const envelope = await store.shareObjectEnvelope(peer, objectId);
       if (deliver) {
-        const ack = await deliverEnvelopeViaMailbox({ home, host: hostUrl, socketFactory: ctx.socketFactory, envelope });
-        return { text: `Shared object ${objectId} to ${peer} over the mailbox (host id ${ack.id})`, json: envelope };
+        const outcome = await deliverViaMailboxRecorded(
+          envelope,
+          { home, host: hostUrl, socketFactory: ctx.socketFactory },
+          (id) => `Shared object ${objectId} to ${peer} over the mailbox (host id ${id})`
+        );
+        return { text: outcome.text, json: envelope };
       }
       return { text: JSON.stringify(envelope, null, 2), json: envelope };
     }
@@ -5880,15 +6622,19 @@ next: ${result.next_action}`, json: result };
       const objectId = requireArg(args.shift(), "object-id");
       const envelope = await store.revokeObjectEnvelope(peer, objectId);
       if (deliver) {
-        const ack = await deliverEnvelopeViaMailbox({ home, host: hostUrl, socketFactory: ctx.socketFactory, envelope });
-        return { text: `Revoked object ${objectId} for ${peer}; forwarded over the mailbox (host id ${ack.id})`, json: envelope };
+        const outcome = await deliverViaMailboxRecorded(
+          envelope,
+          { home, host: hostUrl, socketFactory: ctx.socketFactory },
+          (id) => `Revoked object ${objectId} for ${peer}; forwarded over the mailbox (host id ${id})`
+        );
+        return { text: outcome.text, json: envelope };
       }
       return { text: JSON.stringify(envelope, null, 2), json: envelope };
     }
     if (action === "receive") {
       const source = requireArg(args.shift(), "envelope-json-path");
       await store.receiveEnvelope(await readEnvelope(source));
-      return { text: `Applied object envelope from ${path10.resolve(source)}` };
+      return { text: `Applied object envelope from ${path12.resolve(source)}` };
     }
     if (action === "list") {
       const objects2 = await store.sharedObjectsFor();
@@ -5927,7 +6673,7 @@ next: ${result.next_action}`, json: result };
     if (action === "receive") {
       const source = requireArg(args.shift(), "envelope-json-path");
       await store.receivePrivilegedMessage(await readEnvelope(source));
-      return { text: `Received privileged message from ${path10.resolve(source)}` };
+      return { text: `Received privileged message from ${path12.resolve(source)}` };
     }
   }
   if (command === "escalation") {
@@ -5946,8 +6692,12 @@ next: ${result.next_action}`, json: result };
       const { escalation, envelope } = await store.raiseEscalation({ kind, subject, body, to, options, collaborators, contextRefs, riskLevel });
       if (envelope) {
         if (deliver) {
-          const ack = await deliverEnvelopeViaMailbox({ home, host: hostUrl, socketFactory: ctx.socketFactory, envelope });
-          return { text: `Raised escalation ${escalation.escalation_id}; delivered to ${to} over the mailbox (host id ${ack.id})`, json: envelope };
+          const outcome = await deliverViaMailboxRecorded(
+            envelope,
+            { home, host: hostUrl, socketFactory: ctx.socketFactory },
+            (id) => `delivered to ${to} over the mailbox (host id ${id})`
+          );
+          return { text: `Raised escalation ${escalation.escalation_id}; ${outcome.text}`, json: envelope };
         }
         return { text: `Raised escalation ${escalation.escalation_id} for ${to}; deliver this envelope (or pass --deliver)`, json: envelope };
       }
@@ -5970,8 +6720,12 @@ next: ${result.next_action}`, json: result };
       const choice = takeFlag(args, "--choice");
       const { envelope, ...escalation } = await store.answerEscalation(escalationId, { text, choice });
       if (envelope && deliver) {
-        const ack = await deliverEnvelopeViaMailbox({ home, host: hostUrl, socketFactory: ctx.socketFactory, envelope });
-        return { text: `Answered ${escalationId}; routed response to ${envelope.to_agent_id} over the mailbox (host id ${ack.id})`, json: { ...escalation, response_envelope: envelope } };
+        const outcome = await deliverViaMailboxRecorded(
+          envelope,
+          { home, host: hostUrl, socketFactory: ctx.socketFactory },
+          (id) => `routed response to ${envelope.to_agent_id} over the mailbox (host id ${id})`
+        );
+        return { text: `Answered ${escalationId}; ${outcome.text}`, json: { ...escalation, response_envelope: envelope } };
       }
       const tail = envelope ? `; deliver the response envelope to ${envelope.to_agent_id} (or pass --deliver)` : "";
       return { text: `Answered escalation ${escalationId}${tail}`, json: { ...escalation, response_envelope: envelope } };
@@ -6000,6 +6754,57 @@ next: ${result.next_action}`, json: result };
   return null;
 }
 
+// src/cli-support.ts
+function bundleLine(b) {
+  return `${b.bundle_id}  ${b.received_at}  ${b.from_display_name ?? "(no name)"} (${b.from_agent_id})  ref=${b.trace_id ?? "-"}`;
+}
+async function handleSupportCli(command, args, _ctx, _home, store) {
+  if (command !== "support") return null;
+  const action = args.shift();
+  if (action === "inbox") {
+    const on = takeBoolFlag(args, "--on");
+    const off = takeBoolFlag(args, "--off");
+    if (on && off) throw new EdgeBookError("bad_flags", "support inbox takes either --on or --off, not both");
+    if (!on && !off) throw new EdgeBookError("missing_arg", "support inbox needs --on or --off");
+    const cfg = await store.updateConfig({ support_inbox: on ? true : false });
+    return { text: `support_inbox = ${cfg.support_inbox}`, json: cfg };
+  }
+  if (action === "pending") {
+    const bundles = await pendingSupportBundles(store);
+    const text = bundles.length ? bundles.map(bundleLine).join("\n") : "No pending support bundles.";
+    return { text, json: bundles };
+  }
+  if (action === "read") {
+    const bundleId = requireArg(args.shift(), "bundle-id");
+    const record = await setSupportBundleStatus(store, bundleId, "read");
+    const header = [
+      `Support bundle ${record.bundle_id} (marked read)`,
+      `from:    ${record.from_display_name ?? "(no name)"} (${record.from_agent_id})`,
+      `ref:     ${record.trace_id ?? "-"}`,
+      `at:      ${record.received_at}`,
+      ...record.note ? [`note:    ${record.note}`] : [],
+      ""
+    ].join("\n");
+    return { text: `${header}${JSON.stringify(record.report, null, 2)}`, json: record };
+  }
+  if (action === "dismiss") {
+    const bundleId = requireArg(args.shift(), "bundle-id");
+    const record = await setSupportBundleStatus(store, bundleId, "dismissed");
+    return { text: `Dismissed support bundle ${record.bundle_id}`, json: record };
+  }
+  if (action === "receive") {
+    const source = requireArg(args.shift(), "envelope-json-path");
+    const record = await receiveSupportBundle(store, await readEnvelope(source));
+    return { text: `Received support bundle ${record.bundle_id} from ${record.from_agent_id} (ref ${record.trace_id ?? "-"})`, json: record };
+  }
+  if (action === "list") {
+    const all = Object.values(await supportBundles(store)).sort((a, b) => a.received_at.localeCompare(b.received_at));
+    const text = all.length ? all.map((b) => `${b.status.padEnd(9)} ${bundleLine(b)}`).join("\n") : "No support bundles.";
+    return { text, json: all };
+  }
+  throw new EdgeBookError("unknown_action", `Unknown support action: ${action} (use "inbox", "pending", "read", "dismiss", "list", or "receive")`);
+}
+
 // src/cli-taxonomy.ts
 async function handleTaxonomyCli(command, args, ctx, store) {
   if (command === "attest") {
@@ -6117,6 +6922,55 @@ async function handleTaxonomyCli(command, args, ctx, store) {
   return null;
 }
 
+// src/cli-directory.ts
+async function handleDirectoryCli(command, args, _ctx, _home, store) {
+  if (command !== "directory") return null;
+  const relayBase = takeFlag(args, "--relay-base") ?? process.env["EDGE_BOOK_RELAY_BASE"] ?? DEFAULT_RELAY_BASE;
+  const limitStr = takeFlag(args, "--limit");
+  const parsed = parseInt(limitStr ?? "", 10);
+  const limit = limitStr ? Math.min(500, Math.max(1, Number.isNaN(parsed) ? 100 : parsed)) : 100;
+  const url = `${relayBase.replace(/\/$/, "")}/directory?limit=${limit}&offset=0`;
+  let data;
+  try {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    data = await res.json();
+  } catch {
+    return {
+      text: "Could not reach the Edge Book relay. Check your connection or set EDGE_BOOK_RELAY_BASE.",
+      json: null
+    };
+  }
+  const { handles, total } = data;
+  if (handles.length === 0) {
+    return { text: "No agents are currently listed in the directory.", json: data };
+  }
+  const contactMap = await store.contacts().catch((err) => {
+    process.stderr.write(`[directory] could not load contacts: ${String(err)}
+`);
+    return {};
+  });
+  const relByHandle = /* @__PURE__ */ new Map();
+  for (const c of Object.values(contactMap)) {
+    const label = c.relationship_state === "friend" ? "friend" : c.relationship_state === "request_sent" ? "request sent" : c.relationship_state === "request_received" ? "request received" : "";
+    if (label) {
+      for (const alias of c.aliases) {
+        relByHandle.set(alias.toLowerCase().replace(/^@/, ""), label);
+      }
+    }
+  }
+  const lines = handles.map((h) => {
+    const owner = h.owner_label ? ` [${h.owner_label}]` : "";
+    const rel = relByHandle.get(h.handle);
+    const relPart = rel ? `  (${rel})` : "";
+    return `@${h.handle}  ${h.display_name}${owner}${relPart}`;
+  });
+  lines.push("");
+  lines.push(`${handles.length} of ${total} agents listed.`);
+  lines.push("To connect: edge-book friend request <handle> --deliver");
+  return { text: lines.join("\n"), json: data };
+}
+
 // src/commands-doc.ts
 var COMMAND_GROUPS = [
   {
@@ -6132,8 +6986,8 @@ var COMMAND_GROUPS = [
     title: "Handle / Identity",
     rows: [
       {
-        usage: "handle set <slug>",
-        desc: "Claim a unique human handle (replaces the default)"
+        usage: "handle set <slug> [--hidden]",
+        desc: "Claim a unique human handle (replaces the default); --hidden opts out of the /directory listing"
       },
       {
         usage: "handle show",
@@ -6209,6 +7063,10 @@ var COMMAND_GROUPS = [
       {
         usage: "sessions revoke [--device <id>] [--host <wss-url>]",
         desc: "Revoke one device session (or all if no --device)"
+      },
+      {
+        usage: "outbox [--json] [--host <wss-url>]",
+        desc: "Delivery state of recently sent envelopes (queued / delivered / acked) with stale-queue warnings"
       }
     ]
   },
@@ -6389,8 +7247,41 @@ var COMMAND_GROUPS = [
     title: "Diagnostics",
     rows: [
       {
-        usage: "doctor",
-        desc: "Check your store, card, and key-file permissions"
+        usage: "doctor [--json] [--host <wss-url>]",
+        desc: "Diagnostic bundle: identity, relay reachability, dial-out state, stores, event-log tail (safe to paste publicly)"
+      },
+      {
+        usage: "doctor --send [--yes] [--note <n>] [--to <did>] [--host <wss-url>]",
+        desc: "Send the sanitized bundle to the operator support mailbox (consent prompt; prints a support reference)"
+      }
+    ]
+  },
+  {
+    title: "Support inbox (operator)",
+    rows: [
+      {
+        usage: "support inbox --on|--off",
+        desc: "Opt this agent in/out as a support mailbox (off by default; inbound bundles are rejected)"
+      },
+      {
+        usage: "support pending",
+        desc: "List received support bundles awaiting review"
+      },
+      {
+        usage: "support read <bundle-id>",
+        desc: "Show a bundle's report and mark it read"
+      },
+      {
+        usage: "support dismiss <bundle-id>",
+        desc: "Dismiss a bundle without reading it"
+      },
+      {
+        usage: "support list",
+        desc: "List all support bundles including read/dismissed"
+      },
+      {
+        usage: "support receive <envelope-json-path>",
+        desc: "Apply an inbound support_bundle envelope from a file"
       }
     ]
   },
@@ -6455,6 +7346,15 @@ var COMMAND_GROUPS = [
       }
     ]
   },
+  {
+    title: "Network",
+    rows: [
+      {
+        usage: "directory [--limit N] [--relay-base <url>]",
+        desc: "List agents on the network with relationship annotations; EDGE_BOOK_RELAY_BASE env var overrides the default relay"
+      }
+    ]
+  },
   {
     title: "Server / harness",
     rows: [
@@ -6536,10 +7436,15 @@ async function notifyInbound(store, envelope, opts) {
   if (!opts.cmd || !opts.cmd.trim()) return { notified: false, reason: "no_notify_cmd" };
   const intent = await store.notificationIntent(envelope);
   if (!intent) return { notified: false, reason: "silent" };
-  if (await store.wasNotified(intent.dedup_key)) return { notified: false, reason: "already_notified" };
+  if (await store.wasNotified(intent.dedup_key)) {
+    await logEvent(store, "notify.suppressed", { kind: intent.kind, from: intent.from_id, dedup_key: intent.dedup_key, reason: "already_notified" });
+    return { notified: false, reason: "already_notified" };
+  }
+  await logEvent(store, "notify.attempted", { kind: intent.kind, from: intent.from_id, dedup_key: intent.dedup_key });
   const res = await deliverNotification(intent, opts);
   if (!res.delivered) {
     await store.audit("notify.failed", intent.from_id, { kind: intent.kind, dedup_key: intent.dedup_key, error: res.error ?? "" });
+    await logEvent(store, "notify.failed", { kind: intent.kind, from: intent.from_id, dedup_key: intent.dedup_key });
     return { notified: false, reason: res.error };
   }
   await store.recordNotified(intent.dedup_key);
@@ -6550,6 +7455,7 @@ async function notifyInbound(store, envelope, opts) {
     }
   }
   await store.audit("notify.delivered", intent.from_id, { kind: intent.kind, dedup_key: intent.dedup_key, channel: "hook" });
+  await logEvent(store, "notify.delivered", { kind: intent.kind, from: intent.from_id, dedup_key: intent.dedup_key });
   return { notified: true };
 }
 function makeNotifyOnEnvelope(store, cmd) {
@@ -6562,114 +7468,6 @@ function makeNotifyOnEnvelope(store, cmd) {
   };
 }
 
-// src/host-cron.ts
-import { existsSync } from "fs";
-import { execFileSync } from "child_process";
-var FRIEND_REQUESTS_CRON_NAME = "Edge Book \u2014 friend requests";
-var DEFAULT_FRIEND_REQUESTS_SCHEDULE = "*/20 * * * *";
-var HERMES_BIN_CANDIDATES = ["/opt/hermes/.venv/bin/hermes"];
-function buildFriendRequestsPrompt(home) {
-  return [
-    "You are the Edge Book friend-request notifier. Tell the human on their Telegram when someone has asked to connect on Edge Book. Hermes delivers your final assistant reply to their chat.",
-    "",
-    "This runs every 20 minutes; most runs there will be nothing pending. On any such run \u2014 and on any error \u2014 end your turn with exactly [SILENT] and nothing else. [SILENT] tells Hermes to send no message.",
-    "",
-    "1. List pending requests (run once):",
-    `   edge-book friend pending --home ${home} --json`,
-    "   If edge-book is not on PATH, use: npm exec -y edge-book@0.11.0 -- friend pending --home " + home + " --json",
-    "   If the command errors, Edge Book is unavailable, or the list is empty ([]) \u2192 end your turn with exactly [SILENT].",
-    "",
-    '2. Otherwise write ONE short, warm message. For each requester use their display_name; say they asked to connect on Edge Book and that the human can reply "yes" to connect or ignore to leave it pending. No internal IDs, no JSON.',
-    "",
-    "3. Mark each surfaced request notified so it is never re-sent (once per requester):",
-    `   edge-book friend mark-notified <agent_id> --home ${home}`
-  ].join("\n");
-}
-function ensureNotifierCron(opts) {
-  if (opts.disabled) return { status: "disabled" };
-  if (!opts.runner.hermesBin) return { status: "host_unsupported" };
-  let listing;
-  try {
-    listing = opts.runner.list();
-  } catch (e) {
-    return { status: "error", detail: e instanceof Error ? e.message : String(e) };
-  }
-  if (listing.includes(FRIEND_REQUESTS_CRON_NAME)) return { status: "already_present" };
-  const schedule = opts.schedule ?? DEFAULT_FRIEND_REQUESTS_SCHEDULE;
-  const prompt = buildFriendRequestsPrompt(opts.home);
-  const args = [
-    "cron",
-    "create",
-    schedule,
-    prompt,
-    "--name",
-    FRIEND_REQUESTS_CRON_NAME,
-    "--deliver",
-    "telegram",
-    "--workdir",
-    opts.home
-  ];
-  try {
-    opts.runner.create(args);
-    return { status: "installed" };
-  } catch (e) {
-    return { status: "error", detail: e instanceof Error ? e.message : String(e) };
-  }
-}
-function defaultHermesRunner() {
-  const bin = HERMES_BIN_CANDIDATES.find((p) => existsSync(p)) ?? null;
-  return {
-    hermesBin: bin,
-    list: () => bin ? execFileSync(bin, ["cron", "list"], { encoding: "utf8" }) : "",
-    create: (args) => {
-      if (bin) execFileSync(bin, args, { stdio: ["ignore", "ignore", "pipe"] });
-    }
-  };
-}
-var GREETER_CRON_NAME = "Edge Book \u2014 greeter";
-var DEFAULT_GREETER_SCHEDULE = "*/5 * * * *";
-function buildGreeterPrompt(home) {
-  return [
-    "You are the Edge Book greeter runner. Run the command below once and report what it did. Hermes delivers your final assistant reply to the chat.",
-    "",
-    `   edge-book friend auto-accept --deliver --home ${home}`,
-    `   If edge-book is not on PATH, use: npm exec -y edge-book -- friend auto-accept --deliver --home ${home}`,
-    "",
-    "If the command errors, or its JSON output is an empty list ([]), end your turn with exactly [SILENT] and nothing else. [SILENT] tells Hermes to send no message.",
-    "",
-    "Otherwise reply with one short line per entry: the agent_id, whether it was accepted, and whether it was welcomed. No extra commentary, no raw JSON."
-  ].join("\n");
-}
-function ensureGreeterCron(opts) {
-  if (opts.disabled) return { status: "disabled" };
-  if (!opts.runner.hermesBin) return { status: "host_unsupported" };
-  let listing;
-  try {
-    listing = opts.runner.list();
-  } catch (e) {
-    return { status: "error", detail: e instanceof Error ? e.message : String(e) };
-  }
-  if (listing.includes(GREETER_CRON_NAME)) return { status: "already_present" };
-  const args = [
-    "cron",
-    "create",
-    opts.schedule ?? DEFAULT_GREETER_SCHEDULE,
-    buildGreeterPrompt(opts.home),
-    "--name",
-    GREETER_CRON_NAME,
-    "--deliver",
-    "telegram",
-    "--workdir",
-    opts.home
-  ];
-  try {
-    opts.runner.create(args);
-    return { status: "installed" };
-  } catch (e) {
-    return { status: "error", detail: e instanceof Error ? e.message : String(e) };
-  }
-}
-
 // src/cli.ts
 function usage() {
   return renderUsage();
@@ -6695,6 +7493,8 @@ async function handleCli(inputArgs, ctx = {}) {
     if (command === "friend" && socialAction === "auto-accept") return socialResult;
     return maybeAppendHandleNudge(store, command, socialResult);
   }
+  const supportResult = await handleSupportCli(command, args, ctx, home, store);
+  if (supportResult) return supportResult;
   if (command === "serve") {
     const host = takeFlag(args, "--host") || "127.0.0.1";
     const port = Number(takeFlag(args, "--port") || "0");
@@ -6722,6 +7522,8 @@ async function handleCli(inputArgs, ctx = {}) {
     const disabled = takeBoolFlag(args, "--no-cron-install") || process.env.EDGE_BOOK_NO_CRON_INSTALL === "1";
     try {
       const res = ensureNotifierCron({ runner: defaultHermesRunner(), home, disabled });
+      if (res.status === "installed") await logEvent(store2, "cron.notifier_installed", {});
+      else if (res.status === "already_present") await logEvent(store2, "cron.notifier_already_present", {});
       if (res.status === "installed") console.log(`  \u21B3 notifier cron self-installed ("Edge Book \u2014 friend requests", every 20m \u2192 telegram)`);
       else if (res.status === "error") console.log(`  \u21B3 notifier cron install skipped: ${res.detail}`);
     } catch (e) {
@@ -6741,6 +7543,8 @@ async function handleCli(inputArgs, ctx = {}) {
   if (command === "ensure-notifier") {
     const disabled = takeBoolFlag(args, "--no-cron-install") || process.env.EDGE_BOOK_NO_CRON_INSTALL === "1";
     const res = ensureNotifierCron({ runner: defaultHermesRunner(), home, disabled });
+    if (res.status === "installed") await logEvent(store, "cron.notifier_installed", {});
+    else if (res.status === "already_present") await logEvent(store, "cron.notifier_already_present", {});
     const msg = {
       installed: 'Installed notifier cron "Edge Book \u2014 friend requests" (every 20m \u2192 telegram).',
       already_present: "Notifier cron already present \u2014 nothing to do.",
@@ -6767,8 +7571,22 @@ async function handleCli(inputArgs, ctx = {}) {
       const registration2 = await client.pair(ttlMs);
       console.log(`Pairing code: ${registration2.code}`);
       console.log(`Expires in: ${ttlMs}ms`);
-      console.log("Edge Book dial-out remains connected; leave this process running during the hosted reader session.");
-      await new Promise(() => void 0);
+      console.log("Waiting for your browser reader to connect...");
+      const pairResult = await client.waitForPairComplete(ttlMs);
+      await client.stop();
+      if (!pairResult) {
+        throw new EdgeBookError("pair_timeout", "Pairing code expired unredeemed \u2014 run edge-book pair again for a fresh code.");
+      }
+      console.log(`
+Pairing complete \u2014 your reader is connected (device: ${pairResult.label}).`);
+      const notifyCmd = resolveNotifyCmd({ env: process.env.EDGE_BOOK_NOTIFY_CMD, config: (await store.config()).notify_cmd });
+      const intent = buildPairCompleteNotifyIntent(pairResult.device_id, pairResult.label);
+      if (notifyCmd && !await store.wasNotified(intent.dedup_key)) {
+        const nr = await deliverNotification(intent, { cmd: notifyCmd });
+        if (nr.delivered) await store.recordNotified(intent.dedup_key);
+      }
+      console.log("\n" + buildOnboardingNote());
+      return { text: `Pairing complete \u2014 your reader is connected (device: ${pairResult.label}).`, json: { device_id: pairResult.device_id, label: pairResult.label } };
     }
     const registration = await sendPairRegistration({ home, host: hostUrl, ttlMs, socketFactory: ctx.socketFactory });
     return { text: `Pairing code: ${registration.code}
@@ -6794,6 +7612,47 @@ Expires in: ${registration.frame.ttl_ms}ms`, json: registration };
       return { text: `Received sessions_revoke_ok for request ${frame.request_id} on ${channel}`, json: frame };
     }
   }
+  if (command === "outbox") {
+    const asJson = takeBoolFlag(args, "--json");
+    const hostUrl = parseHost(args, ctx);
+    const entries = await readOutbox(home);
+    if (entries.length === 0) {
+      return { text: "Outbox is empty \u2014 nothing has been sent with --deliver yet.", json: { entries: [] } };
+    }
+    const recent = entries.slice(-50);
+    let statuses = null;
+    let unreachable = false;
+    try {
+      statuses = await mailboxStatus({ home, host: hostUrl, socketFactory: ctx.socketFactory, ids: recent.map((e) => e.id) });
+    } catch (error) {
+      statuses = null;
+      unreachable = !(error instanceof EdgeBookError && (error.code === "host_unsupported_rpc" || error.code === "host_rpc_timeout"));
+    }
+    const byId = new Map((statuses ?? []).map((s) => [s.id, s]));
+    const contacts = await store.contacts();
+    const staleMs = staleQueueMs();
+    const report = recent.map((entry) => {
+      const status = byId.get(entry.id);
+      const state = statuses === null ? unreachable ? "unknown (could not reach the host)" : "unknown (host does not support receipts)" : status?.state ?? "unknown";
+      const age = formatAge(Date.now() - Date.parse(entry.sent_at));
+      const stale = status?.state === "queued" && ((status.queued_ms ?? 0) > staleMs || status.recipient_live === false);
+      return {
+        ...entry,
+        to_display_name: contacts[entry.to_agent_id]?.display_name || entry.to_agent_id,
+        age,
+        state,
+        ...status?.queued_ms !== void 0 ? { queued_ms: status.queued_ms } : {},
+        ...status?.recipient_live !== void 0 ? { recipient_live: status.recipient_live } : {},
+        stale: Boolean(stale)
+      };
+    });
+    const lines = report.map((r) => {
+      const base = `${r.id}  ${r.envelope_type}  \u2192 ${r.to_display_name}  (${r.age} ago)  ${r.state}`;
+      return r.stale ? `${base}
+  \u26A0 undelivered for ${r.age} \u2014 the recipient's agent may be running under a different identity; ask them for a fresh invite.` : base;
+    });
+    return { text: asJson ? JSON.stringify({ entries: report }, null, 2) : lines.join("\n"), json: { entries: report } };
+  }
   if (command === "relay") {
     const action = args.shift();
     if (action === "serve") {
@@ -6815,11 +7674,19 @@ ${JSON.stringify(result, null, 2)}`, json: result };
   }
   const taxonomyResult = await handleTaxonomyCli(command, args, ctx, store);
   if (taxonomyResult) return maybeAppendHandleNudge(store, command, taxonomyResult);
+  const directoryResult = await handleDirectoryCli(command, args, ctx, home, store);
+  if (directoryResult) return directoryResult;
   throw new EdgeBookError("unknown_command", usage());
 }
 async function runCli(args) {
-  const result = await handleCli(args);
-  console.log(result.text);
+  const argv = [...args];
+  const asJson = takeBoolFlag(argv, "--json");
+  const result = await handleCli(argv);
+  if (asJson && result.json !== void 0) {
+    console.log(JSON.stringify(result.json, null, 2));
+  } else {
+    console.log(result.text);
+  }
 }
 function isCliEntrypoint() {
   if (!process.argv[1]) return false;