claudemesh-cli 1.34.7 → 1.34.9

package/dist/entrypoints/cli.js

@@ -104,7 +104,7 @@ __export(exports_urls, {
   VERSION: () => VERSION,
   URLS: () => URLS
 });
-var URLS, VERSION = "1.34.7", env;
+var URLS, VERSION = "1.34.9", env;
 var init_urls = __esm(() => {
   URLS = {
     BROKER: process.env.CLAUDEMESH_BROKER_URL ?? "wss://ic.claudemesh.com/ws",
@@ -4052,11 +4052,18 @@ async function tryListPeersViaDaemon(mesh) {
     return null;
   }
 }
-async function tryListInboxViaDaemon(mesh, limit = 100) {
+async function tryListInboxViaDaemon(mesh, limit = 100, opts = {}) {
   if (!await daemonReachable())
     return null;
   try {
-    const path = `/v1/inbox${meshQuery(mesh)}${meshQuery(mesh) ? "&" : "?"}limit=${limit}`;
+    const params = [`limit=${limit}`];
+    if (mesh)
+      params.push(`mesh=${encodeURIComponent(mesh)}`);
+    if (opts.unreadOnly)
+      params.push("unread_only=true");
+    if (opts.markSeen === false)
+      params.push("mark_seen=false");
+    const path = `/v1/inbox?${params.join("&")}`;
     const res = await ipc({ path, timeoutMs: 3000 });
     if (res.status !== 200)
       return null;
@@ -4324,6 +4331,7 @@ async function ensureDaemonRunning(meshSlug, quiet) {
   if (res.state === "up") {
     if (!quiet)
       render.ok("daemon already running");
+    await warnIfDaemonStale(quiet);
     return;
   }
   if (res.state === "started") {
@@ -4333,6 +4341,21 @@ async function ensureDaemonRunning(meshSlug, quiet) {
   }
   render.warn(`daemon ${res.state}${res.reason ? `: ${res.reason}` : ""}`, "Run `claudemesh daemon up --mesh " + meshSlug + "` manually, then re-launch.");
 }
+async function warnIfDaemonStale(quiet) {
+  if (quiet)
+    return;
+  try {
+    const { ipc: ipc2 } = await Promise.resolve().then(() => (init_client3(), exports_client));
+    const { VERSION: VERSION2 } = await Promise.resolve().then(() => (init_urls(), exports_urls));
+    const res = await ipc2({ path: "/v1/version", timeoutMs: 1500 });
+    if (res.status !== 200)
+      return;
+    const daemonVersion = res.body.daemon_version ?? "";
+    if (!daemonVersion || daemonVersion === VERSION2)
+      return;
+    render.warn(`daemon is ${daemonVersion}, CLI is ${VERSION2} — restart to pick up new fixes.`, "Run: `claudemesh daemon down && claudemesh daemon up` (or restart the launchd / systemd-user unit).");
+  } catch {}
+}
 function parseGroupsString(raw) {
   return raw.split(",").map((s) => s.trim()).filter(Boolean).map((token) => {
     const idx = token.indexOf(":");
@@ -8380,7 +8403,10 @@ function formatMessage(msg, includeMesh) {
 }
 async function runInbox(flags) {
   const meshSlug = flags.mesh;
-  const items = await tryListInboxViaDaemon(meshSlug, flags.limit ?? 100);
+  const items = await tryListInboxViaDaemon(meshSlug, flags.limit ?? 100, {
+    unreadOnly: flags.unread === true,
+    markSeen: true
+  });
   if (items === null) {
     if (flags.json) {
       process.stdout.write(`[]
@@ -8397,10 +8423,12 @@ async function runInbox(flags) {
   }
   if (items.length === 0) {
     const scope = meshSlug ? `mesh "${meshSlug}"` : "any mesh";
-    render.info(dim(`No messages on ${scope}.`));
+    const filter = flags.unread ? "unread " : "";
+    render.info(dim(`No ${filter}messages on ${scope}.`));
     return;
   }
-  const heading = meshSlug ? `inbox — ${meshSlug} (${items.length} message${items.length === 1 ? "" : "s"})` : `inbox (${items.length} message${items.length === 1 ? "" : "s"})`;
+  const filterTag = flags.unread ? " unread" : "";
+  const heading = meshSlug ? `inbox — ${meshSlug} (${items.length}${filterTag} message${items.length === 1 ? "" : "s"})` : `inbox (${items.length}${filterTag} message${items.length === 1 ? "" : "s"})`;
   render.section(heading);
   for (const msg of items) {
     process.stdout.write(formatMessage(msg, !meshSlug) + `
@@ -9582,6 +9610,11 @@ function migrateInbox(db) {
     CREATE INDEX IF NOT EXISTS inbox_topic       ON inbox(topic);
     CREATE INDEX IF NOT EXISTS inbox_sender      ON inbox(sender_pubkey);
   `);
+  const cols = db.prepare(`PRAGMA table_info(inbox)`).all();
+  if (!cols.some((c) => c.name === "seen_at")) {
+    db.exec(`ALTER TABLE inbox ADD COLUMN seen_at INTEGER`);
+    db.exec(`CREATE INDEX IF NOT EXISTS inbox_seen_at ON inbox(seen_at)`);
+  }
 }
 function insertIfNew(db, row) {
   const before = db.prepare(`SELECT id FROM inbox WHERE client_message_id = ?`).get(row.client_message_id);
@@ -9616,9 +9649,12 @@ function listInbox(db, p) {
     where.push("mesh = ?");
     args.push(p.mesh);
   }
+  if (p.unreadOnly === true) {
+    where.push("seen_at IS NULL");
+  }
   const sql = `
     SELECT id, client_message_id, broker_message_id, mesh, topic,
-           sender_pubkey, sender_name, body, meta, received_at, reply_to_id
+           sender_pubkey, sender_name, body, meta, received_at, reply_to_id, seen_at
       FROM inbox
      ${where.length ? "WHERE " + where.join(" AND ") : ""}
      ORDER BY received_at DESC
@@ -9627,6 +9663,17 @@ function listInbox(db, p) {
   args.push(Math.min(Math.max(p.limit ?? 100, 1), 1000));
   return db.prepare(sql).all(...args);
 }
+function markInboxSeen(db, ids, now = Date.now()) {
+  if (ids.length === 0)
+    return 0;
+  const placeholders = ids.map(() => "?").join(",");
+  const r = db.prepare(`UPDATE inbox SET seen_at = ? WHERE seen_at IS NULL AND id IN (${placeholders})`).run(now, ...ids);
+  return Number(r.changes);
+}
+function pruneInboxBefore(db, cutoffMs) {
+  const r = db.prepare(`DELETE FROM inbox WHERE received_at < ?`).run(cutoffMs);
+  return Number(r.changes);
+}
 function deleteInboxRow(db, id) {
   const r = db.prepare(`DELETE FROM inbox WHERE id = ?`).run(id);
   return Number(r.changes) > 0;
@@ -10387,13 +10434,23 @@ function makeHandler(opts) {
       const limitRaw = url.searchParams.get("limit");
       const limit = limitRaw ? Number.parseInt(limitRaw, 10) : undefined;
       const meshFilter = meshFromCtx(url.searchParams.get("mesh")) ?? undefined;
+      const unreadOnly = url.searchParams.get("unread_only") === "true";
+      const markSeen = url.searchParams.get("mark_seen") !== "false";
       const rows = listInbox(opts.inboxDb, {
         since: Number.isFinite(since) ? since : undefined,
         topic,
         fromPubkey,
         ...meshFilter ? { mesh: meshFilter } : {},
+        unreadOnly,
         limit: Number.isFinite(limit ?? NaN) ? limit : undefined
       });
+      let flippedCount = 0;
+      if (markSeen) {
+        const unreadIds = rows.filter((r) => r.seen_at == null).map((r) => r.id);
+        if (unreadIds.length > 0) {
+          flippedCount = markInboxSeen(opts.inboxDb, unreadIds);
+        }
+      }
       respond(res, 200, {
         items: rows.map((r) => ({
           id: r.id,
@@ -10405,11 +10462,32 @@ function makeHandler(opts) {
           sender_name: r.sender_name,
           body: r.body,
           received_at: new Date(r.received_at).toISOString(),
-          reply_to_id: r.reply_to_id
-        }))
+          reply_to_id: r.reply_to_id,
+          seen_at: r.seen_at ? new Date(r.seen_at).toISOString() : null
+        })),
+        marked_seen: flippedCount
       });
       return;
     }
+    if (req.method === "POST" && url.pathname === "/v1/inbox/seen") {
+      if (!opts.inboxDb) {
+        respond(res, 503, { error: "inbox not initialised" });
+        return;
+      }
+      try {
+        const body = await readJsonBody(req, 64 * 1024);
+        const ids = Array.isArray(body?.ids) ? body.ids.filter((x) => typeof x === "string") : [];
+        if (ids.length === 0) {
+          respond(res, 400, { error: "missing 'ids' (string[])" });
+          return;
+        }
+        const flipped = markInboxSeen(opts.inboxDb, ids);
+        respond(res, 200, { marked_seen: flipped });
+      } catch (e) {
+        respond(res, 400, { error: String(e) });
+      }
+      return;
+    }
     if (req.method === "DELETE" && url.pathname === "/v1/inbox") {
       if (!opts.inboxDb) {
         respond(res, 503, { error: "inbox not initialised" });
@@ -11376,6 +11454,13 @@ class SessionBrokerClient {
           return;
         }
         if (msg.type === "push" || msg.type === "inbound") {
+          if (msg.subtype === "system")
+            return;
+          const senderPubkey = String(msg.senderPubkey ?? "").toLowerCase();
+          if (senderPubkey && senderPubkey === this.opts.sessionPubkey.toLowerCase()) {
+            this.log("info", "self_echo_dropped", { sender: senderPubkey.slice(0, 12) });
+            return;
+          }
           this.opts.onPush?.(msg);
           return;
         }
@@ -11667,14 +11752,58 @@ function defaultLog4(level, msg, meta) {
 var POLL_INTERVAL_MS = 500, MAX_ATTEMPTS_PER_ROW = 25, BACKOFF_BASE_MS = 500, BACKOFF_CAP_MS = 30000;
 var init_drain = () => {};
 
+// src/daemon/inbox-pruner.ts
+function startInboxPruner(opts) {
+  const retentionMs = opts.retentionMs ?? DEFAULT_RETENTION_MS;
+  const intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
+  const log2 = opts.log ?? defaultLog5;
+  const tick = () => {
+    try {
+      const cutoff = Date.now() - retentionMs;
+      const removed = pruneInboxBefore(opts.db, cutoff);
+      if (removed > 0) {
+        log2("info", "inbox_prune_completed", {
+          removed,
+          retention_days: Math.round(retentionMs / (24 * 60 * 60 * 1000))
+        });
+      }
+    } catch (e) {
+      log2("warn", "inbox_prune_failed", { err: String(e) });
+    }
+  };
+  tick();
+  const handle = setInterval(tick, intervalMs);
+  if (typeof handle.unref === "function")
+    handle.unref();
+  return { stop: () => clearInterval(handle) };
+}
+function defaultLog5(level, msg, meta) {
+  const line = JSON.stringify({ level, msg, ...meta, ts: new Date().toISOString() });
+  if (level === "info")
+    process.stdout.write(line + `
+`);
+  else
+    process.stderr.write(line + `
+`);
+}
+var DEFAULT_RETENTION_MS, DEFAULT_INTERVAL_MS;
+var init_inbox_pruner = __esm(() => {
+  DEFAULT_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+  DEFAULT_INTERVAL_MS = 60 * 60 * 1000;
+});
+
 // src/daemon/inbound.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 async function handleBrokerPush(msg, ctx) {
   if (msg.subtype === "system" && typeof msg.event === "string") {
+    const eventData = msg.eventData ?? {};
+    const eventPubkey = typeof eventData.pubkey === "string" ? eventData.pubkey : "";
+    if (eventPubkey && ctx.isOwnPubkey?.(eventPubkey))
+      return;
     ctx.bus.publish(mapSystemEventKind(msg.event), {
       mesh: ctx.meshSlug,
       event: msg.event,
-      ...msg.eventData ?? {}
+      ...eventData
     });
     return;
   }
@@ -11966,6 +12095,8 @@ async function runDaemon(opts = {}) {
   } else {
     meshes = cfg.meshes;
   }
+  const sessionBrokers = new Map;
+  const sessionBrokersByPubkey = new Map;
   const brokers = new Map;
   const meshConfigs = new Map;
   for (const mesh of meshes) {
@@ -11983,12 +12114,23 @@ async function runDaemon(opts = {}) {
         bus.publish("broker_status", { mesh: mesh.slug, status: s });
       },
       onPush: (m) => {
+        const senderMemberPk = String(m.senderMemberPubkey ?? "").toLowerCase();
+        const ownMember = mesh.pubkey.toLowerCase();
+        if (senderMemberPk && senderMemberPk === ownMember) {
+          return;
+        }
         handleBrokerPush(m, {
           db: inboxDb,
           bus,
           meshSlug: mesh.slug,
           recipientSecretKeyHex: mesh.secretKey,
-          ackClientMessage: (cmid, bmid) => broker.sendClientAck(cmid, bmid)
+          ackClientMessage: (cmid, bmid) => broker.sendClientAck(cmid, bmid),
+          isOwnPubkey: (pubkey) => {
+            const lower = pubkey.toLowerCase();
+            if (lower === ownMember)
+              return true;
+            return sessionBrokersByPubkey.has(lower);
+          }
         });
       }
     });
@@ -11996,14 +12138,13 @@ async function runDaemon(opts = {}) {
 `));
     brokers.set(mesh.slug, broker);
   }
-  const sessionBrokers = new Map;
-  const sessionBrokersByPubkey = new Map;
   let drain = null;
   drain = startDrainWorker({
     db: outboxDb,
     brokers,
     getSessionBrokerByPubkey: (pubkey) => sessionBrokersByPubkey.get(pubkey)
   });
+  const inboxPruner = startInboxPruner({ db: inboxDb });
   setRegistryHooks({
     onRegister: (info) => {
       if (!info.presence)
@@ -12107,6 +12248,7 @@ async function runDaemon(opts = {}) {
     shuttingDown = true;
     process.stdout.write(JSON.stringify({ msg: "daemon_shutdown", signal: sig, ts: new Date().toISOString() }) + `
 `);
+    inboxPruner.stop();
     if (drain)
       await drain.close();
     for (const b of brokers.values()) {
@@ -12143,6 +12285,7 @@ var init_run = __esm(() => {
   init_broker();
   init_session_broker();
   init_drain();
+  init_inbox_pruner();
   init_inbound();
   init_identity();
   init_facade();
@@ -16270,7 +16413,8 @@ claudemesh message send <p> "..." --priority low       # pull-only
 claudemesh inbox                                       # all attached meshes, last 100
 claudemesh inbox --mesh <slug>                         # scoped to one mesh
 claudemesh inbox --mesh <slug> --limit 20              # custom cap
-claudemesh inbox --json                                # full row (sender_pubkey, mesh, body, received_at, …)
+claudemesh inbox --json                                # full row (sender_pubkey, mesh, body, received_at, seen_at, …)
+claudemesh inbox --unread                              # 1.34.8+ only rows whose seen_at IS NULL
 
 # inbox flush + delete — 1.34.7+
 claudemesh inbox flush --mesh <slug>                   # delete all rows on one mesh
@@ -16286,6 +16430,12 @@ claudemesh message status <message-id> --json
 
 **Inbox source (1.34.0+):** \`claudemesh inbox\` queries the daemon's persistent \`~/.claudemesh/daemon/inbox.db\` over IPC — it is NOT a fresh broker-WS buffer drain. Rows survive daemon restarts. Sender attribution is the actual session pubkey of the launched session that originated the send (NOT the stable member pubkey of the sender's daemon), so two sibling sessions of the same human appear as distinct rows.
 
+**Read-state (1.34.8+):** every inbox row carries a \`seen_at\` timestamp. \`null\` = never surfaced; an ISO string = first surfaced at that moment. The flag flips automatically when (a) the row is returned by an interactive \`claudemesh inbox\` listing, or (b) the MCP server emits a live \`<channel>\` reminder for it. The launch welcome push uses \`unread_only=true\` to surface only rows the user hasn't seen — so a session relaunched a day later sees what it actually missed, not the same 24h batch every time. Use \`claudemesh inbox --unread\` to get the same filter from the CLI.
+
+**Self-echo guard (1.34.8+):** broker fan-out paths sometimes mirror an outbound DM back to the originating session-WS. The daemon now drops those at the WS boundary (matching on \`senderPubkey === own.session_pubkey\`), so the sender no longer sees their own \`claudemesh send\` arrive as a \`← claudemesh: <self>: ...\` channel push immediately after dispatching it.
+
+**Inbox TTL (1.34.8+):** the daemon runs an hourly prune that deletes rows older than 30 days. Without this the inbox grew unbounded; now it self-trims while preserving "I went on holiday and want to see what I missed" recovery for a generous window. No CLI knob — it's a built-in retention policy. To override, manually \`claudemesh inbox flush --before <iso>\`.
+
 \`send\` JSON output: \`{"ok": true, "messageId": "...", "target": "..."}\`. Errors: \`{"ok": false, "error": "..."}\`.
 
 ### \`state\` — shared per-mesh key-value store
@@ -18389,6 +18539,32 @@ function daemonGet(path2, opts = {}) {
     req.end();
   });
 }
+function daemonMarkSeen(ids, sessionToken) {
+  return new Promise((resolve3) => {
+    if (ids.length === 0) {
+      resolve3();
+      return;
+    }
+    const body = JSON.stringify({ ids });
+    const headers = {
+      "Content-Type": "application/json",
+      "Content-Length": String(Buffer.byteLength(body))
+    };
+    if (sessionToken)
+      headers.Authorization = `ClaudeMesh-Session ${sessionToken}`;
+    const req = httpRequest2({ socketPath: DAEMON_PATHS.SOCK_FILE, path: "/v1/inbox/seen", method: "POST", timeout: 3000, headers }, (res) => {
+      res.on("data", () => {});
+      res.on("end", () => resolve3());
+    });
+    req.on("error", () => resolve3());
+    req.on("timeout", () => {
+      req.destroy();
+      resolve3();
+    });
+    req.write(body);
+    req.end();
+  });
+}
 function subscribeEvents(onEvent) {
   let active = true;
   let req = null;
@@ -18601,6 +18777,8 @@ ${mf.allowed_tools.map((t) => `  - ${t}`).join(`
     } catch {}
   };
   mcpLog("mcp_started", { version: VERSION });
+  const { readSessionTokenFromEnv: readSessionTokenFromEnv2 } = await Promise.resolve().then(() => (init_token(), exports_token));
+  const sessionTokenForSeen = readSessionTokenFromEnv2();
   const sub = subscribeEvents(async (ev) => {
     mcpLog("sse_event_received", { kind: ev.kind });
     if (ev.kind === "message") {
@@ -18633,6 +18811,10 @@ ${mf.allowed_tools.map((t) => `  - ${t}`).join(`
           }
         });
         mcpLog("channel_emitted", { content_preview: content.slice(0, 80), mesh: String(d.mesh ?? "") });
+        const inboxRowId = String(d.id ?? "");
+        if (inboxRowId) {
+          daemonMarkSeen([inboxRowId], sessionTokenForSeen).catch(() => {});
+        }
       } catch (err) {
         mcpLog("channel_emit_failed", { err: String(err) });
         process.stderr.write(`[claudemesh-mcp] channel emit failed: ${err}
@@ -18641,11 +18823,23 @@ ${mf.allowed_tools.map((t) => `  - ${t}`).join(`
     } else if (ev.kind === "peer_join" || ev.kind === "peer_leave" || ev.kind === "system") {
       const d = ev.data;
       const eventName = String(d.event ?? ev.kind);
+      const renderPeerLine = (verb) => {
+        const name = String(d.name ?? "unknown");
+        const pubkey = String(d.pubkey ?? "");
+        const pubkeyTag = pubkey ? ` (${pubkey.slice(0, 8)})` : "";
+        const groups = Array.isArray(d.groups) ? d.groups : [];
+        const groupNames = groups.map((g) => typeof g === "object" && g !== null && ("name" in g) ? String(g.name) : typeof g === "string" ? g : "").filter(Boolean);
+        const groupsTag = groupNames.length > 0 ? ` [${groupNames.join(", ")}]` : "";
+        const lastSeen = typeof d.lastSeenAt === "string" ? d.lastSeenAt : null;
+        const summary = typeof d.summary === "string" && d.summary.trim() ? d.summary.trim() : null;
+        const returningTail = lastSeen ? ` — last seen ${new Date(lastSeen).toLocaleTimeString()}${summary ? ` · "${summary.slice(0, 80)}"` : ""}` : "";
+        return `[system] Peer "${name}"${pubkeyTag}${groupsTag} ${verb} the mesh${returningTail}`;
+      };
       let content;
       if (ev.kind === "peer_join") {
-        content = `[system] Peer "${String(d.name ?? "unknown")}" joined the mesh`;
+        content = renderPeerLine(eventName === "peer_returned" ? "returned to" : "joined");
       } else if (ev.kind === "peer_leave") {
-        content = `[system] Peer "${String(d.name ?? "unknown")}" left the mesh`;
+        content = renderPeerLine("left");
       } else {
         content = `[system] ${eventName}: ${JSON.stringify(d).slice(0, 240)}`;
       }
@@ -18657,7 +18851,12 @@ ${mf.allowed_tools.map((t) => `  - ${t}`).join(`
             meta: {
               kind: "system",
               event: eventName,
-              mesh_slug: String(d.mesh ?? "")
+              mesh_slug: String(d.mesh ?? ""),
+              ...typeof d.name === "string" ? { peer_name: d.name } : {},
+              ...typeof d.pubkey === "string" ? { peer_pubkey: d.pubkey } : {},
+              ...Array.isArray(d.groups) ? { peer_groups: JSON.stringify(d.groups) } : {},
+              ...typeof d.lastSeenAt === "string" ? { peer_last_seen_at: d.lastSeenAt } : {},
+              ...typeof d.summary === "string" ? { peer_summary: d.summary } : {}
             }
           }
         });
@@ -18732,8 +18931,7 @@ async function emitMeshWelcome(server, mcpLog) {
   } catch (e) {
     mcpLog("welcome_peers_lookup_failed", { err: String(e) });
   }
-  const sinceIso = new Date(Date.now() - 86400000).toISOString();
-  const inboxPath = selfMeshSlug ? `/v1/inbox?mesh=${encodeURIComponent(selfMeshSlug)}&since=${encodeURIComponent(sinceIso)}&limit=20` : `/v1/inbox?since=${encodeURIComponent(sinceIso)}&limit=20`;
+  const inboxPath = selfMeshSlug ? `/v1/inbox?mesh=${encodeURIComponent(selfMeshSlug)}&unread_only=true&mark_seen=false&limit=50` : `/v1/inbox?unread_only=true&mark_seen=false&limit=50`;
   let inboxItems = [];
   try {
     const { status, body } = await daemonGet(inboxPath, { sessionToken });
@@ -18757,9 +18955,9 @@ async function emitMeshWelcome(server, mcpLog) {
     lines.push(`\uD83D\uDC65 Peer list unavailable (daemon query failed).`);
   }
   if (inboxItems.length === 0) {
-    lines.push(`\uD83D\uDCE5 Inbox is empty (last 24h).`);
+    lines.push(`\uD83D\uDCE5 No unread messages.`);
   } else {
-    lines.push(`\uD83D\uDCE5 ${inboxItems.length} message${inboxItems.length === 1 ? "" : "s"} in inbox (last 24h):`);
+    lines.push(`\uD83D\uDCE5 ${inboxItems.length} unread message${inboxItems.length === 1 ? "" : "s"}:`);
     for (const it of inboxItems.slice(0, 3)) {
       const sender = String(it.sender_name ?? "unknown");
       const senderPub = String(it.sender_pubkey ?? "").slice(0, 8);
@@ -18798,6 +18996,12 @@ async function emitMeshWelcome(server, mcpLog) {
       peer_count: peerCount,
       unread_count: inboxItems.length
     });
+    if (inboxItems.length > 0) {
+      const ids = inboxItems.map((it) => String(it.id ?? "")).filter(Boolean);
+      if (ids.length > 0) {
+        daemonMarkSeen(ids, sessionToken).catch(() => {});
+      }
+    }
   } catch (err) {
     mcpLog("welcome_emit_failed", { err: String(err) });
   }
@@ -19060,7 +19264,8 @@ var BOOLEAN_FLAGS = new Set([
   "force",
   "dry-run",
   "verbose",
-  "skip-service"
+  "skip-service",
+  "unread"
 ]);
 function parseArgv(argv) {
   const args = argv.slice(2);
@@ -19673,8 +19878,10 @@ Message  (resource form)
                                           fans out to every sibling session of your member)
                                           [--json] (machine-readable result)
   claudemesh message inbox         read persisted inbox       (alias: inbox)
-                                   flags: [--mesh <slug>] [--limit N] [--json]
+                                   flags: [--mesh <slug>] [--limit N] [--unread] [--json]
                                    reads ~/.claudemesh/daemon/inbox.db via daemon
+                                   --unread → only rows never surfaced before (seen_at IS NULL);
+                                   listing stamps returned rows seen as a side effect
   claudemesh inbox flush           bulk-delete inbox rows
                                    flags: [--mesh <slug>] [--before <iso-timestamp>] [--all]
                                    --all required when neither --mesh nor --before is set
@@ -20052,7 +20259,8 @@ async function main() {
         await runInbox2({
           mesh: flags.mesh,
           json: !!flags.json,
-          limit: typeof flags.limit === "number" ? flags.limit : typeof flags.limit === "string" ? Number.parseInt(flags.limit, 10) : undefined
+          limit: typeof flags.limit === "number" ? flags.limit : typeof flags.limit === "string" ? Number.parseInt(flags.limit, 10) : undefined,
+          unread: !!flags.unread
         });
       }
       break;
@@ -20325,7 +20533,8 @@ async function main() {
           await runInbox2({
             mesh: flags.mesh,
             json: !!flags.json,
-            limit: typeof flags.limit === "number" ? flags.limit : typeof flags.limit === "string" ? Number.parseInt(flags.limit, 10) : undefined
+            limit: typeof flags.limit === "number" ? flags.limit : typeof flags.limit === "string" ? Number.parseInt(flags.limit, 10) : undefined,
+            unread: !!flags.unread
           });
         }
       } else if (sub === "status") {
@@ -20880,4 +21089,4 @@ main().catch((err) => {
   process.exit(EXIT.INTERNAL_ERROR);
 });
 
-//# debugId=FB01D4AF897A4CD164756E2164756E21
+//# debugId=7232363C9624744664756E2164756E21