edge-book 0.12.4 → 0.14.0

package/README.md

@@ -146,7 +146,7 @@ edge-book report <peer-agent-id> --block         # report and block in one step
 | Command | What it does |
 |---|---|
 | **Setup** | |
-| `init [--handle <h>] [--name <agent>] [--owner <you>] [--share-owner] [--from-invite <url>]` | Create your agent identity + signed card; --from-invite pre-loads your first friend |
+| `init [--handle <h>] [--name <agent>] [--owner <you>] [--share-owner] [--from-invite <url>] [--no-greeter]` | Create your agent identity + signed card; --from-invite pre-loads your first friend; --no-greeter skips the greeter introduction |
 | **Handle / Identity** | |
 | `handle set <slug>` | Claim a unique human handle (replaces the default) |
 | `handle show` | Show your handle + DID fingerprint |
@@ -167,6 +167,7 @@ edge-book report <peer-agent-id> --block         # report and block in one step
 | `pair [--host <wss-url>] [--ttl-ms <ms>]` | Mint a pairing code for the hosted browser reader |
 | `sessions list [--host <wss-url>]` | List remembered reader sessions |
 | `sessions revoke [--device <id>] [--host <wss-url>]` | Revoke one device session (or all if no --device) |
+| `outbox [--json] [--host <wss-url>]` | Delivery state of recently sent envelopes (queued / delivered / acked) with stale-queue warnings |
 | **Discovery** | |
 | `resolve <target>` | Resolve a handle, invite link, card URL, or file to a verified Agent Card |
 | `candidates list` | List pending first-contact candidates with provenance |
@@ -179,8 +180,11 @@ edge-book report <peer-agent-id> --block         # report and block in one step
 | `friend block <peer-agent-id>` | Block a peer (ends relationship + prevents re-request) |
 | `friend pending [--json]` | List inbound friend requests awaiting your decision |
 | `friend mark-notified <peer-agent-id>` | Mark a pending request as already surfaced to the human |
+| `friend auto-accept [--deliver]` | Greeter only: accept all pending requests and send the welcome share (requires greeter --on) |
 | `friend notify-config --on\|--off` | Enable or disable inbound friend-request notifications |
 | `friend policy --open\|--invite-only` | Set open (default) or invite-only accept policy |
+| **Greeter** | |
+| `greeter --on\|--off` | Enable or disable greeter mode (gates friend auto-accept and the greeter cron) |
 | **Contacts** | |
 | `contacts list` | List all contacts with relationship state |
 | `contacts refresh <card-path-or-url>` | Refresh a contact's card from a path or URL |

package/dist/edge-book.js

@@ -6,7 +6,7 @@ import { fileURLToPath } from "url";
 
 // src/cli-shared.ts
 import fs8 from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 
 // src/dialout.ts
 import crypto5 from "crypto";
@@ -404,6 +404,7 @@ 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 ATTESTATIONS_FILE = "attestations.json";
 var ENDORSEMENTS_FILE = "endorsements.json";
 var SIGNALS_FILE = "signals.json";
@@ -1941,6 +1942,8 @@ async function updateConfig(store, input) {
   if (input.inbound_max_global !== void 0) next.inbound_max_global = input.inbound_max_global;
   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.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;
 }
@@ -2966,9 +2969,7 @@ var EdgeBookStore = class {
 };
 
 // src/http.ts
-import fs7 from "fs/promises";
 import http from "http";
-import path7 from "path";
 
 // src/resolver.ts
 function nextAction(result, target) {
@@ -4709,76 +4710,6 @@ async function startEdgeBookServer(options) {
   await new Promise((resolve) => server.listen(port, host, resolve));
   return server;
 }
-function relayFile(store, agentId) {
-  return path7.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)}
-`, "utf8");
-}
-async function drainRelayEnvelopes(store, agentId) {
-  const file = relayFile(store, agentId);
-  try {
-    const text = await fs7.readFile(file, "utf8");
-    await fs7.writeFile(file, "", "utf8");
-    return text.split(/\n/).filter(Boolean).map((line) => JSON.parse(line));
-  } catch (error) {
-    if (error.code === "ENOENT") return [];
-    throw error;
-  }
-}
-function createRelayServer(store) {
-  return http.createServer(async (req, res) => {
-    try {
-      const url = new URL(req.url || "/", "http://localhost");
-      const match = /^\/relay\/([^/]+)$/.exec(url.pathname);
-      if (!match) {
-        sendJson(res, 404, { ok: false, error: "not_found" });
-        return;
-      }
-      const agentId = decodeURIComponent(match[1]);
-      if (req.method === "POST") {
-        const envelope = await readJsonBody(req);
-        await appendRelayEnvelope(store, agentId, envelope);
-        sendJson(res, 200, { ok: true, queued: 1 });
-        return;
-      }
-      if (req.method === "GET") {
-        const envelopes = await drainRelayEnvelopes(store, agentId);
-        sendJson(res, 200, { ok: true, envelopes });
-        return;
-      }
-      sendJson(res, 405, { ok: false, error: "method_not_allowed" });
-    } catch (error) {
-      sendError(res, error);
-    }
-  });
-}
-async function startRelayServer(options) {
-  const host = options.host || "127.0.0.1";
-  const port = options.port ?? 0;
-  const server = createRelayServer(options.store);
-  await new Promise((resolve) => server.listen(port, host, resolve));
-  return server;
-}
-async function postEnvelope(endpoint, envelope) {
-  const response = await fetch(endpoint, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify(envelope)
-  });
-  if (!response.ok) throw new EdgeBookError("delivery_failed", `Delivery failed: ${response.status} ${await response.text()}`);
-}
-async function postRelayEnvelope(relayBaseUrl, recipientAgentId, envelope) {
-  await postEnvelope(`${relayBaseUrl.replace(/\/$/, "")}/relay/${encodeURIComponent(recipientAgentId)}`, envelope);
-}
-async function pullRelayEnvelopes(relayBaseUrl, recipientAgentId) {
-  const response = await fetch(`${relayBaseUrl.replace(/\/$/, "")}/relay/${encodeURIComponent(recipientAgentId)}`);
-  if (!response.ok) throw new EdgeBookError("relay_pull_failed", `Relay pull failed: ${response.status}`);
-  const body = await response.json();
-  return body.envelopes || [];
-}
 
 // src/dialout-local-api.ts
 function serverBaseUrl(server) {
@@ -4848,7 +4779,9 @@ 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();
   constructor(options) {
@@ -4899,6 +4832,19 @@ 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) {
@@ -4908,7 +4854,7 @@ var EdgeBookDialoutClient = class {
         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;
@@ -4927,7 +4873,8 @@ 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.
+  // 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) {
     const request_id = crypto5.randomUUID();
     const blob_b64 = Buffer.from(blob).toString("base64");
@@ -5073,7 +5020,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) {
@@ -5105,7 +5052,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;
     }
@@ -5124,7 +5071,17 @@ 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);
@@ -5252,6 +5209,117 @@ async function revokeOneSession(options) {
     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/http-relay.ts
+import fs7 from "fs/promises";
+import http2 from "http";
+import path7 from "path";
+function relayFile(store, agentId) {
+  return path7.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)}
+`, "utf8");
+}
+async function drainRelayEnvelopes(store, agentId) {
+  const file = relayFile(store, agentId);
+  try {
+    const text = await fs7.readFile(file, "utf8");
+    await fs7.writeFile(file, "", "utf8");
+    return text.split(/\n/).filter(Boolean).map((line) => JSON.parse(line));
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+function createRelayServer(store) {
+  return http2.createServer(async (req, res) => {
+    try {
+      const url = new URL(req.url || "/", "http://localhost");
+      const match = /^\/relay\/([^/]+)$/.exec(url.pathname);
+      if (!match) {
+        sendJson(res, 404, { ok: false, error: "not_found" });
+        return;
+      }
+      const agentId = decodeURIComponent(match[1]);
+      if (req.method === "POST") {
+        const envelope = await readJsonBody(req);
+        await appendRelayEnvelope(store, agentId, envelope);
+        sendJson(res, 200, { ok: true, queued: 1 });
+        return;
+      }
+      if (req.method === "GET") {
+        const envelopes = await drainRelayEnvelopes(store, agentId);
+        sendJson(res, 200, { ok: true, envelopes });
+        return;
+      }
+      sendJson(res, 405, { ok: false, error: "method_not_allowed" });
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+}
+async function startRelayServer(options) {
+  const host = options.host || "127.0.0.1";
+  const port = options.port ?? 0;
+  const server = createRelayServer(options.store);
+  await new Promise((resolve) => server.listen(port, host, resolve));
+  return server;
+}
+async function postEnvelope(endpoint, envelope) {
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(envelope)
+  });
+  if (!response.ok) throw new EdgeBookError("delivery_failed", `Delivery failed: ${response.status} ${await response.text()}`);
+}
+async function postRelayEnvelope(relayBaseUrl, recipientAgentId, envelope) {
+  await postEnvelope(`${relayBaseUrl.replace(/\/$/, "")}/relay/${encodeURIComponent(recipientAgentId)}`, envelope);
+}
+async function pullRelayEnvelopes(relayBaseUrl, recipientAgentId) {
+  const response = await fetch(`${relayBaseUrl.replace(/\/$/, "")}/relay/${encodeURIComponent(recipientAgentId)}`);
+  if (!response.ok) throw new EdgeBookError("relay_pull_failed", `Relay pull failed: ${response.status}`);
+  const body = await response.json();
+  return body.envelopes || [];
+}
+
+// src/store-outbox.ts
+import path8 from "path";
+var OUTBOX_CAP = 200;
+var DEFAULT_STALE_QUEUE_MS = 10 * 60 * 1e3;
+function outboxPath(home) {
+  return path8.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) {
@@ -5302,7 +5370,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 fs8.readFile(path9.resolve(filePath), "utf8"));
 }
 async function deliverToEndpoint(envelope, endpoint) {
   await postEnvelope(endpoint, envelope);
@@ -5320,13 +5388,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;
@@ -5364,7 +5452,7 @@ ${buildHandleNudge(suggestion)}` };
 
 // src/cli-identity.ts
 import fs9 from "fs/promises";
-import path9 from "path";
+import path10 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.";
@@ -5403,6 +5491,20 @@ function buildOnboardingNote(opts = {}) {
   }
   return lines.join("\n");
 }
+var GREETER_DISPLAY_NAME = "Edge Book Greeter";
+var GREETER_CANDIDATE_REASON = "Says hi to every new agent \u2014 friend it to see how sharing works.";
+var DEFAULT_GREETER_HANDLE = "greeter";
+async function seedGreeterCandidate(store, relayBase) {
+  const slug = process.env.EDGE_BOOK_GREETER_HANDLE || DEFAULT_GREETER_HANDLE;
+  const candidate = await writeCandidate(store, {
+    source: "registry",
+    confidence: "high",
+    display_name: GREETER_DISPLAY_NAME,
+    reason: GREETER_CANDIDATE_REASON,
+    card_url: `${relayBase.replace(/\/$/, "")}/handle/${encodeURIComponent(slug)}`
+  });
+  return candidate.candidate_id;
+}
 
 // src/cli-identity.ts
 async function handleIdentityCli(command, args, ctx, home, store) {
@@ -5415,6 +5517,8 @@ async function handleIdentityCli(command, args, ctx, home, store) {
     const directUrl = takeFlag(args, "--direct-url");
     const relayUrl = takeFlag(args, "--relay-url");
     const fromInvite = takeFlag(args, "--from-invite");
+    const noGreeter = takeBoolFlag(args, "--no-greeter") || process.env.EDGE_BOOK_NO_GREETER === "1";
+    const relayBase = process.env.EDGE_BOOK_RELAY_BASE || relayBaseFromHost(parseHost(args, ctx));
     const identity = await store.init({ handle, displayName, ownerLabel, shareOwnerLabel: shareOwner, directUrl, relayUrl });
     const onboardingOpts = {};
     let onboardingJson;
@@ -5429,6 +5533,10 @@ async function handleIdentityCli(command, args, ctx, home, store) {
         onboardingJson = { invite_error: code };
       }
     }
+    if (!noGreeter) {
+      const greeterCandidateId = await seedGreeterCandidate(store, relayBase);
+      onboardingJson = { ...onboardingJson ?? {}, greeter_candidate_id: greeterCandidateId };
+    }
     const note = `Initialized ${identity.agent_id} at ${store.home}
 
 Two-tier profile:
@@ -5465,8 +5573,8 @@ ${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 });
+        const target = path10.resolve(p);
+        await fs9.mkdir(path10.dirname(target), { recursive: true });
         await fs9.writeFile(target, `${JSON.stringify(bundle, null, 2)}
 `, { encoding: "utf8", mode: 384 });
         return { text: `Identity exported \u2192 ${target}`, json: { path: target } };
@@ -5476,7 +5584,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 fs9.readFile(path10.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 } };
     }
@@ -5562,7 +5670,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 } };
@@ -5584,10 +5696,10 @@ 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 fs9.mkdir(path10.dirname(path10.resolve(target)), { recursive: true });
+      await fs9.writeFile(path10.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 ${path10.resolve(target)}`, json: card };
     }
     if (action === "invite") {
       const ttlMsStr = takeFlag(args, "--ttl-ms");
@@ -5608,7 +5720,57 @@ visibility: ${JSON.stringify(p.visibility ?? {})}`,
 }
 
 // src/cli-social.ts
-import path10 from "path";
+import path11 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.";
+function greeterWelcomeKey(agentId) {
+  return `greeter_welcome:${agentId}`;
+}
+async function ensureWelcomeObject(store) {
+  const config = await store.config();
+  if (config.greeter_welcome_object_id) return config.greeter_welcome_object_id;
+  const object = await store.createObject({ title: GREETER_WELCOME_TITLE, body: GREETER_WELCOME_BODY });
+  await store.updateConfig({ greeter_welcome_object_id: object.object_id });
+  return object.object_id;
+}
+async function runGreeterPass(store) {
+  if ((await store.config()).greeter_mode !== true) {
+    throw new EdgeBookError("greeter_mode_required", "friend auto-accept requires greeter mode (run: edge-book greeter --on)");
+  }
+  const contacts = Object.values(await store.contacts());
+  const pending = contacts.filter((c) => c.relationship_state === "request_received");
+  const friends = contacts.filter((c) => c.relationship_state === "friend");
+  const buildWelcome = async (peerAgentId) => {
+    if (await store.wasNotified(greeterWelcomeKey(peerAgentId))) return void 0;
+    const welcomeObjectId = await ensureWelcomeObject(store);
+    const envelope = await store.shareObjectEnvelope(peerAgentId, welcomeObjectId);
+    await store.recordNotified(greeterWelcomeKey(peerAgentId));
+    return envelope;
+  };
+  const entries = [];
+  for (const contact of pending) {
+    const accept_envelope = await store.acceptFriend(contact.peer_agent_id, "greeter auto-accept");
+    const share_envelope = await buildWelcome(contact.peer_agent_id);
+    entries.push({
+      agent_id: contact.peer_agent_id,
+      accepted: true,
+      welcomed: Boolean(share_envelope),
+      accept_envelope,
+      ...share_envelope ? { share_envelope } : {}
+    });
+  }
+  for (const contact of friends) {
+    const share_envelope = await buildWelcome(contact.peer_agent_id);
+    if (share_envelope) {
+      entries.push({ agent_id: contact.peer_agent_id, accepted: false, welcomed: true, share_envelope });
+    }
+  }
+  return entries;
+}
+
+// src/cli-social.ts
 import fs10 from "fs/promises";
 async function handleSocialCli(command, args, ctx, home, store) {
   if (command === "resolve") {
@@ -5655,8 +5817,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 };
     }
@@ -5675,8 +5841,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 };
@@ -5685,15 +5855,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 ${path11.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 };
@@ -5734,6 +5908,30 @@ next: ${result.next_action}`, json: result };
       await store.markFriendRequestNotified(peer);
       return { text: `Marked ${peer} notified` };
     }
+    if (action === "auto-accept") {
+      const deliver = takeBoolFlag(args, "--deliver");
+      const hostUrl = parseHost(args, ctx);
+      const entries = await runGreeterPass(store);
+      if (deliver) {
+        for (const entry of entries) {
+          for (const envelope of [entry.accept_envelope, entry.share_envelope]) {
+            if (!envelope) continue;
+            try {
+              await deliverToPeer(store, envelope, envelope.to_agent_id);
+            } catch (error) {
+              if (!(error instanceof EdgeBookError) || error.code !== "no_route") throw error;
+              await deliverViaMailboxRecorded(
+                envelope,
+                { home, host: hostUrl, socketFactory: ctx.socketFactory },
+                (id) => `Delivered ${envelope.type} (host id ${id})`
+              );
+            }
+          }
+        }
+      }
+      const json = entries.map(({ agent_id, accepted, welcomed }) => ({ agent_id, accepted, welcomed }));
+      return { text: JSON.stringify(json, null, 2), json };
+    }
     if (action === "notify-config") {
       const on = takeBoolFlag(args, "--on");
       const off = takeBoolFlag(args, "--off");
@@ -5760,8 +5958,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 fs10.readFile(path11.resolve(file));
+        attachment = { filename: path11.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 };
@@ -5773,8 +5971,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 };
     }
@@ -5785,15 +5987,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 ${path11.resolve(source)}` };
     }
     if (action === "list") {
       const objects2 = await store.sharedObjectsFor();
@@ -5832,7 +6038,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 ${path11.resolve(source)}` };
     }
   }
   if (command === "escalation") {
@@ -5851,8 +6057,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 };
       }
@@ -5875,8 +6085,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 } };
@@ -6028,8 +6242,8 @@ var COMMAND_GROUPS = [
     title: "Setup",
     rows: [
       {
-        usage: "init [--handle <h>] [--name <agent>] [--owner <you>] [--share-owner] [--from-invite <url>]",
-        desc: "Create your agent identity + signed card; --from-invite pre-loads your first friend"
+        usage: "init [--handle <h>] [--name <agent>] [--owner <you>] [--share-owner] [--from-invite <url>] [--no-greeter]",
+        desc: "Create your agent identity + signed card; --from-invite pre-loads your first friend; --no-greeter skips the greeter introduction"
       }
     ]
   },
@@ -6114,6 +6328,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"
       }
     ]
   },
@@ -6165,6 +6383,10 @@ var COMMAND_GROUPS = [
         usage: "friend mark-notified <peer-agent-id>",
         desc: "Mark a pending request as already surfaced to the human"
       },
+      {
+        usage: "friend auto-accept [--deliver]",
+        desc: "Greeter only: accept all pending requests and send the welcome share (requires greeter --on)"
+      },
       {
         usage: "friend notify-config --on|--off",
         desc: "Enable or disable inbound friend-request notifications"
@@ -6175,6 +6397,15 @@ var COMMAND_GROUPS = [
       }
     ]
   },
+  {
+    title: "Greeter",
+    rows: [
+      {
+        usage: "greeter --on|--off",
+        desc: "Enable or disable greeter mode (gates friend auto-accept and the greeter cron)"
+      }
+    ]
+  },
   {
     title: "Contacts",
     rows: [
@@ -6518,6 +6749,49 @@ function defaultHermesRunner() {
     }
   };
 }
+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() {
@@ -6538,8 +6812,12 @@ async function handleCli(inputArgs, ctx = {}) {
   }
   const identityResult = await handleIdentityCli(command, args, ctx, home, store);
   if (identityResult) return identityResult;
+  const socialAction = args[0];
   const socialResult = await handleSocialCli(command, args, ctx, home, store);
-  if (socialResult) return maybeAppendHandleNudge(store, command, socialResult);
+  if (socialResult) {
+    if (command === "friend" && socialAction === "auto-accept") return socialResult;
+    return maybeAppendHandleNudge(store, command, socialResult);
+  }
   if (command === "serve") {
     const host = takeFlag(args, "--host") || "127.0.0.1";
     const port = Number(takeFlag(args, "--port") || "0");
@@ -6564,14 +6842,23 @@ async function handleCli(inputArgs, ctx = {}) {
     });
     await client.start();
     console.log(`Edge Book dial-out connected to ${hostUrl}${notifyCmd ? " (notify hook active)" : ""}`);
+    const disabled = takeBoolFlag(args, "--no-cron-install") || process.env.EDGE_BOOK_NO_CRON_INSTALL === "1";
     try {
-      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") 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) {
       console.log(`  \u21B3 notifier cron install skipped: ${e instanceof Error ? e.message : String(e)}`);
     }
+    try {
+      if ((await store2.config()).greeter_mode === true) {
+        const res = ensureGreeterCron({ runner: defaultHermesRunner(), home, disabled });
+        if (res.status === "installed") console.log(`  \u21B3 greeter cron self-installed ("Edge Book \u2014 greeter", every 5m)`);
+        else if (res.status === "error") console.log(`  \u21B3 greeter cron install skipped: ${res.detail}`);
+      }
+    } catch (e) {
+      console.log(`  \u21B3 greeter cron install skipped: ${e instanceof Error ? e.message : String(e)}`);
+    }
     await new Promise(() => void 0);
   }
   if (command === "ensure-notifier") {
@@ -6586,6 +6873,14 @@ async function handleCli(inputArgs, ctx = {}) {
     };
     return { text: msg[res.status] ?? res.status, json: res };
   }
+  if (command === "greeter") {
+    const on = takeBoolFlag(args, "--on");
+    const off = takeBoolFlag(args, "--off");
+    if (on && off) throw new EdgeBookError("bad_flags", "greeter takes either --on or --off, not both");
+    if (!on && !off) throw new EdgeBookError("missing_arg", "greeter needs --on or --off");
+    const cfg = await store.updateConfig({ greeter_mode: on ? true : false });
+    return { text: `greeter_mode = ${cfg.greeter_mode}`, json: cfg };
+  }
   if (command === "pair") {
     const hostUrl = parseHost(args, ctx);
     const ttlMs = Number(takeFlag(args, "--ttl-ms") || `${5 * 60 * 1e3}`);
@@ -6622,6 +6917,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") {
@@ -6646,8 +6982,14 @@ ${JSON.stringify(result, null, 2)}`, json: result };
   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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edge-book",
-  "version": "0.12.4",
+  "version": "0.14.0",
   "description": "Run your own Edge Book agent and connect it to the hosted reader.",
   "license": "MIT",
   "type": "module",