claudemesh-cli 1.34.6 → 1.34.8

package/dist/entrypoints/cli.js

@@ -104,7 +104,7 @@ __export(exports_urls, {
   VERSION: () => VERSION,
   URLS: () => URLS
 });
-var URLS, VERSION = "1.34.6", env;
+var URLS, VERSION = "1.34.8", env;
 var init_urls = __esm(() => {
   URLS = {
     BROKER: process.env.CLAUDEMESH_BROKER_URL ?? "wss://ic.claudemesh.com/ws",
@@ -4022,7 +4022,9 @@ __export(exports_daemon_route, {
   tryListInboxViaDaemon: () => tryListInboxViaDaemon,
   tryGetStateViaDaemon: () => tryGetStateViaDaemon,
   tryGetSkillViaDaemon: () => tryGetSkillViaDaemon,
-  tryForgetViaDaemon: () => tryForgetViaDaemon
+  tryForgetViaDaemon: () => tryForgetViaDaemon,
+  tryFlushInboxViaDaemon: () => tryFlushInboxViaDaemon,
+  tryDeleteInboxRowViaDaemon: () => tryDeleteInboxRowViaDaemon
 });
 function meshQuery(mesh) {
   return mesh ? `?mesh=${encodeURIComponent(mesh)}` : "";
@@ -4050,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;
@@ -4066,6 +4075,48 @@ async function tryListInboxViaDaemon(mesh, limit = 100) {
     return null;
   }
 }
+async function tryFlushInboxViaDaemon(args = {}) {
+  if (!await daemonReachable())
+    return null;
+  try {
+    const params = [];
+    if (args.mesh)
+      params.push(`mesh=${encodeURIComponent(args.mesh)}`);
+    if (args.beforeIso)
+      params.push(`before=${encodeURIComponent(args.beforeIso)}`);
+    const path = `/v1/inbox${params.length ? `?${params.join("&")}` : ""}`;
+    const res = await ipc({ path, method: "DELETE", timeoutMs: 3000 });
+    if (res.status !== 200)
+      return null;
+    return typeof res.body.removed === "number" ? res.body.removed : null;
+  } catch (err) {
+    const msg = String(err);
+    if (/ENOENT|ECONNREFUSED|ipc_timeout/.test(msg))
+      return null;
+    return null;
+  }
+}
+async function tryDeleteInboxRowViaDaemon(id) {
+  if (!await daemonReachable())
+    return null;
+  try {
+    const res = await ipc({
+      path: `/v1/inbox/${encodeURIComponent(id)}`,
+      method: "DELETE",
+      timeoutMs: 3000
+    });
+    if (res.status === 404)
+      return false;
+    if (res.status !== 200)
+      return null;
+    return (res.body.removed ?? 0) > 0;
+  } catch (err) {
+    const msg = String(err);
+    if (/ENOENT|ECONNREFUSED|ipc_timeout/.test(msg))
+      return null;
+    return null;
+  }
+}
 async function tryListSkillsViaDaemon(mesh) {
   if (!await daemonReachable())
     return null;
@@ -8239,6 +8290,87 @@ var init_send = __esm(() => {
   init_styles();
 });
 
+// src/commands/inbox-actions.ts
+var exports_inbox_actions = {};
+__export(exports_inbox_actions, {
+  runInboxFlush: () => runInboxFlush,
+  runInboxDelete: () => runInboxDelete
+});
+async function runInboxFlush(flags) {
+  const hasFilter = !!(flags.mesh || flags.before);
+  if (!hasFilter && !flags.all) {
+    if (flags.json) {
+      process.stdout.write(JSON.stringify({ ok: false, error: "missing_filter" }) + `
+`);
+      return;
+    }
+    render.info(dim(`Refusing to flush every row on every mesh.
+` + "  Re-run with --mesh <slug>, --before <iso-timestamp>, or --all to confirm."));
+    process.exit(1);
+  }
+  const removed = await tryFlushInboxViaDaemon({
+    ...flags.mesh ? { mesh: flags.mesh } : {},
+    ...flags.before ? { beforeIso: flags.before } : {}
+  });
+  if (removed === null) {
+    if (flags.json) {
+      process.stdout.write(JSON.stringify({ ok: false, error: "daemon_unreachable" }) + `
+`);
+      return;
+    }
+    render.info(dim("Daemon not reachable. Run `claudemesh daemon up` and retry."));
+    process.exit(1);
+  }
+  if (flags.json) {
+    process.stdout.write(JSON.stringify({ ok: true, removed }) + `
+`);
+    return;
+  }
+  const scope = flags.mesh ? `mesh "${flags.mesh}"` : flags.before ? `older than ${flags.before}` : "all meshes";
+  render.info(`✔ Flushed ${removed} message${removed === 1 ? "" : "s"} from ${scope}.`);
+}
+async function runInboxDelete(id, flags) {
+  if (!id) {
+    if (flags.json) {
+      process.stdout.write(JSON.stringify({ ok: false, error: "missing_id" }) + `
+`);
+      return;
+    }
+    render.info(dim("Usage: claudemesh inbox delete <message-id>"));
+    process.exit(1);
+  }
+  const ok = await tryDeleteInboxRowViaDaemon(id);
+  if (ok === null) {
+    if (flags.json) {
+      process.stdout.write(JSON.stringify({ ok: false, error: "daemon_unreachable" }) + `
+`);
+      return;
+    }
+    render.info(dim("Daemon not reachable. Run `claudemesh daemon up` and retry."));
+    process.exit(1);
+  }
+  if (!ok) {
+    if (flags.json) {
+      process.stdout.write(JSON.stringify({ ok: false, error: "not_found", id }) + `
+`);
+      return;
+    }
+    render.info(dim(`No inbox row with id "${id}".`));
+    process.exit(1);
+  }
+  if (flags.json) {
+    process.stdout.write(JSON.stringify({ ok: true, id }) + `
+`);
+    return;
+  }
+  render.info(`✔ Deleted inbox row ${id}.`);
+}
+var init_inbox_actions = __esm(() => {
+  init_daemon_route();
+  init_render();
+  init_styles();
+});
+
 // src/commands/inbox.ts
 var exports_inbox = {};
 __export(exports_inbox, {
@@ -8255,7 +8387,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(`[]
@@ -8272,10 +8407,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) + `
@@ -9457,6 +9594,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);
@@ -9491,9 +9633,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
@@ -9502,6 +9647,36 @@ 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;
+}
+function flushInbox(db, p) {
+  const where = [];
+  const args = [];
+  if (p.mesh !== undefined) {
+    where.push("mesh = ?");
+    args.push(p.mesh);
+  }
+  if (p.before !== undefined) {
+    where.push("received_at < ?");
+    args.push(p.before);
+  }
+  const sql = `DELETE FROM inbox ${where.length ? "WHERE " + where.join(" AND ") : ""}`;
+  const r = db.prepare(sql).run(...args);
+  return Number(r.changes);
+}
 
 // src/daemon/events.ts
 class EventBus {
@@ -10243,13 +10418,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,
@@ -10261,11 +10446,65 @@ 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" });
+        return;
+      }
+      const meshFilter = meshFromCtx(url.searchParams.get("mesh")) ?? undefined;
+      const beforeRaw = url.searchParams.get("before");
+      const before = beforeRaw ? Date.parse(beforeRaw) : undefined;
+      const removed = flushInbox(opts.inboxDb, {
+        ...meshFilter ? { mesh: meshFilter } : {},
+        ...Number.isFinite(before) ? { before } : {}
+      });
+      respond(res, 200, { removed });
+      return;
+    }
+    if (req.method === "DELETE" && url.pathname.startsWith("/v1/inbox/")) {
+      if (!opts.inboxDb) {
+        respond(res, 503, { error: "inbox not initialised" });
+        return;
+      }
+      const id = url.pathname.slice("/v1/inbox/".length);
+      if (!id) {
+        respond(res, 400, { error: "missing id" });
+        return;
+      }
+      const ok = deleteInboxRow(opts.inboxDb, id);
+      if (!ok) {
+        respond(res, 404, { error: "not found", id });
+        return;
+      }
+      respond(res, 200, { removed: 1, id });
+      return;
+    }
     if (req.method === "GET" && url.pathname === "/v1/outbox") {
       if (!opts.outboxDb) {
         respond(res, 503, { error: "outbox not initialised" });
@@ -11199,6 +11438,11 @@ class SessionBrokerClient {
           return;
         }
         if (msg.type === "push" || msg.type === "inbound") {
+          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;
         }
@@ -11490,6 +11734,46 @@ 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) {
@@ -11806,6 +12090,12 @@ async function runDaemon(opts = {}) {
         bus.publish("broker_status", { mesh: mesh.slug, status: s });
       },
       onPush: (m) => {
+        const senderMemberPk = String(m.senderMemberPubkey ?? "").toLowerCase();
+        const senderPubkey = String(m.senderPubkey ?? "").toLowerCase();
+        const ownMember = mesh.pubkey.toLowerCase();
+        if (senderMemberPk && senderMemberPk === ownMember && senderPubkey === ownMember) {
+          return;
+        }
         handleBrokerPush(m, {
           db: inboxDb,
           bus,
@@ -11827,6 +12117,7 @@ async function runDaemon(opts = {}) {
     brokers,
     getSessionBrokerByPubkey: (pubkey) => sessionBrokersByPubkey.get(pubkey)
   });
+  const inboxPruner = startInboxPruner({ db: inboxDb });
   setRegistryHooks({
     onRegister: (info) => {
       if (!info.presence)
@@ -11930,6 +12221,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()) {
@@ -11966,6 +12258,7 @@ var init_run = __esm(() => {
   init_broker();
   init_session_broker();
   init_drain();
+  init_inbox_pruner();
   init_inbound();
   init_identity();
   init_facade();
@@ -16093,7 +16386,15 @@ 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
+claudemesh inbox flush --before <iso-timestamp>        # delete rows older than timestamp
+claudemesh inbox flush --all                           # delete every row on every mesh (required guard)
+claudemesh inbox delete <id>                           # delete one inbox row by id (alias: rm)
+claudemesh inbox flush --mesh <slug> --json            # JSON: { ok: true, removed: N }
 
 # delivery status (alias: claudemesh msg-status <id>)
 claudemesh message status <message-id>
@@ -16102,6 +16403,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
@@ -18205,6 +18512,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;
@@ -18417,6 +18750,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") {
@@ -18449,6 +18784,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}
@@ -18548,8 +18887,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 });
@@ -18573,9 +18911,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);
@@ -18614,6 +18952,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) });
   }
@@ -18876,7 +19220,8 @@ var BOOLEAN_FLAGS = new Set([
   "force",
   "dry-run",
   "verbose",
-  "skip-service"
+  "skip-service",
+  "unread"
 ]);
 function parseArgv(argv) {
   const args = argv.slice(2);
@@ -19489,8 +19834,14 @@ 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
+  claudemesh inbox delete <id>     delete one inbox row by id (alias: rm)
   claudemesh message status <id>   delivery status            (alias: msg-status)
 
 Memory  (resource form)
@@ -19847,8 +20198,27 @@ async function main() {
       break;
     }
     case "inbox": {
-      const { runInbox: runInbox2 } = await Promise.resolve().then(() => (init_inbox(), exports_inbox));
-      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 });
+      const sub = positionals[0];
+      if (sub === "flush") {
+        const { runInboxFlush: runInboxFlush2 } = await Promise.resolve().then(() => (init_inbox_actions(), exports_inbox_actions));
+        await runInboxFlush2({
+          mesh: flags.mesh,
+          before: flags.before,
+          all: !!flags.all,
+          json: !!flags.json
+        });
+      } else if (sub === "delete" || sub === "rm") {
+        const { runInboxDelete: runInboxDelete2 } = await Promise.resolve().then(() => (init_inbox_actions(), exports_inbox_actions));
+        await runInboxDelete2(positionals[1] ?? "", { json: !!flags.json });
+      } else {
+        const { runInbox: runInbox2 } = await Promise.resolve().then(() => (init_inbox(), exports_inbox));
+        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,
+          unread: !!flags.unread
+        });
+      }
       break;
     }
     case "state": {
@@ -20102,8 +20472,27 @@ async function main() {
         const { runSend: runSend2 } = await Promise.resolve().then(() => (init_send(), exports_send));
         await runSend2({ mesh: flags.mesh, priority: flags.priority, json: !!flags.json, self: !!flags.self }, positionals[1] ?? "", positionals.slice(2).join(" "));
       } else if (sub === "inbox") {
-        const { runInbox: runInbox2 } = await Promise.resolve().then(() => (init_inbox(), exports_inbox));
-        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 });
+        const sub2 = positionals[1];
+        if (sub2 === "flush") {
+          const { runInboxFlush: runInboxFlush2 } = await Promise.resolve().then(() => (init_inbox_actions(), exports_inbox_actions));
+          await runInboxFlush2({
+            mesh: flags.mesh,
+            before: flags.before,
+            all: !!flags.all,
+            json: !!flags.json
+          });
+        } else if (sub2 === "delete" || sub2 === "rm") {
+          const { runInboxDelete: runInboxDelete2 } = await Promise.resolve().then(() => (init_inbox_actions(), exports_inbox_actions));
+          await runInboxDelete2(positionals[2] ?? "", { json: !!flags.json });
+        } else {
+          const { runInbox: runInbox2 } = await Promise.resolve().then(() => (init_inbox(), exports_inbox));
+          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,
+            unread: !!flags.unread
+          });
+        }
       } else if (sub === "status") {
         const { runMsgStatus: runMsgStatus2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
         process.exit(await runMsgStatus2(positionals[1], { mesh: flags.mesh, json: !!flags.json }));
@@ -20656,4 +21045,4 @@ main().catch((err) => {
   process.exit(EXIT.INTERNAL_ERROR);
 });
 
-//# debugId=944F6ED12781882C64756E2164756E21
+//# debugId=99681AB539B313DF64756E2164756E21