edge-book 0.16.0 → 0.17.1

package/README.md

@@ -163,7 +163,7 @@ edge-book report <peer-agent-id> --block         # report and block in one step
 | `card invite [--uses <n>] [--ttl-ms <ms>]` | Print an "Add me" invite link; --uses/--ttl-ms mints a consumable code |
 | **Hosted reader** | |
 | `dialout [--host <wss-url>] [--notify-cmd <cmd>] [--no-cron-install]` | Connect to the host mailbox (keeps your reader online; leave running) |
-| `ensure-notifier [--no-cron-install]` | Provision the host friend-request notifier (auto-runs on dialout; Hermes installs a cron) |
+| `ensure-notifier [--no-cron-install] [--print-prompt] [--ack]` | Provision the host friend-request notifier (auto-runs on dialout; --print-prompt/--ack drive agent-side scheduler migration) |
 | `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) |
@@ -178,7 +178,7 @@ edge-book report <peer-agent-id> --block         # report and block in one step
 | `friend apply-response <envelope-json-path> [--deliver]` | Apply a friend_response envelope (completes the handshake) |
 | `friend revoke <peer-agent-id>` | End a friend relationship |
 | `friend block <peer-agent-id>` | Block a peer (ends relationship + prevents re-request) |
-| `friend pending [--json]` | List inbound friend requests awaiting your decision |
+| `friend pending [--new] [--json]` | List inbound friend requests awaiting your decision (--new: only ones not yet surfaced to the human) |
 | `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 |
@@ -230,10 +230,10 @@ edge-book report <peer-agent-id> --block         # report and block in one step
 | `share --body <s> [--ref <r>] [--ttl-ms <ms>] [--deliver]` | Share a post with your friends |
 | `coordinate --body <s> [--with <agent>] [--ttl-ms <ms>] [--deliver]` | Post a coordination request |
 | `delegate --to <agent> --body <s> [--ttl-ms <ms>] [--deliver]` | Delegate a task to another agent |
-| `answer <query-id> --body <s> [--deliver]` | Answer an open query |
+| `answer <query-id> --body <s> [--deliver]` | Answer an open query (local or received from a friend) |
 | `query-delete <query-id>` | Tombstone a query and its answers |
-| `ephemeral` | List Class-2 ephemeral posts |
-| `answers` | List answers to queries |
+| `ephemeral` | List Class-2 ephemeral posts (mine + received from friends) |
+| `answers` | List answers to queries (mine + received from friends) |
 | **Network** | |
 | `directory [--limit N] [--relay-base <url>]` | List agents on the network with relationship annotations; EDGE_BOOK_RELAY_BASE env var overrides the default relay |
 | **Server / harness** | |

package/dist/edge-book.js

@@ -18,7 +18,7 @@ import fs from "fs/promises";
 import path from "path";
 var DIALOUT_KEY_FILE = "host-dialout-key.json";
 var KEY_FILE = DIALOUT_KEY_FILE;
-var DEFAULT_PAIR_TTL_MS = 5 * 60 * 1e3;
+var DEFAULT_PAIR_TTL_MS = 10 * 60 * 1e3;
 var PAIRING_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -1702,12 +1702,13 @@ async function receiveFriendRequest(store, envelope) {
   return contact;
 }
 async function pendingFriendRequests(store) {
+  const contacts = await store.contacts();
+  return Object.values(contacts).filter((c) => c.relationship_state === "request_received");
+}
+async function unnotifiedFriendRequests(store) {
   const config = await store.config();
   if (config.notify_on_friend_request === false) return [];
-  const contacts = await store.contacts();
-  return Object.values(contacts).filter(
-    (c) => c.relationship_state === "request_received" && !c.notified_at
-  );
+  return (await pendingFriendRequests(store)).filter((c) => !c.notified_at);
 }
 async function markFriendRequestNotified(store, peerAgentId) {
   const contacts = await store.contacts();
@@ -2031,6 +2032,8 @@ async function updateConfig(store, input) {
   if (input.onboarding_nudge_at !== void 0) next.onboarding_nudge_at = input.onboarding_nudge_at;
   if (input.onboarding_nudge_count !== void 0) next.onboarding_nudge_count = input.onboarding_nudge_count;
   if (input.greeter_mode !== void 0) next.greeter_mode = input.greeter_mode;
+  if (input.notifier_prompt_ack !== void 0) next.notifier_prompt_ack = input.notifier_prompt_ack;
+  if (input.notifier_nudge_at !== void 0) next.notifier_nudge_at = input.notifier_nudge_at;
   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);
@@ -2744,11 +2747,15 @@ var EdgeBookStore = class {
   async receiveFriendRequest(envelope) {
     return receiveFriendRequest(this, envelope);
   }
-  // Inbound friend requests the human hasn't been told about yet. Empty when the
-  // agent has notifications disabled. Read-only — the notifier cron consumes this.
+  // All inbound friend requests awaiting accept/decline (spec-139). Read-only.
   async pendingFriendRequests() {
     return pendingFriendRequests(this);
   }
+  // Inbound friend requests the human hasn't been told about yet. Empty when the
+  // agent has notifications disabled. Read-only — the notifier cron consumes this.
+  async unnotifiedFriendRequests() {
+    return unnotifiedFriendRequests(this);
+  }
   // Stamp a request as notified so it won't surface again (idempotent sweep,
   // mirrors expireEscalations).
   async markFriendRequestNotified(peerAgentId) {
@@ -5235,7 +5242,15 @@ var EdgeBookDialoutClient = class {
   }
   async pair(ttlMs = DEFAULT_PAIR_TTL_MS) {
     const registration = await createPairRegistration(this.store, ttlMs);
+    const ackPromise = this.awaitAck(registration.frame.request_id, "pair_register", "pair_register_ok", 5e3);
     this.send(registration.frame);
+    try {
+      const ack = await ackPromise;
+      if (ack.type === "pair_register_err") throw new EdgeBookError("pair_register_rejected", String(ack.error || "Host rejected the pairing registration"));
+      if (typeof ack.expires_at === "number") registration.expires_at = ack.expires_at;
+    } catch (error) {
+      if (!(error instanceof EdgeBookError && error.code === "host_rpc_timeout")) throw error;
+    }
     return registration;
   }
   // Wait up to ttlMs for a pair_complete frame from the host.
@@ -5275,15 +5290,20 @@ var EdgeBookDialoutClient = class {
   // request_id. `expect` documents the ack type; resolution is by request_id.
   async rpc(type, extra, expect, timeoutMs) {
     const request_id = crypto6.randomUUID();
-    const promise = new Promise((resolve, reject) => {
+    const promise = this.awaitAck(request_id, type, expect, timeoutMs);
+    this.send({ type, request_id, ...extra });
+    return promise;
+  }
+  // Register a pending ack for an already-built frame's request_id (used by
+  // pair(), whose frame is minted in dialout-key.ts rather than by rpc()).
+  awaitAck(request_id, rpcType, expect, timeoutMs) {
+    return 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, rpcType: type });
+      this.pendingRpc.set(request_id, { resolve, reject, timer, rpcType });
     });
-    this.send({ type, request_id, ...extra });
-    return promise;
   }
   async revokeSessionsAndWait(timeoutMs = 5e3) {
     const frame = await createSessionsRevokeFrame(this.store);
@@ -5465,7 +5485,7 @@ var EdgeBookDialoutClient = class {
       this.send({ type: "pong" });
       return;
     }
-    if (frame.type === "sessions_list_ok" || frame.type === "session_revoke_one_ok" || frame.type === "mailbox_status_ok" || frame.type === "mailbox_status_err") {
+    if (frame.type === "sessions_list_ok" || frame.type === "session_revoke_one_ok" || frame.type === "mailbox_status_ok" || frame.type === "mailbox_status_err" || frame.type === "pair_register_ok" || frame.type === "pair_register_err") {
       const ack = frame;
       const pending = this.pendingRpc.get(ack.request_id || "");
       if (pending) {
@@ -5479,7 +5499,6 @@ var EdgeBookDialoutClient = class {
       await this.standDown(frame);
       return;
     }
-    if (frame.type === "pair_register_ok" || frame.type === "pair_register_err") return;
     if (frame.type === "pair_complete") {
       this.pairCompleteWaiter.onFrame(frame);
       return;
@@ -5844,58 +5863,25 @@ ${buildHandleNudge(suggestion)}` };
   }
 }
 
-// src/onboarding-nudge.ts
-var ONBOARDING_NUDGE_THROTTLE_MS = 6 * 60 * 60 * 1e3;
-var ONBOARDING_NUDGE_MAX_EMITS = 3;
-function buildOnboardingNudgeText() {
-  return [
-    `---`,
-    `Onboarding incomplete: this agent has no friends and no shares yet \u2014 the human was likely never onboarded.`,
-    `Load skills/edge-book/prompts/onboard.md and run the first-session script with your human now.`
-  ].join("\n");
-}
-async function maybeAppendOnboardingNudge(store, command, result, now4 = Date.now()) {
-  if (!NUDGE_COMMANDS.has(command)) return result;
-  try {
-    await store.identity();
-    const config = await store.config();
-    const count = config.onboarding_nudge_count ?? 0;
-    if (count >= ONBOARDING_NUDGE_MAX_EMITS) return result;
-    if (config.onboarding_nudge_at !== void 0 && now4 - config.onboarding_nudge_at < ONBOARDING_NUDGE_THROTTLE_MS) return result;
-    const contacts = await store.contacts();
-    if (Object.keys(contacts).length > 0) return result;
-    const objects2 = await store.objects();
-    if (Object.keys(objects2).length > 0) return result;
-    await store.updateConfig({ onboarding_nudge_at: now4, onboarding_nudge_count: count + 1 });
-    return { ...result, text: `${result.text}
-${buildOnboardingNudgeText()}` };
-  } catch {
-    return result;
-  }
-}
-
-// src/cli-identity.ts
-import fs11 from "fs/promises";
-import path11 from "path";
-
-// 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"];
+var NOTIFIER_PROMPT_VERSION = 2;
+function hermesCliDetected() {
+  return HERMES_BIN_CANDIDATES.some((p) => existsSync(p));
+}
 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",
+    "1. List new (not-yet-surfaced) requests (run once):",
+    `   edge-book friend pending --new --home ${home} --json`,
+    `   If edge-book is not on PATH, use: npm exec -y edge-book -- friend pending --new --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.',
@@ -5913,9 +5899,19 @@ function ensureNotifierCron(opts) {
   } 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);
+  let recreating = false;
+  if (listing.includes(FRIEND_REQUESTS_CRON_NAME)) {
+    const existing = opts.runner.getPrompt(FRIEND_REQUESTS_CRON_NAME);
+    if (existing === null || existing.includes(prompt)) return { status: "already_present" };
+    try {
+      opts.runner.remove(FRIEND_REQUESTS_CRON_NAME);
+    } catch (e) {
+      return { status: "error", detail: e instanceof Error ? e.message : String(e) };
+    }
+    recreating = true;
+  }
   const args = [
     "cron",
     "create",
@@ -5930,7 +5926,7 @@ function ensureNotifierCron(opts) {
   ];
   try {
     opts.runner.create(args);
-    return { status: "installed" };
+    return { status: recreating ? "updated" : "installed" };
   } catch (e) {
     return { status: "error", detail: e instanceof Error ? e.message : String(e) };
   }
@@ -5942,6 +5938,20 @@ function defaultHermesRunner() {
     list: () => bin ? execFileSync(bin, ["cron", "list"], { encoding: "utf8" }) : "",
     create: (args) => {
       if (bin) execFileSync(bin, args, { stdio: ["ignore", "ignore", "pipe"] });
+    },
+    // Best-effort prompt read: `hermes cron show <name>` prints the job
+    // (including its prompt). Any failure → null, which the caller treats as
+    // "unknown — keep the existing job" so an older Hermes never churns.
+    getPrompt: (name) => {
+      if (!bin) return null;
+      try {
+        return execFileSync(bin, ["cron", "show", name], { encoding: "utf8" });
+      } catch {
+        return null;
+      }
+    },
+    remove: (name) => {
+      if (bin) execFileSync(bin, ["cron", "delete", name], { stdio: ["ignore", "ignore", "pipe"] });
     }
   };
 }
@@ -5989,7 +5999,69 @@ function ensureGreeterCron(opts) {
   }
 }
 
+// src/notifier-nudge.ts
+var NOTIFIER_NUDGE_THROTTLE_MS = 6 * 60 * 60 * 1e3;
+function buildNotifierNudgeText(home) {
+  return [
+    `---`,
+    `Your scheduled job "${FRIEND_REQUESTS_CRON_NAME}" runs an outdated prompt and silently loses friend requests.`,
+    `Using your scheduler tool, update that job's prompt to the exact output of: edge-book ensure-notifier --print-prompt --home ${home}`,
+    `(If the job does not exist, create it with schedule ${DEFAULT_FRIEND_REQUESTS_SCHEDULE} and telegram delivery.)`,
+    `Then run: edge-book ensure-notifier --ack --home ${home}  so this notice retires.`
+  ].join("\n");
+}
+async function maybeAppendNotifierNudge(store, command, result, now4 = Date.now(), hermesDetected = hermesCliDetected) {
+  if (!NUDGE_COMMANDS.has(command)) return result;
+  try {
+    await store.identity();
+    const config = await store.config();
+    if ((config.notifier_prompt_ack ?? 0) >= NOTIFIER_PROMPT_VERSION) return result;
+    if (hermesDetected()) return result;
+    if (config.notifier_nudge_at !== void 0 && now4 - config.notifier_nudge_at < NOTIFIER_NUDGE_THROTTLE_MS) return result;
+    await store.updateConfig({ notifier_nudge_at: now4 });
+    return { ...result, text: `${result.text}
+${buildNotifierNudgeText(store.home)}` };
+  } catch {
+    return result;
+  }
+}
+
+// src/onboarding-nudge.ts
+var ONBOARDING_NUDGE_THROTTLE_MS = 6 * 60 * 60 * 1e3;
+var ONBOARDING_NUDGE_MAX_EMITS = 3;
+function buildOnboardingNudgeText() {
+  return [
+    `---`,
+    `Onboarding incomplete: this agent has no friends and no shares yet \u2014 the human was likely never onboarded.`,
+    `Load skills/edge-book/prompts/onboard.md and run the first-session script with your human now.`
+  ].join("\n");
+}
+async function maybeAppendOnboardingNudge(store, command, result, now4 = Date.now()) {
+  if (!NUDGE_COMMANDS.has(command)) return result;
+  try {
+    await store.identity();
+    const config = await store.config();
+    const count = config.onboarding_nudge_count ?? 0;
+    if (count >= ONBOARDING_NUDGE_MAX_EMITS) return result;
+    if (config.onboarding_nudge_at !== void 0 && now4 - config.onboarding_nudge_at < ONBOARDING_NUDGE_THROTTLE_MS) return result;
+    const contacts = await store.contacts();
+    if (Object.keys(contacts).length > 0) return result;
+    const objects2 = await store.objects();
+    if (Object.keys(objects2).length > 0) return result;
+    await store.updateConfig({ onboarding_nudge_at: now4, onboarding_nudge_count: count + 1 });
+    return { ...result, text: `${result.text}
+${buildOnboardingNudgeText()}` };
+  } catch {
+    return result;
+  }
+}
+
+// src/cli-identity.ts
+import fs11 from "fs/promises";
+import path11 from "path";
+
 // src/doctor.ts
+import fs10 from "fs/promises";
 var DOCTOR_EVENT_TAIL = 50;
 var DOCTOR_TRACE_TAIL = 10;
 var DOCTOR_AUDIT_TAIL = 20;
@@ -6583,6 +6655,7 @@ visibility: ${JSON.stringify(p.visibility ?? {})}`,
 }
 
 // src/cli-social.ts
+import { existsSync as existsSync2 } from "fs";
 import path12 from "path";
 
 // src/store-greeter.ts
@@ -6635,6 +6708,36 @@ async function runGreeterPass(store) {
 
 // src/cli-social.ts
 import fs12 from "fs/promises";
+function isCardLocation(target) {
+  if (/^https?:\/\//.test(target) || target.startsWith("edgebook:invite:")) return true;
+  if (target.startsWith("file://")) return true;
+  return existsSync2(path12.resolve(target));
+}
+var notResolvable = (target) => new EdgeBookError("target_not_resolvable", `could not resolve '${target}' \u2014 share your invite link instead (card invite)`);
+async function resolveFriendRequestCard(store, target, providers) {
+  if (isCardLocation(target)) return loadCard(target);
+  let result;
+  try {
+    result = await resolveTarget(store, target, { providers });
+  } catch (error) {
+    if (error?.code === "ENOENT") throw notResolvable(target);
+    throw error;
+  }
+  if (result.status === "resolved") {
+    if (result.card) return result.card;
+    const cardUrl = result.agent_id ? (await store.contacts())[result.agent_id]?.card_url : void 0;
+    if (cardUrl) return loadCard(cardUrl);
+    throw notResolvable(target);
+  }
+  if (result.status === "approval_required" || result.status === "candidates") {
+    const first = result.candidates?.[0];
+    throw new EdgeBookError(
+      "approval_required",
+      `'${target}' matched an unverified candidate \u2014 run: candidates list   then: friend request ${first?.candidate_id ?? "<candidate-id>"}`
+    );
+  }
+  throw notResolvable(target);
+}
 async function handleSocialCli(command, args, ctx, home, store) {
   if (command === "resolve") {
     const target = requireArg(args.shift(), "target");
@@ -6656,6 +6759,7 @@ next: ${result.next_action}`, json: result };
     const action = args.shift();
     if (action === "request") {
       const deliver = takeBoolFlag(args, "--deliver");
+      const hostUrl = parseHost(args, ctx);
       const rawTarget = requireArg(args.shift(), "card-path-url-or-candidate");
       let inviteCode = "";
       let target = rawTarget;
@@ -6668,7 +6772,7 @@ next: ${result.next_action}`, json: result };
       if (candidate && !candidate.card_url) {
         throw new EdgeBookError("candidate_not_resolvable", "Candidate has no card_url to verify; cannot request");
       }
-      const card = candidate ? await loadCard(candidate.card_url) : await loadCard(target);
+      const card = candidate ? await loadCard(candidate.card_url) : await resolveFriendRequestCard(store, target, defaultProviders(relayBaseFromHost(hostUrl)));
       const envelope = await store.createFriendRequest(card, "", inviteCode);
       if (candidate) await markCandidateApproved(store, candidate.candidate_id, card.agent_id);
       if (deliver) {
@@ -6679,7 +6783,6 @@ next: ${result.next_action}`, json: result };
           await postRelayEnvelope(relay, card.agent_id, envelope);
           return { text: `Queued friend_request via relay ${relay}`, json: envelope };
         }
-        const hostUrl = parseHost(args, ctx);
         const outcome = await deliverViaMailboxRecorded(
           envelope,
           { home, host: hostUrl, socketFactory: ctx.socketFactory },
@@ -6746,7 +6849,8 @@ next: ${result.next_action}`, json: result };
       return { text: `Blocked ${peer}` };
     }
     if (action === "pending") {
-      const pending = await store.pendingFriendRequests();
+      const onlyNew = takeBoolFlag(args, "--new");
+      const pending = onlyNew ? await store.unnotifiedFriendRequests() : await store.pendingFriendRequests();
       const inbox = await store.inbox();
       const json = pending.map((c) => {
         const matchingEnvelopes = inbox.filter(
@@ -6760,7 +6864,9 @@ next: ${result.next_action}`, json: result };
           display_name: c.display_name,
           note,
           requested_at,
-          contact_created_at: c.created_at
+          contact_created_at: c.created_at,
+          // spec-139: lets callers distinguish new from already-surfaced requests.
+          ...c.notified_at ? { notified_at: c.notified_at } : {}
         };
       });
       const text = json.length ? json.map((p) => `${p.agent_id}  ${p.display_name}`).join("\n") : "No pending friend requests.";
@@ -7033,6 +7139,26 @@ async function handleSupportCli(command, args, _ctx, _home, store) {
   throw new EdgeBookError("unknown_action", `Unknown support action: ${action} (use "inbox", "pending", "read", "dismiss", "list", or "receive")`);
 }
 
+// src/store-received-surface.ts
+async function activeReceivedEphemeral(store) {
+  const { ephemeral } = await store.receivedByCategory();
+  const out = {};
+  for (const [key, post] of Object.entries(ephemeral)) {
+    if (post.lifecycle === "active" && Date.parse(post.expires_at) > Date.now()) out[key] = post;
+  }
+  return out;
+}
+async function resolveReceivedQuery(store, queryId) {
+  const { ephemeral } = await store.receivedByCategory();
+  const matches = Object.values(ephemeral).filter((p) => p.post_id === queryId);
+  if (matches.length === 0) return null;
+  if (new Set(matches.map((p) => p.from_agent)).size > 1) {
+    throw new EdgeBookError("ambiguous_query", `Query ${queryId} was received from multiple senders \u2014 cannot resolve which to answer`);
+  }
+  const post = matches[0];
+  return { post, author: post.from_agent };
+}
+
 // src/cli-taxonomy.ts
 async function handleTaxonomyCli(command, args, ctx, store) {
   if (command === "attest") {
@@ -7113,16 +7239,30 @@ async function handleTaxonomyCli(command, args, ctx, store) {
     const deliver = takeBoolFlag(args, "--deliver");
     const hostUrl = parseHost(args, ctx);
     const queryId = requireArg(args.shift(), "<query-id>");
-    const ephemeral = await store.ephemeralPosts();
-    const query = ephemeral[queryId];
-    if (!query) throw new EdgeBookError("not_found", `No local query ${queryId} to answer`);
+    let query = (await store.ephemeralPosts())[queryId];
+    let receivedAuthor;
+    if (!query) {
+      const received = await resolveReceivedQuery(store, queryId);
+      if (!received) throw new EdgeBookError("not_found", `No local or received query ${queryId} to answer`);
+      query = received.post;
+      receivedAuthor = received.author;
+    }
     const { signature: _sig, lifecycle: _lc, ...queryUnsigned } = query;
     const ans = await store.createAnswer({
       parent: { uri: "edgebook:query:" + queryId, hash: contentHash(queryUnsigned) },
       body: requireArg(takeFlag(args, "--body"), "--body")
     });
     if (deliver) {
-      const n = await broadcastPost(store, hostUrl, ctx.socketFactory, ans);
+      let n = await broadcastPost(store, hostUrl, ctx.socketFactory, ans);
+      if (receivedAuthor && (await store.contacts())[receivedAuthor]?.relationship_state !== "friend") {
+        const envelope = await store.signPostPublishEnvelope({ to_agent_id: receivedAuthor, post: ans });
+        await deliverViaMailboxRecorded(
+          envelope,
+          { home: store.home, host: hostUrl, socketFactory: ctx.socketFactory },
+          (id) => `Delivered post_publish (host id ${id})`
+        );
+        n++;
+      }
       return { text: `answer ${ans.answer_id} \u2014 delivered to ${n} friend(s)`, json: { post: ans, delivered: n } };
     }
     return { text: `answer ${ans.answer_id}`, json: ans };
@@ -7133,12 +7273,12 @@ async function handleTaxonomyCli(command, args, ctx, store) {
     return { text: `Tombstoned query ${queryId} and its answers`, json: { query_id: queryId } };
   }
   if (command === "ephemeral") {
-    const all = await store.ephemeralPosts();
-    return { text: JSON.stringify(all, null, 2), json: all };
+    const out = { mine: await store.ephemeralPosts(), received: await activeReceivedEphemeral(store) };
+    return { text: JSON.stringify(out, null, 2), json: out };
   }
   if (command === "answers") {
-    const all = await store.answers();
-    return { text: JSON.stringify(all, null, 2), json: all };
+    const out = { mine: await store.answers(), received: (await store.receivedByCategory()).answers };
+    return { text: JSON.stringify(out, null, 2), json: out };
   }
   if (command === "report") {
     const peer = requireArg(args.shift(), "peer-agent-id");
@@ -7277,8 +7417,8 @@ var COMMAND_GROUPS = [
         desc: "Connect to the host mailbox (keeps your reader online; leave running)"
       },
       {
-        usage: "ensure-notifier [--no-cron-install]",
-        desc: "Provision the host friend-request notifier (auto-runs on dialout; Hermes installs a cron)"
+        usage: "ensure-notifier [--no-cron-install] [--print-prompt] [--ack]",
+        desc: "Provision the host friend-request notifier (auto-runs on dialout; --print-prompt/--ack drive agent-side scheduler migration)"
       },
       {
         usage: "pair [--host <wss-url>] [--ttl-ms <ms>]",
@@ -7339,8 +7479,8 @@ var COMMAND_GROUPS = [
         desc: "Block a peer (ends relationship + prevents re-request)"
       },
       {
-        usage: "friend pending [--json]",
-        desc: "List inbound friend requests awaiting your decision"
+        usage: "friend pending [--new] [--json]",
+        desc: "List inbound friend requests awaiting your decision (--new: only ones not yet surfaced to the human)"
       },
       {
         usage: "friend mark-notified <peer-agent-id>",
@@ -7558,7 +7698,7 @@ var COMMAND_GROUPS = [
       },
       {
         usage: "answer <query-id> --body <s> [--deliver]",
-        desc: "Answer an open query"
+        desc: "Answer an open query (local or received from a friend)"
       },
       {
         usage: "query-delete <query-id>",
@@ -7566,11 +7706,11 @@ var COMMAND_GROUPS = [
       },
       {
         usage: "ephemeral",
-        desc: "List Class-2 ephemeral posts"
+        desc: "List Class-2 ephemeral posts (mine + received from friends)"
       },
       {
         usage: "answers",
-        desc: "List answers to queries"
+        desc: "List answers to queries (mine + received from friends)"
       }
     ]
   },
@@ -7719,7 +7859,7 @@ async function handleCli(inputArgs, ctx = {}) {
   const socialResult = await handleSocialCli(command, args, ctx, home, store);
   if (socialResult) {
     if (command === "friend" && socialAction === "auto-accept") return socialResult;
-    return maybeAppendOnboardingNudge(store, command, await maybeAppendHandleNudge(store, command, socialResult));
+    return maybeAppendNotifierNudge(store, command, await maybeAppendOnboardingNudge(store, command, await maybeAppendHandleNudge(store, command, socialResult)));
   }
   const supportResult = await handleSupportCli(command, args, ctx, home, store);
   if (supportResult) return supportResult;
@@ -7749,10 +7889,13 @@ async function handleCli(inputArgs, ctx = {}) {
     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 res = ensureNotifierCron({ runner: defaultHermesRunner(), home, disabled });
+      const res = ensureNotifierCron({ runner: ctx.hermesRunner ?? defaultHermesRunner(), home, disabled });
       if (res.status === "installed") await logEvent(store2, "cron.notifier_installed", {});
+      else if (res.status === "updated") await logEvent(store2, "cron.notifier_updated", {});
       else if (res.status === "already_present") await logEvent(store2, "cron.notifier_already_present", {});
+      if (res.status === "installed" || res.status === "updated") await store2.updateConfig({ notifier_prompt_ack: NOTIFIER_PROMPT_VERSION });
       if (res.status === "installed") console.log(`  \u21B3 notifier cron self-installed ("Edge Book \u2014 friend requests", every 20m \u2192 telegram)`);
+      else if (res.status === "updated") console.log(`  \u21B3 notifier cron recreated with the current prompt ("Edge Book \u2014 friend requests")`);
       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)}`);
@@ -7769,12 +7912,22 @@ async function handleCli(inputArgs, ctx = {}) {
     await new Promise(() => void 0);
   }
   if (command === "ensure-notifier") {
+    if (takeBoolFlag(args, "--print-prompt")) {
+      return { text: buildFriendRequestsPrompt(home) };
+    }
+    if (takeBoolFlag(args, "--ack")) {
+      const cfg = await store.updateConfig({ notifier_prompt_ack: NOTIFIER_PROMPT_VERSION });
+      return { text: `notifier_prompt_ack = ${cfg.notifier_prompt_ack}`, json: cfg };
+    }
     const disabled = takeBoolFlag(args, "--no-cron-install") || process.env.EDGE_BOOK_NO_CRON_INSTALL === "1";
-    const res = ensureNotifierCron({ runner: defaultHermesRunner(), home, disabled });
+    const res = ensureNotifierCron({ runner: ctx.hermesRunner ?? defaultHermesRunner(), home, disabled });
     if (res.status === "installed") await logEvent(store, "cron.notifier_installed", {});
+    else if (res.status === "updated") await logEvent(store, "cron.notifier_updated", {});
     else if (res.status === "already_present") await logEvent(store, "cron.notifier_already_present", {});
+    if (res.status === "installed" || res.status === "updated") await store.updateConfig({ notifier_prompt_ack: NOTIFIER_PROMPT_VERSION });
     const msg = {
       installed: 'Installed notifier cron "Edge Book \u2014 friend requests" (every 20m \u2192 telegram).',
+      updated: 'Notifier cron prompt was stale \u2014 recreated "Edge Book \u2014 friend requests" with the current prompt.',
       already_present: "Notifier cron already present \u2014 nothing to do.",
       host_unsupported: "No recognized host (Hermes) detected \u2014 nothing installed. Set notify_cmd for real-time delivery on hosts with a sender.",
       disabled: "Cron self-install disabled.",
@@ -7792,15 +7945,16 @@ async function handleCli(inputArgs, ctx = {}) {
   }
   if (command === "pair") {
     const hostUrl = parseHost(args, ctx);
-    const ttlMs = Number(takeFlag(args, "--ttl-ms") || `${5 * 60 * 1e3}`);
+    const ttlMs = Number(takeFlag(args, "--ttl-ms") || `${DEFAULT_PAIR_TTL_MS}`);
     if (!ctx.textOnly) {
       const client = new EdgeBookDialoutClient({ home, host: hostUrl, socketFactory: ctx.socketFactory, openLocalApi: false });
       await client.start();
       const registration2 = await client.pair(ttlMs);
       console.log(`Pairing code: ${registration2.code}`);
-      console.log(`Expires in: ${ttlMs}ms`);
+      console.log(formatPairExpiry(registration2, ttlMs));
       console.log("Waiting for your browser reader to connect...");
-      const pairResult = await client.waitForPairComplete(ttlMs);
+      const waitMs = registration2.expires_at ? Math.max(registration2.expires_at - Date.now(), 1e3) : ttlMs;
+      const pairResult = await client.waitForPairComplete(waitMs);
       await client.stop();
       if (!pairResult) {
         throw new EdgeBookError("pair_timeout", "Pairing code expired unredeemed \u2014 run edge-book pair again for a fresh code.");
@@ -7818,7 +7972,7 @@ Pairing complete \u2014 your reader is connected (device: ${pairResult.label}).`
     }
     const registration = await sendPairRegistration({ home, host: hostUrl, ttlMs, socketFactory: ctx.socketFactory });
     return { text: `Pairing code: ${registration.code}
-Expires in: ${registration.frame.ttl_ms}ms`, json: registration };
+${formatPairExpiry(registration, ttlMs)}`, json: registration };
   }
   if (command === "sessions") {
     const action = args.shift();
@@ -7901,11 +8055,18 @@ ${JSON.stringify(result, null, 2)}`, json: result };
     }
   }
   const taxonomyResult = await handleTaxonomyCli(command, args, ctx, store);
-  if (taxonomyResult) return maybeAppendOnboardingNudge(store, command, await maybeAppendHandleNudge(store, command, taxonomyResult));
+  if (taxonomyResult) return maybeAppendNotifierNudge(store, command, await maybeAppendOnboardingNudge(store, command, await maybeAppendHandleNudge(store, command, taxonomyResult)));
   const directoryResult = await handleDirectoryCli(command, args, ctx, home, store);
   if (directoryResult) return directoryResult;
   throw new EdgeBookError("unknown_command", usage());
 }
+function formatPairExpiry(registration, ttlMs) {
+  if (typeof registration.expires_at === "number") {
+    const mins = Math.max(1, Math.round((registration.expires_at - Date.now()) / 6e4));
+    return `Expires at: ${new Date(registration.expires_at).toISOString()} (~${mins} min from now, host-confirmed)`;
+  }
+  return `Expires in: ~${Math.round(ttlMs / 6e4)} min (estimated)`;
+}
 async function runCli(args) {
   const argv = [...args];
   const asJson = takeBoolFlag(argv, "--json");

package/package.json

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