@agent-marshal/marshal-prime-agent 0.54.1 → 0.55.1

package/package.json

@@ -50,5 +50,5 @@
     "test": "bun test"
   },
   "type": "module",
-  "version": "0.54.1"
+  "version": "0.55.1"
 }

package/src/daemon.ts

@@ -41,9 +41,11 @@ import {
   type SessionNicknameItem,
 } from "./entities.ts";
 import type { Identity } from "./identity.ts";
+import { InboxPuller, type InboxPull } from "./inbox-pull.ts";
 
 const LIVENESS_INTERVAL_MS = 5_000;
 const INBOX_PULL_LIMIT = 20;
+const INBOX_COMMAND_TIMEOUT_MS = 1_500;
 const SOURCE_ID = "marshal-prime-agent";
 
 /** myko's CellServer serves its WebSocket at the `/myko` path. */
@@ -78,7 +80,11 @@ export class MarshalDaemon {
   private roster: SessionItem[] = [];
   private nicknames: SessionNicknameItem[] = [];
 
-  private readonly draining = new Map<string, Promise<string | null>>();
+  private readonly inbox = new InboxPuller<MessageView>({
+    read: (sessionId) => this.readUnread(sessionId),
+    ack: async (sessionId, messageIds) => { await this.sendForInbox(ackMessages(sessionId, messageIds)); },
+    render: (messages) => this.renderInbox(messages),
+  });
   private notifyHandler: NotifyHandler | null = null;
   private livenessTimer: ReturnType<typeof setInterval> | null = null;
   private started = false;
@@ -250,12 +256,14 @@ export class MarshalDaemon {
     return `- [${m.messageId}] ${this.senderLabel(m.fromSessionId)} [response_required=${m.responseRequired ?? false}]: ${m.body}`;
   }
 
-  drainInbox(sessionId: string): Promise<string | null> {
-    const prev = this.draining.get(sessionId) ?? Promise.resolve<string | null>(null);
-    const next = prev.catch(() => null).then(() => this.drainInboxInner(sessionId));
-    this.draining.set(sessionId, next);
-    void next.finally(() => { if (this.draining.get(sessionId) === next) this.draining.delete(sessionId); });
-    return next;
+  /**
+   * Read the unread inbox without acking it. Commit the pull once its text is
+   * in the conversation, or release it if it never gets there, so a message is
+   * never marked read without having been shown.
+   */
+  pullInbox(sessionId: string): Promise<InboxPull | null> {
+    if (!this.connected) return Promise.resolve(null);
+    return this.inbox.pull(sessionId).catch(() => null);
   }
 
   nicknameFor(sessionId: string): string {
@@ -270,11 +278,11 @@ export class MarshalDaemon {
 
   // ── Internals ──────────────────────────────────────────────────────────
 
-  private async drainInboxInner(sessionId: string): Promise<string | null> {
+  private async readUnread(sessionId: string): Promise<MessageView[] | null> {
     let result: ReadMessagesResult | undefined;
     for (let attempt = 0; attempt < 3; attempt++) {
       try {
-        result = await this.send(readMessages({
+        result = await this.sendForInbox(readMessages({
           asSession: sessionId,
           toSession: sessionId,
           inbox: false,
@@ -288,13 +296,7 @@ export class MarshalDaemon {
       if (result.messages && result.messages.length > 0) break;
       if (attempt < 2) await new Promise((r) => setTimeout(r, 100 * (attempt + 1)));
     }
-    if (!result?.messages?.length) return null;
-
-    const block = this.renderInbox(result.messages);
-    try {
-      await this.send(ackMessages(sessionId, result.messages.map((m) => m.messageId)));
-    } catch { this.log("inbox ack failed"); }
-    return block;
+    return result?.messages?.length ? result.messages : null;
   }
 
   private renderInbox(messages: MessageView[]): string {
@@ -352,6 +354,38 @@ export class MarshalDaemon {
     return this.client.sendCommand(command as never) as Promise<R>;
   }
 
+  /** Bounded send for the inbox path: reject at once while the WS is down, and
+   *  otherwise time out, so a read that never answers can't hold up every later
+   *  pull for the session. */
+  private sendForInbox<R>(command: MarshalCommand<R>): Promise<R> {
+    if (!this.connected) return Promise.reject(new Error("marshal is disconnected"));
+
+    return new Promise<R>((resolve, reject) => {
+      let settled = false;
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        reject(new Error(`marshal inbox command timed out after ${INBOX_COMMAND_TIMEOUT_MS}ms`));
+      }, INBOX_COMMAND_TIMEOUT_MS);
+      if (typeof (timer as any).unref === "function") (timer as any).unref();
+
+      void this.send(command).then(
+        (value) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          resolve(value);
+        },
+        (error: unknown) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          reject(error);
+        },
+      );
+    });
+  }
+
   private watch<I>(query: MarshalQuery<I>) {
     return this.client.watchQuery(query as never) as unknown as import("rxjs").Observable<I[]>;
   }

package/src/generated/Message.ts

@@ -26,28 +26,30 @@ export type Message = {
  * pull it. In the pull-via-hook model the recipient reads on its
  * next turn — which can be after the sender's SessionEnd — so
  * cascading on the sender would silently delete unread messages in
- * that window. The message's lifetime is governed by the *recipient*
- * instead (the `to_session_id` / `to_room_id` cascades below).
+ * that window. No recipient-session cascade either (see `to_session_id`).
  */
 fromSessionId: SessionId, 
 /**
  * Direct recipient — set for 1:1 sends, `None` for broadcasts.
- * Cascade-DELs the message when the recipient session is DEL'd.
+ * NOT a `belongs_to(Session)` cascade: a recipient's session row is DEL'd
+ * and re-SET under the same id on a reload, a resume or a reaped pull
+ * session's next hook, and its direct messages must still be there. A
+ * message lives until the daemon's TTL sweep prunes it.
  */
 toSessionId?: SessionId | null, 
 /**
  * Broadcast recipient — set for room sends, `None` for direct
  * sends. Cascade-DELs when the room is DEL'd. (Auto-rooms like
  * `everyone` and `host:*` are never DEL'd, so broadcasts to them
- * effectively persist forever.)
+ * persist until the daemon's TTL sweep prunes them.)
  */
 toRoomId?: RoomId | null, 
 /**
  * When this direct message was addressed to a *human* — via their operator
  * identity (the `op:`/`human:`/email tier of recipient resolution) rather
  * than to one specific agent — this holds that operator string (e.g.
- * `max@lucid.rocks`). The message is still routed to, and cascades on, the
- * operator's most-active session via `to_session_id`; this marks it as
+ * `max@lucid.rocks`). The message is still routed to the operator's
+ * most-active session via `to_session_id`; this marks it as
  * human-addressed so the receiving agent surfaces it to its operator
  * instead of treating it as ordinary peer chatter, and the UI console can
  * toast it for that operator regardless of which agent it landed on. `None`

package/src/generated/MessageRead.ts

@@ -3,7 +3,24 @@ import type { MessageId } from "./MessageId";
 import type { MessageReadId } from "./MessageReadId";
 import type { SessionId } from "./SessionId";
 
-export type MessageRead = { messageId: MessageId, sessionId: SessionId, 
+export type MessageRead = { 
+/**
+ * Cascade on the *message*: an ack is meaningless once its message is gone,
+ * so it dies with the message. This is the ack's primary lifetime owner.
+ * The TTL prune deletes messages without cascading, so the daemon's
+ * cleanup also sweeps acks whose message is gone (`sweep_orphan_reads`).
+ */
+messageId: MessageId, 
+/**
+ * NOT a `belongs_to(Session)` cascade: an ack is a fact about (message,
+ * reader) and outlives the reader's session row. Harnesses re-register
+ * under the same session id after a reload or resume (marshal-pi across
+ * `/reload`, the Claude shim on `--resume`, a pull session repaired after
+ * the reap backstop), so a session DEL is often a reconnect. Cascading
+ * here made every re-registration see the direct messages it had already
+ * read as unread, and the inbox handed them over again.
+ */
+sessionId: SessionId, 
 /**
  * Wall-clock millis when this session marked the message read.
  */

package/src/generated/index.ts

@@ -217,84 +217,6 @@ import type { SetSessionLastToolAt as _SetSessionLastToolAt } from "./SetSession
 import type { SetSessionSessionName as _SetSessionSessionName } from "./SetSessionSessionName";
 
 // Query classes
-export class GetSessionsByQuery {
-  static readonly queryId = "GetSessionsByQuery" as const;
-  static readonly queryItemType = "Session" as const;
-  readonly queryId = "GetSessionsByQuery" as const;
-  readonly queryItemType = "Session" as const;
-  readonly query: Omit<_GetSessionsByQuery, "tx" | "createdAt">;
-  declare readonly $res: () => Session[];
-
-  constructor(args: Omit<_GetSessionsByQuery, "tx" | "createdAt">) {
-    this.query = args;
-  }
-}
-
-export class GetSessionsByIds {
-  static readonly queryId = "GetSessionsByIds" as const;
-  static readonly queryItemType = "Session" as const;
-  readonly queryId = "GetSessionsByIds" as const;
-  readonly queryItemType = "Session" as const;
-  readonly query: Omit<_GetSessionsByIds, "tx" | "createdAt">;
-  declare readonly $res: () => Session[];
-
-  constructor(args: Omit<_GetSessionsByIds, "tx" | "createdAt">) {
-    this.query = args;
-  }
-}
-
-export class GetAllSessions {
-  static readonly queryId = "GetAllSessions" as const;
-  static readonly queryItemType = "Session" as const;
-  readonly queryId = "GetAllSessions" as const;
-  readonly queryItemType = "Session" as const;
-  readonly query: Omit<_GetAllSessions, "tx" | "createdAt">;
-  declare readonly $res: () => Session[];
-
-  constructor(args: Omit<_GetAllSessions, "tx" | "createdAt">) {
-    this.query = args;
-  }
-}
-
-export class GetMessageReadsByQuery {
-  static readonly queryId = "GetMessageReadsByQuery" as const;
-  static readonly queryItemType = "MessageRead" as const;
-  readonly queryId = "GetMessageReadsByQuery" as const;
-  readonly queryItemType = "MessageRead" as const;
-  readonly query: Omit<_GetMessageReadsByQuery, "tx" | "createdAt">;
-  declare readonly $res: () => MessageRead[];
-
-  constructor(args: Omit<_GetMessageReadsByQuery, "tx" | "createdAt">) {
-    this.query = args;
-  }
-}
-
-export class GetMessageReadsByIds {
-  static readonly queryId = "GetMessageReadsByIds" as const;
-  static readonly queryItemType = "MessageRead" as const;
-  readonly queryId = "GetMessageReadsByIds" as const;
-  readonly queryItemType = "MessageRead" as const;
-  readonly query: Omit<_GetMessageReadsByIds, "tx" | "createdAt">;
-  declare readonly $res: () => MessageRead[];
-
-  constructor(args: Omit<_GetMessageReadsByIds, "tx" | "createdAt">) {
-    this.query = args;
-  }
-}
-
-export class GetAllMessageReads {
-  static readonly queryId = "GetAllMessageReads" as const;
-  static readonly queryItemType = "MessageRead" as const;
-  readonly queryId = "GetAllMessageReads" as const;
-  readonly queryItemType = "MessageRead" as const;
-  readonly query: Omit<_GetAllMessageReads, "tx" | "createdAt">;
-  declare readonly $res: () => MessageRead[];
-
-  constructor(args: Omit<_GetAllMessageReads, "tx" | "createdAt">) {
-    this.query = args;
-  }
-}
-
 export class GetSessionNicknamesByQuery {
   static readonly queryId = "GetSessionNicknamesByQuery" as const;
   static readonly queryItemType = "SessionNickname" as const;
@@ -490,75 +412,87 @@ export class GetAllMessages {
   }
 }
 
-// View classes
-
-// Report classes
-export class GetSessionById {
-  static readonly reportId = "GetSessionById" as const;
-  readonly reportId = "GetSessionById" as const;
-  readonly report: Omit<_GetSessionById, "tx">;
-  declare readonly $res: () => Session | null;
+export class GetSessionsByQuery {
+  static readonly queryId = "GetSessionsByQuery" as const;
+  static readonly queryItemType = "Session" as const;
+  readonly queryId = "GetSessionsByQuery" as const;
+  readonly queryItemType = "Session" as const;
+  readonly query: Omit<_GetSessionsByQuery, "tx" | "createdAt">;
+  declare readonly $res: () => Session[];
 
-  constructor(args: Omit<_GetSessionById, "tx">) {
-    this.report = args;
+  constructor(args: Omit<_GetSessionsByQuery, "tx" | "createdAt">) {
+    this.query = args;
   }
 }
 
-export class CountSessions {
-  static readonly reportId = "CountSessions" as const;
-  readonly reportId = "CountSessions" as const;
-  readonly report: Omit<_CountSessions, "tx">;
-  declare readonly $res: () => SessionCount;
+export class GetSessionsByIds {
+  static readonly queryId = "GetSessionsByIds" as const;
+  static readonly queryItemType = "Session" as const;
+  readonly queryId = "GetSessionsByIds" as const;
+  readonly queryItemType = "Session" as const;
+  readonly query: Omit<_GetSessionsByIds, "tx" | "createdAt">;
+  declare readonly $res: () => Session[];
 
-  constructor(args: Omit<_CountSessions, "tx">) {
-    this.report = args;
+  constructor(args: Omit<_GetSessionsByIds, "tx" | "createdAt">) {
+    this.query = args;
   }
 }
 
-export class CountAllSessions {
-  static readonly reportId = "CountAllSessions" as const;
-  readonly reportId = "CountAllSessions" as const;
-  readonly report: Omit<_CountAllSessions, "tx">;
-  declare readonly $res: () => SessionCount;
+export class GetAllSessions {
+  static readonly queryId = "GetAllSessions" as const;
+  static readonly queryItemType = "Session" as const;
+  readonly queryId = "GetAllSessions" as const;
+  readonly queryItemType = "Session" as const;
+  readonly query: Omit<_GetAllSessions, "tx" | "createdAt">;
+  declare readonly $res: () => Session[];
 
-  constructor(args: Omit<_CountAllSessions, "tx">) {
-    this.report = args;
+  constructor(args: Omit<_GetAllSessions, "tx" | "createdAt">) {
+    this.query = args;
   }
 }
 
-export class GetMessageReadById {
-  static readonly reportId = "GetMessageReadById" as const;
-  readonly reportId = "GetMessageReadById" as const;
-  readonly report: Omit<_GetMessageReadById, "tx">;
-  declare readonly $res: () => MessageRead | null;
+export class GetMessageReadsByQuery {
+  static readonly queryId = "GetMessageReadsByQuery" as const;
+  static readonly queryItemType = "MessageRead" as const;
+  readonly queryId = "GetMessageReadsByQuery" as const;
+  readonly queryItemType = "MessageRead" as const;
+  readonly query: Omit<_GetMessageReadsByQuery, "tx" | "createdAt">;
+  declare readonly $res: () => MessageRead[];
 
-  constructor(args: Omit<_GetMessageReadById, "tx">) {
-    this.report = args;
+  constructor(args: Omit<_GetMessageReadsByQuery, "tx" | "createdAt">) {
+    this.query = args;
   }
 }
 
-export class CountMessageReads {
-  static readonly reportId = "CountMessageReads" as const;
-  readonly reportId = "CountMessageReads" as const;
-  readonly report: Omit<_CountMessageReads, "tx">;
-  declare readonly $res: () => MessageReadCount;
+export class GetMessageReadsByIds {
+  static readonly queryId = "GetMessageReadsByIds" as const;
+  static readonly queryItemType = "MessageRead" as const;
+  readonly queryId = "GetMessageReadsByIds" as const;
+  readonly queryItemType = "MessageRead" as const;
+  readonly query: Omit<_GetMessageReadsByIds, "tx" | "createdAt">;
+  declare readonly $res: () => MessageRead[];
 
-  constructor(args: Omit<_CountMessageReads, "tx">) {
-    this.report = args;
+  constructor(args: Omit<_GetMessageReadsByIds, "tx" | "createdAt">) {
+    this.query = args;
   }
 }
 
-export class CountAllMessageReads {
-  static readonly reportId = "CountAllMessageReads" as const;
-  readonly reportId = "CountAllMessageReads" as const;
-  readonly report: Omit<_CountAllMessageReads, "tx">;
-  declare readonly $res: () => MessageReadCount;
+export class GetAllMessageReads {
+  static readonly queryId = "GetAllMessageReads" as const;
+  static readonly queryItemType = "MessageRead" as const;
+  readonly queryId = "GetAllMessageReads" as const;
+  readonly queryItemType = "MessageRead" as const;
+  readonly query: Omit<_GetAllMessageReads, "tx" | "createdAt">;
+  declare readonly $res: () => MessageRead[];
 
-  constructor(args: Omit<_CountAllMessageReads, "tx">) {
-    this.report = args;
+  constructor(args: Omit<_GetAllMessageReads, "tx" | "createdAt">) {
+    this.query = args;
   }
 }
 
+// View classes
+
+// Report classes
 export class GetSessionNicknameById {
   static readonly reportId = "GetSessionNicknameById" as const;
   readonly reportId = "GetSessionNicknameById" as const;
@@ -724,150 +658,73 @@ export class CountAllMessages {
   }
 }
 
-// Command classes
-export class BroadcastMessage {
-  static readonly commandId = "BroadcastMessage" as const;
-  readonly commandId = "BroadcastMessage" as const;
-  readonly command: Omit<_BroadcastMessage, "tx" | "createdAt">;
-  declare readonly $res: () => BroadcastMessageResult;
-
-  constructor(args: Omit<_BroadcastMessage, "tx" | "createdAt">) {
-    this.command = args;
-  }
-}
-
-export class SendMessage {
-  static readonly commandId = "SendMessage" as const;
-  readonly commandId = "SendMessage" as const;
-  readonly command: Omit<_SendMessage, "tx" | "createdAt">;
-  declare readonly $res: () => SendMessageResult;
-
-  constructor(args: Omit<_SendMessage, "tx" | "createdAt">) {
-    this.command = args;
-  }
-}
-
-export class SetSessionLastToolAt {
-  static readonly commandId = "SetSessionLastToolAt" as const;
-  readonly commandId = "SetSessionLastToolAt" as const;
-  readonly command: Omit<_SetSessionLastToolAt, "tx" | "createdAt">;
-  declare readonly $res: () => void;
-
-  constructor(args: Omit<_SetSessionLastToolAt, "tx" | "createdAt">) {
-    this.command = args;
-  }
-}
-
-export class SetSessionLastTool {
-  static readonly commandId = "SetSessionLastTool" as const;
-  readonly commandId = "SetSessionLastTool" as const;
-  readonly command: Omit<_SetSessionLastTool, "tx" | "createdAt">;
-  declare readonly $res: () => void;
-
-  constructor(args: Omit<_SetSessionLastTool, "tx" | "createdAt">) {
-    this.command = args;
-  }
-}
-
-export class SetSessionLastActivityAt {
-  static readonly commandId = "SetSessionLastActivityAt" as const;
-  readonly commandId = "SetSessionLastActivityAt" as const;
-  readonly command: Omit<_SetSessionLastActivityAt, "tx" | "createdAt">;
-  declare readonly $res: () => void;
-
-  constructor(args: Omit<_SetSessionLastActivityAt, "tx" | "createdAt">) {
-    this.command = args;
-  }
-}
-
-export class SetSessionGitBranch {
-  static readonly commandId = "SetSessionGitBranch" as const;
-  readonly commandId = "SetSessionGitBranch" as const;
-  readonly command: Omit<_SetSessionGitBranch, "tx" | "createdAt">;
-  declare readonly $res: () => void;
-
-  constructor(args: Omit<_SetSessionGitBranch, "tx" | "createdAt">) {
-    this.command = args;
-  }
-}
-
-export class DeleteSessions {
-  static readonly commandId = "DeleteSessions" as const;
-  readonly commandId = "DeleteSessions" as const;
-  readonly command: Omit<_DeleteSessions, "tx" | "createdAt">;
-  declare readonly $res: () => DeleteSessionsResult;
-
-  constructor(args: Omit<_DeleteSessions, "tx" | "createdAt">) {
-    this.command = args;
-  }
-}
-
-export class SetSessionActivity {
-  static readonly commandId = "SetSessionActivity" as const;
-  readonly commandId = "SetSessionActivity" as const;
-  readonly command: Omit<_SetSessionActivity, "tx" | "createdAt">;
-  declare readonly $res: () => void;
+export class GetSessionById {
+  static readonly reportId = "GetSessionById" as const;
+  readonly reportId = "GetSessionById" as const;
+  readonly report: Omit<_GetSessionById, "tx">;
+  declare readonly $res: () => Session | null;
 
-  constructor(args: Omit<_SetSessionActivity, "tx" | "createdAt">) {
-    this.command = args;
+  constructor(args: Omit<_GetSessionById, "tx">) {
+    this.report = args;
   }
 }
 
-export class SetSessionSessionName {
-  static readonly commandId = "SetSessionSessionName" as const;
-  readonly commandId = "SetSessionSessionName" as const;
-  readonly command: Omit<_SetSessionSessionName, "tx" | "createdAt">;
-  declare readonly $res: () => void;
+export class CountSessions {
+  static readonly reportId = "CountSessions" as const;
+  readonly reportId = "CountSessions" as const;
+  readonly report: Omit<_CountSessions, "tx">;
+  declare readonly $res: () => SessionCount;
 
-  constructor(args: Omit<_SetSessionSessionName, "tx" | "createdAt">) {
-    this.command = args;
+  constructor(args: Omit<_CountSessions, "tx">) {
+    this.report = args;
   }
 }
 
-export class SetSessionCurrentTask {
-  static readonly commandId = "SetSessionCurrentTask" as const;
-  readonly commandId = "SetSessionCurrentTask" as const;
-  readonly command: Omit<_SetSessionCurrentTask, "tx" | "createdAt">;
-  declare readonly $res: () => void;
+export class CountAllSessions {
+  static readonly reportId = "CountAllSessions" as const;
+  readonly reportId = "CountAllSessions" as const;
+  readonly report: Omit<_CountAllSessions, "tx">;
+  declare readonly $res: () => SessionCount;
 
-  constructor(args: Omit<_SetSessionCurrentTask, "tx" | "createdAt">) {
-    this.command = args;
+  constructor(args: Omit<_CountAllSessions, "tx">) {
+    this.report = args;
   }
 }
 
-export class DeleteSession {
-  static readonly commandId = "DeleteSession" as const;
-  readonly commandId = "DeleteSession" as const;
-  readonly command: Omit<_DeleteSession, "tx" | "createdAt">;
-  declare readonly $res: () => DeleteSessionResult;
+export class GetMessageReadById {
+  static readonly reportId = "GetMessageReadById" as const;
+  readonly reportId = "GetMessageReadById" as const;
+  readonly report: Omit<_GetMessageReadById, "tx">;
+  declare readonly $res: () => MessageRead | null;
 
-  constructor(args: Omit<_DeleteSession, "tx" | "createdAt">) {
-    this.command = args;
+  constructor(args: Omit<_GetMessageReadById, "tx">) {
+    this.report = args;
   }
 }
 
-export class DeleteMessageRead {
-  static readonly commandId = "DeleteMessageRead" as const;
-  readonly commandId = "DeleteMessageRead" as const;
-  readonly command: Omit<_DeleteMessageRead, "tx" | "createdAt">;
-  declare readonly $res: () => DeleteMessageReadResult;
+export class CountMessageReads {
+  static readonly reportId = "CountMessageReads" as const;
+  readonly reportId = "CountMessageReads" as const;
+  readonly report: Omit<_CountMessageReads, "tx">;
+  declare readonly $res: () => MessageReadCount;
 
-  constructor(args: Omit<_DeleteMessageRead, "tx" | "createdAt">) {
-    this.command = args;
+  constructor(args: Omit<_CountMessageReads, "tx">) {
+    this.report = args;
   }
 }
 
-export class DeleteMessageReads {
-  static readonly commandId = "DeleteMessageReads" as const;
-  readonly commandId = "DeleteMessageReads" as const;
-  readonly command: Omit<_DeleteMessageReads, "tx" | "createdAt">;
-  declare readonly $res: () => DeleteMessageReadsResult;
+export class CountAllMessageReads {
+  static readonly reportId = "CountAllMessageReads" as const;
+  readonly reportId = "CountAllMessageReads" as const;
+  readonly report: Omit<_CountAllMessageReads, "tx">;
+  declare readonly $res: () => MessageReadCount;
 
-  constructor(args: Omit<_DeleteMessageReads, "tx" | "createdAt">) {
-    this.command = args;
+  constructor(args: Omit<_CountAllMessageReads, "tx">) {
+    this.report = args;
   }
 }
 
+// Command classes
 export class DeleteSessionNickname {
   static readonly commandId = "DeleteSessionNickname" as const;
   readonly commandId = "DeleteSessionNickname" as const;
@@ -945,6 +802,28 @@ export class JoinRoom {
   }
 }
 
+export class BroadcastMessage {
+  static readonly commandId = "BroadcastMessage" as const;
+  readonly commandId = "BroadcastMessage" as const;
+  readonly command: Omit<_BroadcastMessage, "tx" | "createdAt">;
+  declare readonly $res: () => BroadcastMessageResult;
+
+  constructor(args: Omit<_BroadcastMessage, "tx" | "createdAt">) {
+    this.command = args;
+  }
+}
+
+export class SendMessage {
+  static readonly commandId = "SendMessage" as const;
+  readonly commandId = "SendMessage" as const;
+  readonly command: Omit<_SendMessage, "tx" | "createdAt">;
+  declare readonly $res: () => SendMessageResult;
+
+  constructor(args: Omit<_SendMessage, "tx" | "createdAt">) {
+    this.command = args;
+  }
+}
+
 export class DeleteRoom {
   static readonly commandId = "DeleteRoom" as const;
   readonly commandId = "DeleteRoom" as const;
@@ -1066,15 +945,136 @@ export class NotifyChannel {
   }
 }
 
+export class SetSessionLastToolAt {
+  static readonly commandId = "SetSessionLastToolAt" as const;
+  readonly commandId = "SetSessionLastToolAt" as const;
+  readonly command: Omit<_SetSessionLastToolAt, "tx" | "createdAt">;
+  declare readonly $res: () => void;
+
+  constructor(args: Omit<_SetSessionLastToolAt, "tx" | "createdAt">) {
+    this.command = args;
+  }
+}
+
+export class SetSessionLastTool {
+  static readonly commandId = "SetSessionLastTool" as const;
+  readonly commandId = "SetSessionLastTool" as const;
+  readonly command: Omit<_SetSessionLastTool, "tx" | "createdAt">;
+  declare readonly $res: () => void;
+
+  constructor(args: Omit<_SetSessionLastTool, "tx" | "createdAt">) {
+    this.command = args;
+  }
+}
+
+export class SetSessionLastActivityAt {
+  static readonly commandId = "SetSessionLastActivityAt" as const;
+  readonly commandId = "SetSessionLastActivityAt" as const;
+  readonly command: Omit<_SetSessionLastActivityAt, "tx" | "createdAt">;
+  declare readonly $res: () => void;
+
+  constructor(args: Omit<_SetSessionLastActivityAt, "tx" | "createdAt">) {
+    this.command = args;
+  }
+}
+
+export class SetSessionGitBranch {
+  static readonly commandId = "SetSessionGitBranch" as const;
+  readonly commandId = "SetSessionGitBranch" as const;
+  readonly command: Omit<_SetSessionGitBranch, "tx" | "createdAt">;
+  declare readonly $res: () => void;
+
+  constructor(args: Omit<_SetSessionGitBranch, "tx" | "createdAt">) {
+    this.command = args;
+  }
+}
+
+export class DeleteSessions {
+  static readonly commandId = "DeleteSessions" as const;
+  readonly commandId = "DeleteSessions" as const;
+  readonly command: Omit<_DeleteSessions, "tx" | "createdAt">;
+  declare readonly $res: () => DeleteSessionsResult;
+
+  constructor(args: Omit<_DeleteSessions, "tx" | "createdAt">) {
+    this.command = args;
+  }
+}
+
+export class SetSessionActivity {
+  static readonly commandId = "SetSessionActivity" as const;
+  readonly commandId = "SetSessionActivity" as const;
+  readonly command: Omit<_SetSessionActivity, "tx" | "createdAt">;
+  declare readonly $res: () => void;
+
+  constructor(args: Omit<_SetSessionActivity, "tx" | "createdAt">) {
+    this.command = args;
+  }
+}
+
+export class SetSessionSessionName {
+  static readonly commandId = "SetSessionSessionName" as const;
+  readonly commandId = "SetSessionSessionName" as const;
+  readonly command: Omit<_SetSessionSessionName, "tx" | "createdAt">;
+  declare readonly $res: () => void;
+
+  constructor(args: Omit<_SetSessionSessionName, "tx" | "createdAt">) {
+    this.command = args;
+  }
+}
+
+export class SetSessionCurrentTask {
+  static readonly commandId = "SetSessionCurrentTask" as const;
+  readonly commandId = "SetSessionCurrentTask" as const;
+  readonly command: Omit<_SetSessionCurrentTask, "tx" | "createdAt">;
+  declare readonly $res: () => void;
+
+  constructor(args: Omit<_SetSessionCurrentTask, "tx" | "createdAt">) {
+    this.command = args;
+  }
+}
+
+export class DeleteSession {
+  static readonly commandId = "DeleteSession" as const;
+  readonly commandId = "DeleteSession" as const;
+  readonly command: Omit<_DeleteSession, "tx" | "createdAt">;
+  declare readonly $res: () => DeleteSessionResult;
+
+  constructor(args: Omit<_DeleteSession, "tx" | "createdAt">) {
+    this.command = args;
+  }
+}
+
+export class DeleteMessageRead {
+  static readonly commandId = "DeleteMessageRead" as const;
+  readonly commandId = "DeleteMessageRead" as const;
+  readonly command: Omit<_DeleteMessageRead, "tx" | "createdAt">;
+  declare readonly $res: () => DeleteMessageReadResult;
+
+  constructor(args: Omit<_DeleteMessageRead, "tx" | "createdAt">) {
+    this.command = args;
+  }
+}
+
+export class DeleteMessageReads {
+  static readonly commandId = "DeleteMessageReads" as const;
+  readonly commandId = "DeleteMessageReads" as const;
+  readonly command: Omit<_DeleteMessageReads, "tx" | "createdAt">;
+  declare readonly $res: () => DeleteMessageReadsResult;
+
+  constructor(args: Omit<_DeleteMessageReads, "tx" | "createdAt">) {
+    this.command = args;
+  }
+}
+
 // Item constructors
 export const items = {
-  Session: (args: Session) => ({ item: args, itemType: "Session" }),
-  MessageRead: (args: MessageRead) => ({ item: args, itemType: "MessageRead" }),
   SessionNickname: (args: SessionNickname) => ({ item: args, itemType: "SessionNickname" }),
   RoomMember: (args: RoomMember) => ({ item: args, itemType: "RoomMember" }),
   Room: (args: Room) => ({ item: args, itemType: "Room" }),
   SandboxRun: (args: SandboxRun) => ({ item: args, itemType: "SandboxRun" }),
   Message: (args: Message) => ({ item: args, itemType: "Message" }),
+  Session: (args: Session) => ({ item: args, itemType: "Session" }),
+  MessageRead: (args: MessageRead) => ({ item: args, itemType: "MessageRead" }),
 };
 
 // Message events

package/src/inbox-pull.ts

@@ -0,0 +1,86 @@
+// Inbox pulls that are acked only once their text has been shown.
+//
+// Acking in the same step as the read loses messages whenever the caller ends
+// up not showing what it read: a per-turn pull that loses its timeout race, or
+// an injection that fails. A pull here hands the messages back unacked; the
+// caller commits it once the text is in the conversation, or releases it so
+// the next pull hands the same messages out again.
+
+/** Unread messages read but not yet acked. */
+export interface InboxPull {
+  /** The rendered messages, ready to inject. */
+  readonly text: string;
+  /** Ack the messages. Call once `text` has been shown. */
+  commit(): Promise<void>;
+  /** Give the messages back unacked, so the next pull hands them out again. */
+  release(): void;
+}
+
+/** Where a pull reads, acks and renders messages. */
+export interface InboxSource<M extends { messageId: string }> {
+  read(sessionId: string): Promise<M[] | null>;
+  ack(sessionId: string, messageIds: string[]): Promise<void>;
+  render(messages: M[]): string;
+}
+
+export class InboxPuller<M extends { messageId: string }> {
+  /** Per session, the ids an outstanding pull holds: still unread, so a read returns them. */
+  private readonly held = new Map<string, Set<string>>();
+  /** Per session, the pull in flight. Pulls run one at a time, so each sees what the last one holds. */
+  private readonly pulling = new Map<string, Promise<unknown>>();
+
+  private readonly source: InboxSource<M>;
+
+  constructor(source: InboxSource<M>) {
+    this.source = source;
+  }
+
+  pull(sessionId: string): Promise<InboxPull | null> {
+    const previous = this.pulling.get(sessionId) ?? Promise.resolve();
+    const next = previous.catch(() => {}).then(() => this.pullNow(sessionId));
+    this.pulling.set(sessionId, next);
+    void next.catch(() => {}).finally(() => {
+      if (this.pulling.get(sessionId) === next) this.pulling.delete(sessionId);
+    });
+    return next;
+  }
+
+  private async pullNow(sessionId: string): Promise<InboxPull | null> {
+    const held = this.held.get(sessionId) ?? new Set<string>();
+    const messages = (await this.source.read(sessionId))?.filter((m) => !held.has(m.messageId));
+    if (!messages?.length) return null;
+    // Render before holding anything, so a render that throws holds nothing.
+    const text = this.source.render(messages);
+    const ids = messages.map((m) => m.messageId);
+    for (const id of ids) held.add(id);
+    this.held.set(sessionId, held);
+    const settle = () => { for (const id of ids) held.delete(id); };
+    return {
+      text,
+      commit: async () => {
+        try {
+          await this.source.ack(sessionId, ids);
+        } finally {
+          settle();
+        }
+      },
+      release: settle,
+    };
+  }
+}
+
+/**
+ * Pull for a turn, giving up after `timeoutMs` so the turn is never held up.
+ * A pull that lands after that is released, not acked: its messages were not
+ * shown, so they stay unread for the next turn.
+ */
+export async function pullForTurn(pull: () => Promise<InboxPull | null>, timeoutMs: number): Promise<InboxPull | null> {
+  const pending = pull().catch(() => null);
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const deadline = new Promise<"late">((resolve) => { timer = setTimeout(() => resolve("late"), timeoutMs); });
+  const winner = await Promise.race([pending, deadline]);
+  clearTimeout(timer);
+  if (winner !== "late") return winner;
+  void pending.then((landed) => landed?.release());
+  return null;
+}

package/src/index.ts

@@ -23,6 +23,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
 import { MarshalDaemon } from "./daemon.ts";
+import { pullForTurn } from "./inbox-pull.ts";
 import { resolveIdentity, type Identity } from "./identity.ts";
 import type { NotifyChannelMeta, SessionItem } from "./entities.ts";
 import { shouldRegisterPrimeAgentSession } from "./runtime.ts";
@@ -111,12 +112,19 @@ async function init(pi: ExtensionAPI) {
           );
         } else {
           // Compatibility fallback for older daemons that omit body metadata.
-          const inbox = await daemon!.drainInbox(sid).catch(() => null);
-          if (!inbox) return;
-          await pi.sendMessage(
-            { customType: "marshal-channel", content: inbox, display: true, details: meta },
-            { deliverAs: "steer", triggerTurn: true },
-          );
+          // The pull is acked only once it has been injected.
+          const pull = await daemon!.pullInbox(sid);
+          if (!pull) return;
+          try {
+            await pi.sendMessage(
+              { customType: "marshal-channel", content: pull.text, display: true, details: meta },
+              { deliverAs: "steer", triggerTurn: true },
+            );
+          } catch (e) {
+            pull.release();
+            throw e;
+          }
+          await pull.commit().catch(() => log("inbox ack failed"));
         }
       } catch (e) {
         log(`live push injection failed: ${String(e)}`);
@@ -328,19 +336,21 @@ async function init(pi: ExtensionAPI) {
     // Add marshal system prompt context (once per turn, before the LLM call).
     result.systemPrompt = event.systemPrompt + "\n\n" + SYSTEM_PROMPT_BLOCK;
 
-    // Drain any missed inbox messages — only if the daemon is connected.
-    if (daemon && sessionId && daemon.isConnected()) {
-      daemon.registerSession(sessionId); // self-heal a dropped roster row
-      const inbox = await Promise.race([
-        daemon.drainInbox(sessionId).catch(() => null),
-        new Promise<null>((r) => setTimeout(() => r(null), 2000)),
-      ]);
-      if (inbox) {
+    // Pull any missed inbox messages — only if the daemon is connected. The
+    // pull is acked only once its text goes into this turn; one that misses
+    // the deadline is released, so its messages stay unread for the next turn.
+    const d = daemon;
+    const sid = sessionId;
+    if (d && sid && d.isConnected()) {
+      d.registerSession(sid); // self-heal a dropped roster row
+      const pull = await pullForTurn(() => d.pullInbox(sid), 2000);
+      if (pull) {
         result.message = {
           customType: "marshal-inbox",
-          content: inbox,
+          content: pull.text,
           display: true,
         };
+        void pull.commit().catch(() => log("inbox ack failed"));
       }
     }