@gobing-ai/spur 0.4.17 → 0.4.19

package/spur.js

@@ -34977,202 +34977,6 @@ var init_entity_dao = __esm(() => {
   };
 });
 
-// ../../node_modules/.bun/@gobing-ai+ts-db@0.5.32+3ceefb3da453b19a/node_modules/@gobing-ai/ts-db/dist/inbox-message-dao.js
-function isPromiseLike(value) {
-  return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
-}
-function isRequestKeyUniqueViolation(error) {
-  const msg = error instanceof Error ? error.message : String(error);
-  return msg.includes("UNIQUE constraint failed") && (msg.includes("idx_inbox_messages_request_key") || msg.includes("inbox_messages.request_key"));
-}
-var RequestKeyConflictError, InboxMessageDao;
-var init_inbox_message_dao = __esm(() => {
-  init_drizzle_orm();
-  init_entity_dao();
-  init_inbox_messages();
-  RequestKeyConflictError = class RequestKeyConflictError extends Error {
-    requestKey;
-    existingId;
-    constructor(requestKey, existingId) {
-      super(`Request key conflict: key is already bound to another payload` + (existingId ? ` (existing message id: ${existingId})` : ""));
-      this.name = "RequestKeyConflictError";
-      this.requestKey = requestKey;
-      this.existingId = existingId;
-    }
-  };
-  InboxMessageDao = class InboxMessageDao extends EntityDao {
-    events;
-    constructor(adapter, options = {}) {
-      super(adapter, inboxMessages, [inboxMessages.id], "inbox_messages");
-      this.events = options.events;
-    }
-    async enqueue(fromId, toId, body, inReplyTo) {
-      const id = crypto.randomUUID();
-      const now = this.now();
-      await this.create({
-        id,
-        fromId,
-        toId,
-        body,
-        status: "queued",
-        injectAttempts: 0,
-        createdAt: now,
-        updatedAt: now,
-        ...inReplyTo !== undefined ? { inReplyTo } : {}
-      });
-      this.emitEvent("message.enqueued", {
-        id,
-        fromId,
-        toId,
-        ...inReplyTo !== undefined ? { inReplyTo } : {},
-        timestamp: now
-      });
-      return id;
-    }
-    async enqueueIdempotent(fromId, toId, body, requestKey, inReplyTo) {
-      const id = crypto.randomUUID();
-      const now = this.now();
-      try {
-        await this.create({
-          id,
-          fromId,
-          toId,
-          body,
-          status: "queued",
-          injectAttempts: 0,
-          requestKey,
-          createdAt: now,
-          updatedAt: now,
-          ...inReplyTo !== undefined ? { inReplyTo } : {}
-        });
-      } catch (error) {
-        if (isRequestKeyUniqueViolation(error)) {
-          const existing = await this.findBy(inboxMessages.requestKey, requestKey);
-          if (existing && existing.body === body && existing.toId === toId) {
-            return { id: existing.id, replayed: true };
-          }
-          throw new RequestKeyConflictError(requestKey, existing?.id ?? "");
-        }
-        throw error;
-      }
-      this.emitEvent("message.enqueued", {
-        id,
-        fromId,
-        toId,
-        ...inReplyTo !== undefined ? { inReplyTo } : {},
-        timestamp: now
-      });
-      return { id, replayed: false };
-    }
-    async drainPending(toId, options) {
-      const limit = options?.limit ?? 100;
-      if (!Number.isInteger(limit) || limit <= 0) {
-        throw new RangeError(`drainPending limit must be a positive integer; received ${limit}`);
-      }
-      const now = this.now();
-      const rows = await this.db.update(inboxMessages).set({
-        status: "injected",
-        injectAttempts: sql`${inboxMessages.injectAttempts} + 1`,
-        updatedAt: now
-      }).where(sql`${inboxMessages.id} IN (
-                    SELECT id
-                    FROM ${inboxMessages}
-                    WHERE to_id = ${toId}
-                      AND status = 'queued'
-                    ORDER BY created_at
-                    LIMIT ${limit}
-                )
-                AND ${inboxMessages.status} = 'queued'`).returning();
-      for (const row of rows) {
-        this.emitEvent("message.injected", {
-          id: row.id,
-          fromId: row.fromId,
-          toId: row.toId,
-          inReplyTo: row.inReplyTo,
-          injectAttempts: row.injectAttempts,
-          timestamp: now
-        });
-      }
-      return rows;
-    }
-    async markDelivered(msgId) {
-      const now = this.now();
-      const updated = await this.update(msgId, {
-        status: "delivered",
-        deliveredAt: now
-      });
-      if (updated) {
-        this.emitEvent("message.delivered", {
-          id: updated.id,
-          fromId: updated.fromId,
-          toId: updated.toId,
-          deliveredAt: now,
-          timestamp: now
-        });
-      }
-    }
-    async markFailed(msgId, error) {
-      const updated = await this.update(msgId, {
-        status: "failed",
-        injectError: error
-      });
-      if (updated) {
-        this.emitEvent("message.failed", {
-          id: updated.id,
-          fromId: updated.fromId,
-          toId: updated.toId,
-          error,
-          timestamp: updated.updatedAt
-        });
-      }
-    }
-    async release(msgIds) {
-      if (msgIds.length === 0)
-        return 0;
-      const now = this.now();
-      const rows = await this.db.update(inboxMessages).set({ status: "queued", updatedAt: now }).where(and(inArray(inboxMessages.id, msgIds), eq(inboxMessages.status, "injected"))).returning();
-      for (const row of rows) {
-        this.emitEvent("message.requeued", {
-          id: row.id,
-          fromId: row.fromId,
-          toId: row.toId,
-          timestamp: now
-        });
-      }
-      return rows.length;
-    }
-    async inbox(toId, limit, offset) {
-      return this.list({
-        where: { col: inboxMessages.toId, op: "eq", value: toId },
-        orderBy: [{ col: inboxMessages.createdAt, dir: "desc" }],
-        ...limit !== undefined ? { limit } : {},
-        ...offset !== undefined ? { offset } : {}
-      });
-    }
-    async countPending(toId) {
-      return this.count({
-        and: [
-          { col: inboxMessages.toId, op: "eq", value: toId },
-          { col: inboxMessages.status, op: "eq", value: "queued" }
-        ]
-      });
-    }
-    async getById(id) {
-      return this.findBy(inboxMessages.id, id);
-    }
-    emitEvent(event, ...args) {
-      if (!this.events)
-        return;
-      try {
-        const pending = this.events.emit(event, ...args);
-        if (isPromiseLike(pending)) {
-          Promise.resolve(pending).catch(() => {});
-        }
-      } catch {}
-    }
-  };
-});
-
 // ../../node_modules/.bun/@gobing-ai+ts-db@0.5.32+3ceefb3da453b19a/node_modules/@gobing-ai/ts-db/dist/queue-job-dao.js
 function assertValidTimeoutMs(value) {
   if (value === undefined || value === null)
@@ -35398,8 +35202,8 @@ var init_queue_job_dao = __esm(() => {
 
 // ../../node_modules/.bun/@gobing-ai+ts-db@0.5.32+3ceefb3da453b19a/node_modules/@gobing-ai/ts-db/dist/index.js
 var init_dist4 = __esm(() => {
+  init_base_dao();
   init_entity_dao();
-  init_inbox_message_dao();
   init_queue_job_dao();
 });
 
@@ -48413,16 +48217,34 @@ class RunSessionDao {
 var init_retro_correlation = () => {};
 
 // ../../packages/domain/src/dao/system-event-dao.ts
+function systemEventInsertSql(input) {
+  return {
+    sql: `INSERT INTO system_events (${SYSTEM_EVENT_COLUMNS})
+              SELECT ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8,
+                     CASE WHEN ?9 IS NULL THEN COALESCE(MAX(sequence), 0) + 1 ELSE ?9 END
+              FROM system_events`,
+    params: [
+      input.id,
+      input.event_name,
+      input.occurred_at,
+      input.actor ?? null,
+      input.payload_json ?? null,
+      input.run_id ?? null,
+      input.entity_kind ?? null,
+      input.entity_id ?? null,
+      input.sequence ?? null
+    ]
+  };
+}
+
 class SystemEventDao {
   db;
   constructor(db) {
     this.db = db;
   }
   async insert(input) {
-    await this.db.run(`INSERT INTO system_events (${SYSTEM_EVENT_COLUMNS})
-             SELECT ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8,
-                    CASE WHEN ?9 IS NULL THEN COALESCE(MAX(sequence), 0) + 1 ELSE ?9 END
-             FROM system_events`, input.id, input.event_name, input.occurred_at, input.actor ?? null, input.payload_json ?? null, input.run_id ?? null, input.entity_kind ?? null, input.entity_id ?? null, input.sequence ?? null);
+    const statement = systemEventInsertSql(input);
+    await this.db.run(statement.sql, ...statement.params);
   }
   async pruneQuotas(quotas, prefix) {
     try {
@@ -50199,6 +50021,228 @@ class ActionRunDao {
     }
   }
 }
+
+// ../../packages/domain/src/dao/inbox-dao.ts
+function toMessage(row) {
+  return {
+    id: row.id,
+    fromId: row.from_id,
+    toId: row.to_id,
+    body: row.body,
+    kind: row.kind === "request" ? "request" : "chat",
+    status: row.status,
+    claimedAt: row.claimed_at,
+    attempts: row.attempts,
+    error: row.error,
+    deliveredAt: row.delivered_at,
+    readAt: row.read_at,
+    inReplyTo: row.in_reply_to,
+    threadId: row.thread_id,
+    requestKey: row.request_key,
+    taskId: row.task_id,
+    parentRunId: row.parent_run_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function placeholders(values, start) {
+  return values.map((_, index) => `?${start + index}`).join(", ");
+}
+var COLUMNS = `id, from_id, to_id, body, kind, status, claimed_at, attempts, error, delivered_at,
+                 read_at, in_reply_to, thread_id, request_key, task_id, parent_run_id, created_at, updated_at`, transactionLocks, InboxDao;
+var init_inbox_dao = __esm(() => {
+  init_dist4();
+  init_system_event_dao();
+  transactionLocks = new WeakMap;
+  InboxDao = class InboxDao extends BaseDao {
+    constructor(adapter) {
+      super(adapter);
+    }
+    async withTransaction(fn) {
+      const previous = transactionLocks.get(this.adapter) ?? Promise.resolve();
+      const run = previous.then(async () => {
+        await this.adapter.exec("BEGIN IMMEDIATE");
+        try {
+          const result = await fn();
+          await this.adapter.exec("COMMIT");
+          return result;
+        } catch (error) {
+          await this.adapter.exec("ROLLBACK");
+          throw error;
+        }
+      });
+      transactionLocks.set(this.adapter, run.then(() => {
+        return;
+      }, () => {
+        return;
+      }));
+      return run;
+    }
+    async writeEvents(toEvent, changed) {
+      for (const row of changed) {
+        const statement = systemEventInsertSql(toEvent(row));
+        await this.adapter.run(statement.sql, ...statement.params);
+      }
+    }
+    async insert(input, toEvent) {
+      return this.withTransaction(async () => {
+        const [row] = await this.adapter.queryAll(`INSERT INTO inbox_messages (${COLUMNS})
+                 VALUES (?1, ?2, ?3, ?4, ?5, ?6, NULL, 0, NULL, NULL, NULL, ?7, ?8, ?9, ?10, ?11, ?12, ?13)
+                 RETURNING ${COLUMNS}`, input.id, input.fromId, input.toId, input.body, input.kind, input.status, input.inReplyTo, input.threadId, input.requestKey, input.taskId, input.parentRunId, input.createdAt, input.updatedAt);
+        if (row === undefined)
+          throw new Error(`inbox insert returned no row for ${input.id}`);
+        const message = toMessage(row);
+        await this.writeEvents(toEvent, [message]);
+        return message;
+      });
+    }
+    async findByRequestKey(requestKey) {
+      const [row] = await this.adapter.queryAll(`SELECT ${COLUMNS} FROM inbox_messages WHERE request_key = ?1`, requestKey);
+      return row === undefined ? null : toMessage(row);
+    }
+    async get(id) {
+      const [row] = await this.adapter.queryAll(`SELECT ${COLUMNS} FROM inbox_messages WHERE id = ?1`, id);
+      return row === undefined ? null : toMessage(row);
+    }
+    async claim(member, limit, now, toEvent) {
+      return this.withTransaction(async () => {
+        const rows = await this.adapter.queryAll(`UPDATE inbox_messages
+                 SET status = 'claimed', claimed_at = ?2, attempts = attempts + 1, updated_at = ?2
+                 WHERE id IN (
+                     SELECT id FROM inbox_messages
+                     WHERE to_id = ?1 AND status = 'queued'
+                     ORDER BY created_at ASC, rowid ASC
+                     LIMIT ?3
+                 )
+                 RETURNING ${COLUMNS}`, member, now, Math.max(0, limit));
+        const changed = rows.map(toMessage);
+        await this.writeEvents(toEvent, changed);
+        return changed;
+      });
+    }
+    async settle(ids, to, now, toEvent, error = null) {
+      if (ids.length === 0)
+        return [];
+      return this.withTransaction(async () => {
+        const rows = await this.adapter.queryAll(`UPDATE inbox_messages
+                 SET status = ?1, error = ?2,
+                     delivered_at = CASE WHEN ?1 = 'delivered' THEN ?3 ELSE NULL END,
+                     updated_at = ?3
+                 WHERE id IN (${placeholders(ids, 4)}) AND status = 'claimed'
+                 RETURNING ${COLUMNS}`, to, error, now, ...ids);
+        const changed = rows.map(toMessage);
+        await this.writeEvents(toEvent, changed);
+        return changed;
+      });
+    }
+    async release(ids, now, toEvent) {
+      if (ids.length === 0)
+        return [];
+      return this.withTransaction(async () => {
+        const rows = await this.adapter.queryAll(`UPDATE inbox_messages
+                 SET status = 'queued', claimed_at = NULL, updated_at = ?1
+                 WHERE id IN (${placeholders(ids, 2)}) AND status = 'claimed'
+                 RETURNING ${COLUMNS}`, now, ...ids);
+        const changed = rows.map(toMessage);
+        await this.writeEvents(toEvent, changed);
+        return changed;
+      });
+    }
+    async markRead(id, reader, now, toEvent) {
+      return this.withTransaction(async () => {
+        const [stamped] = await this.adapter.queryAll(`UPDATE inbox_messages SET read_at = ?3, updated_at = ?3
+                 WHERE id = ?1 AND to_id = ?2 AND read_at IS NULL
+                 RETURNING ${COLUMNS}`, id, reader, now);
+        if (stamped !== undefined) {
+          const message = toMessage(stamped);
+          await this.writeEvents(toEvent, [message]);
+          return { message, transitioned: true };
+        }
+        const [existing] = await this.adapter.queryAll(`SELECT ${COLUMNS} FROM inbox_messages WHERE id = ?1 AND to_id = ?2`, id, reader);
+        return existing === undefined ? null : { message: toMessage(existing), transitioned: false };
+      });
+    }
+    async listExpiredClaims(cutoff) {
+      const rows = await this.adapter.queryAll(`SELECT ${COLUMNS} FROM inbox_messages
+             WHERE status = 'claimed' AND claimed_at IS NOT NULL AND claimed_at < ?1
+             ORDER BY claimed_at ASC, rowid ASC`, cutoff);
+      return rows.map(toMessage);
+    }
+    async list(member, direction, limit, before) {
+      const scope = direction === "in" ? "to_id = ?1" : direction === "out" ? "from_id = ?1" : "(to_id = ?1 OR from_id = ?1)";
+      const cursor = before === undefined ? "" : "AND (created_at < ?3 OR (created_at = ?3 AND id < ?4))";
+      const params = [member, Math.max(0, limit) + 1];
+      if (before !== undefined)
+        params.push(before.createdAt, before.id);
+      const rows = await this.adapter.queryAll(`SELECT ${COLUMNS} FROM inbox_messages
+             WHERE ${scope} ${cursor}
+             ORDER BY created_at DESC, id DESC
+             LIMIT ?2`, ...params);
+      return rows.map(toMessage);
+    }
+    async thread(threadId) {
+      const rows = await this.adapter.queryAll(`SELECT ${COLUMNS} FROM inbox_messages
+             WHERE thread_id = ?1 OR id = ?1
+             ORDER BY created_at ASC, rowid ASC`, threadId);
+      return rows.map(toMessage);
+    }
+    async requests(toIds) {
+      if (toIds !== undefined && toIds.length === 0)
+        return [];
+      const scope = toIds === undefined ? `m.kind = 'request'` : `m.kind = 'request' AND m.to_id IN (${placeholders(toIds, 1)})`;
+      const rows = await this.adapter.queryAll(`SELECT ${COLUMNS.split(",").map((column) => `m.${column.trim()}`).join(", ")},
+                    r.run_id AS run_id, r.status AS run_status, r.outcome AS run_outcome,
+                    r.task_id AS run_task_id, r.artifact_refs_json AS run_artifact_refs_json
+             FROM inbox_messages m
+             LEFT JOIN coordination_runs r ON r.run_id = (
+                 SELECT c.run_id FROM coordination_runs c, json_each(c.message_ids_json) j
+                 WHERE j.value = m.id
+                 ORDER BY c.started_at DESC
+                 LIMIT 1
+             )
+             WHERE ${scope}
+             ORDER BY m.created_at DESC, m.rowid DESC`, ...toIds ?? []);
+      return rows.map((row) => ({
+        ...toMessage(row),
+        runId: row.run_id ?? null,
+        runStatus: row.run_status ?? null,
+        runOutcome: row.run_outcome ?? null,
+        runTaskId: row.run_task_id ?? null,
+        runArtifactRefsJson: row.run_artifact_refs_json ?? null
+      }));
+    }
+    async countQueued(member) {
+      const [row] = await this.adapter.queryAll(`SELECT COUNT(*) AS n FROM inbox_messages WHERE to_id = ?1 AND status = 'queued'`, member);
+      return row?.n ?? 0;
+    }
+    async distinctRecipients() {
+      return this.adapter.queryAll(`SELECT to_id AS id,
+                    SUM(CASE WHEN status = 'queued' THEN 1 ELSE 0 END) AS queued,
+                    SUM(CASE WHEN read_at IS NULL THEN 1 ELSE 0 END) AS unread
+             FROM inbox_messages
+             GROUP BY to_id
+             ORDER BY to_id ASC`);
+    }
+    async attemptsForTask(taskId) {
+      const rows = await this.adapter.queryAll(`SELECT ${COLUMNS} FROM inbox_messages
+             WHERE task_id = ?1
+             ORDER BY created_at DESC, rowid DESC`, taskId);
+      return { count: rows.length, latest: rows[0] === undefined ? null : toMessage(rows[0]) };
+    }
+    async listByTask(taskId) {
+      const rows = await this.adapter.queryAll(`SELECT ${COLUMNS} FROM inbox_messages
+             WHERE task_id = ?1
+             ORDER BY created_at DESC, rowid DESC`, taskId);
+      return rows.map(toMessage);
+    }
+  };
+});
+
+// ../../packages/domain/src/dao/addressed-spec-ids.ts
+var init_addressed_spec_ids = __esm(() => {
+  init_inbox_dao();
+});
+
 // ../../packages/domain/src/dao/agent-executor-update-dao.ts
 class AgentExecutorUpdateDao {
   db;
@@ -51300,113 +51344,6 @@ var init_decision_log_dao = __esm(() => {
   ];
 });
 
-// ../../packages/domain/src/dao/inbox-recent-dao.ts
-class InboxRecentDao {
-  db;
-  constructor(db) {
-    this.db = db;
-  }
-  async listRecent(limit = 50) {
-    const capped = Math.max(1, Math.min(limit, 500));
-    try {
-      return await this.db.queryAll(`SELECT id, from_id, to_id, body, status, created_at, in_reply_to
-                 FROM inbox_messages
-                 ORDER BY created_at DESC
-                 LIMIT ?1`, capped);
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("no such table: inbox_messages")) {
-        return [];
-      }
-      throw error;
-    }
-  }
-  async countReplies(ids) {
-    const result = new Map;
-    if (ids.length === 0)
-      return result;
-    const placeholders = ids.map((_, i) => `?${i + 1}`).join(", ");
-    try {
-      const rows = await this.db.queryAll(`SELECT in_reply_to, COUNT(*) AS n
-                 FROM inbox_messages
-                 WHERE in_reply_to IS NOT NULL AND in_reply_to IN (${placeholders})
-                 GROUP BY in_reply_to`, ...ids);
-      for (const row of rows) {
-        result.set(row.in_reply_to, row.n);
-      }
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("no such table: inbox_messages")) {
-        return result;
-      }
-      throw error;
-    }
-    return result;
-  }
-  async markRead(id, readerId, nowMs = Date.now()) {
-    try {
-      const [stamped] = await this.db.queryAll(`UPDATE inbox_messages SET read_at = ?3
-                 WHERE id = ?1 AND to_id = ?2 AND read_at IS NULL
-                 RETURNING read_at, from_id, in_reply_to`, id, readerId, nowMs);
-      if (stamped)
-        return toReceipt(stamped, true);
-      const [existing] = await this.db.queryAll("SELECT read_at, from_id, in_reply_to FROM inbox_messages WHERE id = ?1 AND to_id = ?2", id, readerId);
-      return existing?.read_at == null ? null : toReceipt(existing, false);
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("no such table: inbox_messages")) {
-        return null;
-      }
-      throw error;
-    }
-  }
-}
-var toReceipt = (row, transitioned) => ({
-  readAt: row.read_at ?? 0,
-  transitioned,
-  fromId: row.from_id,
-  inReplyTo: row.in_reply_to
-});
-
-// ../../packages/domain/src/dao/inbox-unfinished-dao.ts
-class InboxUnfinishedDao {
-  db;
-  constructor(db) {
-    this.db = db;
-  }
-  async listUnfinished(toId) {
-    try {
-      if (toId !== undefined) {
-        return await this.db.queryAll(`SELECT id, to_id, status, inject_attempts, inject_error, created_at, request_key
-                         FROM inbox_messages
-                         WHERE to_id = ?1
-                         ORDER BY created_at DESC`, toId) ?? [];
-      }
-      return await this.db.queryAll(`SELECT id, to_id, status, inject_attempts, inject_error, created_at, request_key
-                     FROM inbox_messages
-                     ORDER BY created_at DESC`) ?? [];
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("no such table: inbox_messages")) {
-        return [];
-      }
-      throw error;
-    }
-  }
-  async listByRequestKeyPrefix(prefix) {
-    if (prefix === "") {
-      throw new Error("listByRequestKeyPrefix requires a non-empty prefix");
-    }
-    try {
-      return await this.db.queryAll(`SELECT id, to_id, status, inject_attempts, inject_error, created_at, request_key
-                     FROM inbox_messages
-                     WHERE request_key LIKE ?1 ESCAPE '\\'
-                     ORDER BY created_at DESC`, `${prefix.replace(/[\\%_]/g, "\\$&")}%`) ?? [];
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("no such table: inbox_messages")) {
-        return [];
-      }
-      throw error;
-    }
-  }
-}
-
 // ../../packages/domain/src/dao/member-lifecycle.ts
 function parseObservation(payloadJson) {
   if (payloadJson === null)
@@ -52264,10 +52201,11 @@ var init_workspace_dao = __esm(() => {
 
 // ../../packages/domain/src/dao/index.ts
 var init_dao = __esm(() => {
-  init_dist4();
+  init_addressed_spec_ids();
   init_artifact_dao();
   init_database_inspector();
   init_decision_log_dao();
+  init_inbox_dao();
   init_member_lifecycle();
   init_member_session();
   init_phase_run_dao();
@@ -57721,17 +57659,17 @@ function parentDir(filePath) {
   const idx = filePath.lastIndexOf(sep);
   return idx <= 0 ? "." : filePath.slice(0, idx);
 }
-function isPromiseLike2(value) {
+function isPromiseLike(value) {
   return value !== null && typeof value === "object" && "then" in value;
 }
 function attachFileObserver(lifecycleBus, filePath, writer) {
   const logger = getLogger2("event-bus.file-observer");
   const ensureResult = writer.ensureDir(parentDir(filePath));
-  let ready = !isPromiseLike2(ensureResult);
-  let pending = isPromiseLike2(ensureResult);
+  let ready = !isPromiseLike(ensureResult);
+  let pending = isPromiseLike(ensureResult);
   let setupFailed = false;
   let sequence = 0;
-  let writeChain = isPromiseLike2(ensureResult) ? Promise.resolve(ensureResult).then(() => {
+  let writeChain = isPromiseLike(ensureResult) ? Promise.resolve(ensureResult).then(() => {
     ready = true;
   }).catch((error) => {
     setupFailed = true;
@@ -57760,7 +57698,7 @@ function attachFileObserver(lifecycleBus, filePath, writer) {
       return;
     if (ready && !pending) {
       const result = writer.appendFile(filePath, content);
-      if (isPromiseLike2(result)) {
+      if (isPromiseLike(result)) {
         setPending(Promise.resolve(result));
       }
       return;
@@ -65480,6 +65418,41 @@ var init_dist10 = __esm(() => {
   init_types3();
 });
 
+// ../../packages/domain/src/schema/inbox-messages.ts
+var inboxMessagesTable, inboxMessages3, INBOX_MESSAGES_TABLE_SQL;
+var init_inbox_messages2 = __esm(() => {
+  init_schema();
+  inboxMessagesTable = defineTable("inbox_messages", {
+    id: text("id").primaryKey(),
+    fromId: text("from_id").notNull(),
+    toId: text("to_id").notNull(),
+    body: text("body").notNull(),
+    kind: text("kind").notNull().default("chat"),
+    status: text("status").notNull().default("queued"),
+    claimedAt: integer2("claimed_at"),
+    attempts: integer2("attempts").notNull().default(0),
+    error: text("error"),
+    deliveredAt: integer2("delivered_at"),
+    readAt: integer2("read_at"),
+    inReplyTo: text("in_reply_to"),
+    threadId: text("thread_id"),
+    requestKey: text("request_key"),
+    taskId: text("task_id"),
+    parentRunId: text("parent_run_id"),
+    createdAt: integer2("created_at").notNull(),
+    updatedAt: integer2("updated_at").notNull()
+  });
+  inboxMessages3 = inboxMessagesTable.table;
+  INBOX_MESSAGES_TABLE_SQL = [
+    inboxMessagesTable.createTableSql,
+    "CREATE INDEX IF NOT EXISTS idx_inbox_messages_to_status ON inbox_messages (to_id, status)",
+    "CREATE INDEX IF NOT EXISTS idx_inbox_messages_from_created ON inbox_messages (from_id, created_at)",
+    "CREATE INDEX IF NOT EXISTS idx_inbox_messages_thread ON inbox_messages (thread_id)",
+    "CREATE UNIQUE INDEX IF NOT EXISTS idx_inbox_messages_request_key ON inbox_messages (request_key) WHERE request_key IS NOT NULL"
+  ].map((sql) => `${sql};`).join(`
+`);
+});
+
 // ../../packages/domain/src/schema/planning.ts
 var planningEventsTable, planningEvents, taskRunLinksTable, taskRunLinks, PLANNING_SCHEMA_SQL;
 var init_planning = __esm(() => {
@@ -65518,6 +65491,7 @@ var init_schema3 = __esm(() => {
   init_workflow_states();
   init_workspaces();
   init_artifacts();
+  init_inbox_messages2();
   init_phase_runs();
   init_planning();
   init_transition_runs();
@@ -65698,7 +65672,7 @@ ALTER TABLE inbox_messages ADD COLUMN request_key TEXT;
 CREATE UNIQUE INDEX IF NOT EXISTS idx_inbox_messages_request_key ON inbox_messages (request_key) WHERE request_key IS NOT NULL;
 `, INBOX_MESSAGES_READ_AT_SCHEMA_SQL = `
 ALTER TABLE inbox_messages ADD COLUMN read_at INTEGER;
-`, QUEUE_JOBS_SCHEMA_SQL = `
+`, INBOX_MESSAGES_REBUILD_SQL, QUEUE_JOBS_SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS queue_jobs (
     id TEXT PRIMARY KEY,
     type TEXT NOT NULL,
@@ -66457,6 +66431,10 @@ var init_migrations = __esm(() => {
   init_dist5();
   init_importer_schema_version();
   init_schema3();
+  INBOX_MESSAGES_REBUILD_SQL = `
+DROP TABLE IF EXISTS inbox_messages;
+${INBOX_MESSAGES_TABLE_SQL}
+`;
   CLI_SCHEMA_SQL = `
 ${AGENT_EXECUTOR_UPDATES_SCHEMA_SQL}
 
@@ -66680,6 +66658,10 @@ ${HISTORY_TASK_SESSION_SCHEMA_SQL}
       id: "0053_spur_cli_inbox_messages_read_at",
       sql: INBOX_MESSAGES_READ_AT_SCHEMA_SQL,
       addColumnIfMissing: { table: "inbox_messages", column: "read_at" }
+    },
+    {
+      id: "0054_spur_cli_inbox_messages_rebuild",
+      sql: INBOX_MESSAGES_REBUILD_SQL
     }
   ];
 });
@@ -84619,6 +84601,10 @@ var init_event_names = __esm(() => {
     baseEvent("message.sent", "message", "message"),
     baseEvent("message.replied", "message", "message"),
     baseEvent("message.read", "message", "message"),
+    baseEvent("message.claimed", "message", "message"),
+    baseEvent("message.delivered", "message", "message"),
+    baseEvent("message.failed", "message", "message"),
+    baseEvent("message.requeued", "message", "message"),
     baseEvent("process.spawned", "process", "process"),
     baseEvent("process.exited", "process", "process"),
     baseEvent("process.stopped", "process", "process"),
@@ -84957,6 +84943,66 @@ var init_event_names = __esm(() => {
       },
       outcome: unsupported
     },
+    "message.claimed": {
+      description: "A member claimed a queued inbox message; the delivery budget was charged.",
+      fields: [
+        field("msgId", "Message"),
+        field("fromId", "From"),
+        field("toId", "Member"),
+        field("threadId", "Thread"),
+        field("status", "Status")
+      ],
+      summary: ({ data }) => {
+        const to = s2(data, "toId");
+        return to !== undefined ? `[message] ${to} claimed` : "[message] claimed";
+      },
+      outcome: unsupported
+    },
+    "message.delivered": {
+      description: "A claimed message was delivered to its member.",
+      fields: [
+        field("msgId", "Message"),
+        field("fromId", "From"),
+        field("toId", "Member"),
+        field("threadId", "Thread"),
+        field("status", "Status")
+      ],
+      summary: ({ data }) => {
+        const to = s2(data, "toId");
+        return to !== undefined ? `[message] ${to} delivered` : "[message] delivered";
+      },
+      outcome: unsupported
+    },
+    "message.failed": {
+      description: "A message could not be delivered \u2014 the attempt budget was spent or the run errored.",
+      fields: [
+        field("msgId", "Message"),
+        field("fromId", "From"),
+        field("toId", "Member"),
+        field("threadId", "Thread"),
+        field("status", "Status")
+      ],
+      summary: ({ data }) => {
+        const to = s2(data, "toId");
+        return to !== undefined ? `[message] ${to} delivery failed` : "[message] failed";
+      },
+      outcome: unsupported
+    },
+    "message.requeued": {
+      description: "A claim expired or was released, returning the message to the member queue.",
+      fields: [
+        field("msgId", "Message"),
+        field("fromId", "From"),
+        field("toId", "Member"),
+        field("threadId", "Thread"),
+        field("status", "Status")
+      ],
+      summary: ({ data }) => {
+        const to = s2(data, "toId");
+        return to !== undefined ? `[message] ${to} requeued` : "[message] requeued";
+      },
+      outcome: unsupported
+    },
     "process.spawned": {
       description: "A supervised process was spawned with a new pid.",
       fields: [field("label", "Label"), field("pid", "PID"), field("agentId", "Agent")],
@@ -90820,8 +90866,482 @@ var init_fleet_service = __esm(() => {
   init_project_registry();
 });
 
+// ../../packages/app/src/services/system-event-retention.ts
+function resolveRetentionQuotas(config = {}, prefixes = SYSTEM_EVENT_PREFIXES) {
+  const defaultQuota = config.default ?? DEFAULT_SYSTEM_EVENT_RETENTION_QUOTA;
+  const overrides = config.prefixes ?? {};
+  return prefixes.map((prefix) => ({
+    prefix,
+    quota: overrides[prefix] ?? defaultQuota
+  }));
+}
+var DEFAULT_SYSTEM_EVENT_RETENTION_QUOTA = 1e4;
+var init_system_event_retention = __esm(() => {
+  init_event_names();
+});
+
+// ../../packages/app/src/services/system-event-tap.ts
+function registerSystemEventTap(bus, dao, logger, options = {}) {
+  const handlers = new Map;
+  const inFlight = new Set;
+  const diagnosticEnabled = options.diagnosticEnabled === true;
+  const quotas = resolveRetentionQuotas(options.retention);
+  for (const entry of SYSTEM_EVENT_CATALOG) {
+    if (entry.tier === "diagnostic" && !diagnosticEnabled)
+      continue;
+    if (entry.prefix === "message")
+      continue;
+    const handler = (event) => {
+      const actor = extractSystemEventActor(event);
+      const p = persist(dao, entry.prefix, {
+        id: createId("sev"),
+        event_name: entry.name,
+        occurred_at: new Date().toISOString(),
+        actor,
+        payload_json: safeStringify(buildSystemEventEnvelope(entry, event, options.projectContext ?? systemEventProjectContext(""), options.secretValues, actor)),
+        ...extractSystemEventCorrelation(event)
+      }, quotas, logger);
+      inFlight.add(p);
+      p.finally(() => inFlight.delete(p));
+    };
+    handlers.set(entry.name, handler);
+    bus.on(entry.name, handler);
+  }
+  return {
+    unsubscribe: () => {
+      for (const [name, handler] of handlers) {
+        bus.off(name, handler);
+      }
+      handlers.clear();
+    },
+    flush: async () => {
+      while (inFlight.size > 0) {
+        await Promise.allSettled(inFlight);
+      }
+    }
+  };
+}
+async function persist(dao, prefix, input, quotas, logger) {
+  try {
+    await dao.insert(input);
+    await dao.pruneQuotas(quotas, prefix);
+  } catch (error) {
+    logger.warn("system_events tap: persist failed", {
+      name: input.event_name,
+      error: stringifyError(error)
+    });
+  }
+}
+function safeStringify(event) {
+  try {
+    return JSON.stringify(event ?? null);
+  } catch {
+    return null;
+  }
+}
+function extractSystemEventActor(event) {
+  if (event && typeof event === "object") {
+    const obj = event;
+    if (typeof obj.actor === "string" && obj.actor.length > 0)
+      return obj.actor;
+    if (typeof obj.agentId === "string" && obj.agentId.length > 0)
+      return obj.agentId;
+    if (typeof obj.memberId === "string" && obj.memberId.length > 0)
+      return obj.memberId;
+  }
+  return null;
+}
+function extractSystemEventCorrelation(event) {
+  const correlation = { run_id: null, entity_kind: null, entity_id: null, sequence: null };
+  if (!event || typeof event !== "object")
+    return correlation;
+  const obj = event;
+  const nested = obj.correlation && typeof obj.correlation === "object" ? obj.correlation : {};
+  const runId = obj.runId ?? obj.run_id ?? nested.runId;
+  if (typeof runId === "string" && runId.length > 0)
+    correlation.run_id = runId;
+  if (typeof obj.sequence === "number" && Number.isFinite(obj.sequence))
+    correlation.sequence = obj.sequence;
+  const entity = obj.entity;
+  if (entity && typeof entity === "object") {
+    const { kind, id } = entity;
+    if (typeof kind === "string" && kind.length > 0)
+      correlation.entity_kind = kind;
+    if (typeof id === "string" && id.length > 0)
+      correlation.entity_id = id;
+  }
+  if (typeof obj.entityKind === "string" && obj.entityKind.length > 0)
+    correlation.entity_kind = obj.entityKind;
+  if (typeof obj.entityId === "string" && obj.entityId.length > 0)
+    correlation.entity_id = obj.entityId;
+  return correlation;
+}
+function stringifyError(error) {
+  if (error instanceof Error)
+    return `${error.name}: ${error.message}`;
+  return String(error);
+}
+var init_system_event_tap = __esm(() => {
+  init_src2();
+  init_event_names();
+  init_system_event_envelope();
+  init_system_event_retention();
+});
+
+// ../../packages/app/src/services/system-event-catch-all.ts
+function genericSystemEventCatalogEntry(name) {
+  return {
+    name,
+    prefix: name.replace(/\..*/, ""),
+    source: "bus",
+    tier: "default",
+    persisted: true,
+    streamed: true,
+    payloadPolicy: "metadata-only",
+    renderer: GENERIC_SYSTEM_EVENT_RENDERER,
+    producerPackage: "spur",
+    subsystem: "unknown",
+    severity: "info",
+    description: "Uncataloged system event captured by the generic fallback; pending catalog promotion.",
+    metadataFields: [],
+    remediationKind: "none"
+  };
+}
+function ensureRetentionQuotaForPrefix(quotas, prefix, fallbackQuota) {
+  return quotas.some((quota) => quota.prefix === prefix) ? quotas : [...quotas, { prefix, quota: fallbackQuota }];
+}
+function createSystemEventCatchAllSink(options) {
+  const { dao, logger } = options;
+  const quotas = resolveRetentionQuotas(options.retention);
+  const fallbackQuota = options.retention?.default ?? DEFAULT_SYSTEM_EVENT_RETENTION_QUOTA;
+  const projectContext = options.projectContext ?? systemEventProjectContext("");
+  const secretValues = options.secretValues ?? [];
+  const driftWarned = new Set;
+  return async (name, payload) => {
+    const entry = genericSystemEventCatalogEntry(name);
+    const actor = extractSystemEventActor(payload);
+    try {
+      await dao.insert({
+        id: createId("sev"),
+        event_name: entry.name,
+        occurred_at: new Date().toISOString(),
+        actor,
+        payload_json: safeStringify(buildSystemEventEnvelope(entry, payload, projectContext, secretValues, actor)),
+        ...extractSystemEventCorrelation(payload)
+      });
+      await dao.pruneQuotas(ensureRetentionQuotaForPrefix(quotas, entry.prefix, fallbackQuota), entry.prefix);
+    } catch (error) {
+      logger.warn("system_events catch-all: persist failed", {
+        event: name,
+        error: error instanceof Error ? `${error.name}: ${error.message}` : String(error)
+      });
+      return;
+    }
+    if (!driftWarned.has(name)) {
+      driftWarned.add(name);
+      logger.warn(SYSTEM_EVENT_UNCATALOGED_WARN_EVENT, { event: name });
+    }
+  };
+}
+function installSystemEventCatchAll(bus, sink) {
+  const holder = bus;
+  const current = holder.emit;
+  if (current[CATCH_ALL_MARKER] === true) {
+    return { installed: false, flush: async () => {} };
+  }
+  const underlying = current.bind(bus);
+  const inFlight = new Set;
+  const wrapped = (event, ...args) => {
+    const result = underlying(event, ...args);
+    if (systemEventCatalogEntry(event) === undefined) {
+      const pending = Promise.resolve().then(() => sink(event, args[0]));
+      inFlight.add(pending);
+      pending.catch(() => {}).finally(() => {
+        inFlight.delete(pending);
+      });
+    }
+    return result;
+  };
+  Object.defineProperty(wrapped, CATCH_ALL_MARKER, { value: true });
+  holder.emit = wrapped;
+  return {
+    installed: true,
+    flush: async () => {
+      while (inFlight.size > 0) {
+        await Promise.allSettled([...inFlight]);
+      }
+    }
+  };
+}
+var GENERIC_SYSTEM_EVENT_RENDERER = "generic", SYSTEM_EVENT_UNCATALOGED_WARN_EVENT = "system_events.uncataloged", CATCH_ALL_MARKER = "spur.systemEventCatchAll";
+var init_system_event_catch_all = __esm(() => {
+  init_src2();
+  init_event_names();
+  init_system_event_envelope();
+  init_system_event_retention();
+  init_system_event_tap();
+});
+
+// ../../packages/app/src/services/inbox-service.ts
+function isReservedInboxId(id) {
+  return RESERVED_INBOX_IDS.includes(id);
+}
+function assertSameRequest(existing, input) {
+  const sameRequest = existing.fromId === input.from && existing.toId === input.to && existing.body === input.body && existing.kind === (input.kind ?? "chat");
+  if (!sameRequest)
+    throw new RequestKeyConflictError2(input.requestKey ?? "");
+  return existing;
+}
+function isRequestKeyCollision(error) {
+  if (!(error instanceof Error))
+    return false;
+  const code = error.code;
+  if (code === "SQLITE_CONSTRAINT_UNIQUE") {
+    return error.message.includes("inbox_messages.request_key") || !error.message.includes("constraint failed");
+  }
+  return error.message.includes("UNIQUE constraint failed") && error.message.includes("inbox_messages.request_key");
+}
+function encodeCursor(row) {
+  return Buffer.from(JSON.stringify({ c: row.createdAt, i: row.id })).toString("base64url");
+}
+function decodeCursor(cursor) {
+  try {
+    const parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    if (typeof parsed.c !== "number" || typeof parsed.i !== "string")
+      throw new Error("shape");
+    return { createdAt: parsed.c, id: parsed.i };
+  } catch {
+    throw new Error("malformed list cursor");
+  }
+}
+
+class InboxService {
+  deps;
+  leaseMs;
+  clock;
+  constructor(deps) {
+    this.deps = deps;
+    this.leaseMs = deps.leaseMs ?? CLAIM_LEASE_MS;
+    this.clock = deps.now ?? (() => Date.now());
+  }
+  async send(input) {
+    if (input.from.trim() === "")
+      throw new Error("inbox message requires a non-empty sender");
+    if (input.to.trim() === "")
+      throw new Error("inbox message requires a non-empty recipient");
+    const db = await this.deps.getDb();
+    const dao = new InboxDao(db);
+    if (input.requestKey !== undefined) {
+      const existing = await dao.findByRequestKey(input.requestKey);
+      if (existing !== null)
+        return { message: assertSameRequest(existing, input), replayed: true };
+    }
+    const now = this.clock();
+    const id = `msg_${crypto.randomUUID()}`;
+    let message;
+    try {
+      message = await dao.insert({
+        id,
+        fromId: input.from,
+        toId: input.to,
+        body: input.body,
+        kind: input.kind ?? "chat",
+        status: "queued",
+        requestKey: input.requestKey ?? null,
+        taskId: input.taskId ?? null,
+        parentRunId: input.parentRunId ?? null,
+        inReplyTo: null,
+        threadId: id,
+        createdAt: now,
+        updatedAt: now
+      }, this.eventFactory("message.sent"));
+    } catch (error) {
+      if (input.requestKey !== undefined && isRequestKeyCollision(error)) {
+        const winner = await dao.findByRequestKey(input.requestKey);
+        if (winner !== null)
+          return { message: assertSameRequest(winner, input), replayed: true };
+      }
+      throw error;
+    }
+    await this.pruneEvents(db);
+    return { message, replayed: false };
+  }
+  async reply(id, from, body) {
+    const db = await this.deps.getDb();
+    const dao = new InboxDao(db);
+    const original = await dao.get(id);
+    if (original === null)
+      throw new MessageNotFoundError(`No message found with id "${id}"`);
+    const now = this.clock();
+    const replyId = `msg_${crypto.randomUUID()}`;
+    const message = await dao.insert({
+      id: replyId,
+      fromId: from,
+      toId: original.fromId,
+      body,
+      kind: original.kind,
+      status: "queued",
+      requestKey: null,
+      taskId: original.taskId,
+      parentRunId: original.parentRunId,
+      inReplyTo: original.id,
+      threadId: original.threadId,
+      createdAt: now,
+      updatedAt: now
+    }, this.eventFactory("message.replied"));
+    await this.pruneEvents(db);
+    return message;
+  }
+  async get(id) {
+    return new InboxDao(await this.deps.getDb()).get(id);
+  }
+  async claim(member, limit) {
+    const db = await this.deps.getDb();
+    const claimed = await new InboxDao(db).claim(member, limit, this.clock(), this.eventFactory("message.claimed"));
+    await this.pruneEvents(db);
+    return claimed;
+  }
+  async settle(ids, outcome, error) {
+    if (ids.length === 0)
+      return [];
+    const db = await this.deps.getDb();
+    const settled = await new InboxDao(db).settle(ids, outcome === "accepted" ? "delivered" : "failed", this.clock(), this.eventFactory(outcome === "accepted" ? "message.delivered" : "message.failed"), outcome === "accepted" ? null : error ?? "delivery did not start");
+    await this.pruneEvents(db);
+    return settled;
+  }
+  async release(ids) {
+    if (ids.length === 0)
+      return [];
+    const db = await this.deps.getDb();
+    const released = await new InboxDao(db).release(ids, this.clock(), this.eventFactory("message.requeued"));
+    await this.pruneEvents(db);
+    return released;
+  }
+  async sweep(now = this.clock()) {
+    const db = await this.deps.getDb();
+    const dao = new InboxDao(db);
+    const runs = new CoordinationRunDao(db);
+    const cutoff = now - this.leaseMs;
+    const result = { requeued: [], failed: [], settled: [] };
+    for (const message of await dao.listExpiredClaims(cutoff)) {
+      const receipt = (await runs.listByMessageId(message.id))[0];
+      if (receipt !== undefined) {
+        if (receipt.status === "running")
+          continue;
+        const delivered = receipt.outcome === "verified" || receipt.outcome === "run-exit-only";
+        const settled = await dao.settle([message.id], delivered ? "delivered" : "failed", now, this.eventFactory(delivered ? "message.delivered" : "message.failed"), delivered ? null : `run ${receipt.run_id} ${receipt.status}`);
+        for (const row of settled)
+          result.settled.push(row.id);
+        continue;
+      }
+      if (message.attempts >= MAX_DELIVERY_ATTEMPTS) {
+        const failed = await dao.settle([message.id], "failed", now, this.eventFactory("message.failed"), `attempts exhausted after ${MAX_DELIVERY_ATTEMPTS} deliveries`);
+        for (const row of failed)
+          result.failed.push(row.id);
+        continue;
+      }
+      const requeued = await dao.release([message.id], now, this.eventFactory("message.requeued"));
+      for (const row of requeued)
+        result.requeued.push(row.id);
+    }
+    await this.pruneEvents(db);
+    return result;
+  }
+  async markRead(id, reader) {
+    const db = await this.deps.getDb();
+    const receipt = await new InboxDao(db).markRead(id, reader, this.clock(), this.eventFactory("message.read"));
+    if (receipt === null)
+      throw new MessageNotFoundError(`message ${id} not found for ${reader}`);
+    await this.pruneEvents(db);
+    return { readAt: receipt.message.readAt ?? this.clock(), transitioned: receipt.transitioned };
+  }
+  async list(member, direction = "in", page) {
+    const dao = new InboxDao(await this.deps.getDb());
+    const limit = page?.limit ?? 100;
+    const before = page?.cursor === undefined ? undefined : decodeCursor(page.cursor);
+    const rows = await dao.list(member, direction, limit, before);
+    const messages = rows.slice(0, limit);
+    const last = messages.at(-1);
+    return {
+      messages,
+      nextCursor: rows.length > limit && last !== undefined ? encodeCursor(last) : null
+    };
+  }
+  async thread(id) {
+    const dao = new InboxDao(await this.deps.getDb());
+    const root = await dao.get(id);
+    return dao.thread(root?.threadId ?? id);
+  }
+  async requests(member) {
+    return new InboxDao(await this.deps.getDb()).requests(member === undefined ? undefined : [member]);
+  }
+  async countQueued(member) {
+    return new InboxDao(await this.deps.getDb()).countQueued(member);
+  }
+  async members() {
+    return new InboxDao(await this.deps.getDb()).distinctRecipients();
+  }
+  async attempts(taskId) {
+    return new InboxDao(await this.deps.getDb()).attemptsForTask(taskId);
+  }
+  async taskAttempts(taskId) {
+    return new InboxDao(await this.deps.getDb()).listByTask(taskId);
+  }
+  eventFactory(name) {
+    return (row) => ({
+      id: `sev_${crypto.randomUUID()}`,
+      event_name: name,
+      occurred_at: new Date(row.updatedAt).toISOString(),
+      actor: name === "message.read" || name === "message.claimed" || name === "message.delivered" || name === "message.failed" || name === "message.requeued" ? row.toId : row.fromId,
+      payload_json: JSON.stringify({
+        msgId: row.id,
+        fromId: row.fromId,
+        toId: row.toId,
+        threadId: row.threadId,
+        status: row.status,
+        createdAt: new Date(row.createdAt).toISOString()
+      })
+    });
+  }
+  async pruneEvents(db) {
+    try {
+      const quotas = ensureRetentionQuotaForPrefix(resolveRetentionQuotas(), "message", DEFAULT_SYSTEM_EVENT_RETENTION_QUOTA);
+      await new SystemEventDao(db).pruneQuotas(quotas, "message");
+    } catch {}
+  }
+}
+var OPERATOR_INBOX_ID = "operator", SPUR_INBOX_ID = "spur", RESERVED_INBOX_IDS, MAX_DELIVERY_ATTEMPTS = 3, RequestKeyConflictError2, CLAIM_LEASE_MS = 600000;
+var init_inbox_service = __esm(() => {
+  init_src2();
+  init_agent_coordination_service();
+  init_system_event_catch_all();
+  init_system_event_retention();
+  RESERVED_INBOX_IDS = [OPERATOR_INBOX_ID, SPUR_INBOX_ID];
+  RequestKeyConflictError2 = class RequestKeyConflictError2 extends Error {
+    requestKey;
+    constructor(requestKey) {
+      super(`request key "${requestKey}" already names a different message`);
+      this.requestKey = requestKey;
+      this.name = "RequestKeyConflictError";
+    }
+  };
+});
+
 // ../../packages/app/src/services/agent-coordination-service.ts
 import { join as join22 } from "path";
+function toInboxEntry(row) {
+  return {
+    id: row.id,
+    fromId: row.fromId,
+    body: row.body,
+    status: row.status,
+    createdAt: new Date(row.createdAt).toISOString(),
+    inReplyTo: row.inReplyTo,
+    injectAttempts: row.attempts,
+    injectError: row.error,
+    requestKey: row.requestKey
+  };
+}
 
 class AgentCoordinationService {
   ctx;
@@ -90830,157 +91350,88 @@ class AgentCoordinationService {
     this.ctx = ctx;
     this.configDir = join22(ctx.cwd, ".spur", "agents");
   }
-  async sendMessage(fromId, toId, body, replyTo, requestKey) {
+  async sendMessage(fromId, toId, body, replyTo, requestKey, extra) {
     validateAgentId(toId);
     if (fromId !== null)
       validateAgentId(fromId);
     if (requestKey !== undefined && requestKey.trim() === "") {
       throw new Error("requestKey must be a non-empty string");
     }
-    const dao = await this.inboxDao();
-    const keyed = requestKey !== undefined ? await dao.enqueueIdempotent(fromId, toId, body, requestKey, replyTo) : null;
-    const msgId = keyed?.id ?? await dao.enqueue(fromId, toId, body, replyTo);
-    await this.emitMessageEvent(replyTo !== undefined ? "message.replied" : "message.sent", {
-      msgId,
-      fromId,
-      toId,
-      threadId: replyTo ?? null,
-      createdAt: new Date().toISOString()
+    const sender = fromId ?? OPERATOR_INBOX_ID;
+    const service = await this.inboxService();
+    if (replyTo !== undefined) {
+      const reply = await service.reply(replyTo, sender, body);
+      return { msgId: reply.id, toId: reply.toId, status: reply.status, injected: false };
+    }
+    const { message, replayed } = await service.send({
+      from: sender,
+      to: toId,
+      body,
+      kind: extra?.kind ?? "chat",
+      ...requestKey !== undefined ? { requestKey } : {},
+      ...extra?.taskId !== undefined ? { taskId: extra.taskId } : {},
+      ...extra?.parentRunId !== undefined ? { parentRunId: extra.parentRunId } : {}
     });
-    return keyed === null ? { msgId, toId, status: "queued", injected: false } : { msgId, toId, status: "queued", injected: false, replayed: keyed.replayed, requestKey };
+    return requestKey === undefined ? { msgId: message.id, toId: message.toId, status: message.status, injected: false } : {
+      msgId: message.id,
+      toId: message.toId,
+      status: message.status,
+      injected: false,
+      replayed,
+      requestKey
+    };
   }
   async markMessageRead(msgId, readerId) {
     validateAgentId(readerId);
-    const receipt = await (await this.inboxRecentDao()).markRead(msgId, readerId);
+    const receipt = await (await this.inboxService()).markRead(msgId, readerId).catch(() => null);
     if (receipt === null)
       throw new MessageNotFoundError(`message ${msgId} not found for ${readerId}`);
-    const readAt = new Date(receipt.readAt).toISOString();
-    if (receipt.transitioned) {
-      await this.emitMessageEvent("message.read", {
-        msgId,
-        fromId: receipt.fromId,
-        toId: readerId,
-        threadId: receipt.inReplyTo,
-        createdAt: readAt
-      });
-    }
-    return { readAt, transitioned: receipt.transitioned };
+    return { readAt: new Date(receipt.readAt).toISOString(), transitioned: receipt.transitioned };
   }
   async getInbox(agentId, limit, offset) {
     validateAgentId(agentId);
-    const dao = await this.inboxDao();
-    const rows = await dao.inbox(agentId, limit, offset);
-    return {
-      messages: rows.map((row) => ({
-        id: row.id,
-        fromId: row.fromId,
-        body: row.body,
-        status: row.status,
-        createdAt: new Date(row.createdAt).toISOString(),
-        inReplyTo: row.inReplyTo,
-        injectAttempts: row.injectAttempts,
-        injectError: row.injectError,
-        requestKey: row.requestKey
-      })),
-      count: rows.length
-    };
+    const { messages: rows } = await (await this.inboxService()).list(agentId, "in", {
+      ...limit !== undefined ? { limit } : {}
+    });
+    return { messages: rows.map(toInboxEntry), count: rows.length };
   }
   async getMessage(msgId) {
-    const dao = await this.inboxDao();
-    const row = await dao.getById(msgId);
-    if (row === undefined)
+    const row = await (await this.inboxService()).get(msgId);
+    if (row === null)
       return null;
-    return { id: row.id, toId: row.toId, status: row.status, requestKey: row.requestKey ?? null };
+    return { id: row.id, toId: row.toId, status: row.status, requestKey: row.requestKey };
   }
   async drainPending(agentId, options) {
     validateAgentId(agentId);
-    const dao = await this.inboxDao();
-    const rows = await dao.drainPending(agentId, options);
-    return {
-      messages: rows.map((row) => ({
-        id: row.id,
-        fromId: row.fromId,
-        body: row.body,
-        status: row.status,
-        createdAt: new Date(row.createdAt).toISOString(),
-        inReplyTo: row.inReplyTo,
-        requestKey: row.requestKey
-      })),
-      count: rows.length
-    };
+    const rows = await (await this.inboxService()).claim(agentId, options?.limit ?? 100);
+    return { messages: rows.map(toInboxEntry), count: rows.length };
   }
   async releasePending(msgIds) {
     if (msgIds.length === 0)
       return 0;
-    const dao = await this.inboxDao();
-    return dao.release(msgIds);
+    return (await (await this.inboxService()).release(msgIds)).length;
   }
   async settleDelivered(msgIds) {
     if (msgIds.length === 0)
       return;
-    const dao = await this.inboxDao();
-    for (const msgId of msgIds)
-      await dao.markDelivered(msgId);
+    await (await this.inboxService()).settle(msgIds, "accepted");
   }
   async settleFailed(msgIds, error) {
     if (msgIds.length === 0)
       return;
-    const dao = await this.inboxDao();
-    for (const msgId of msgIds)
-      await dao.markFailed(msgId, error);
+    await (await this.inboxService()).settle(msgIds, "not-started", error);
   }
   async countPending(agentId) {
     validateAgentId(agentId);
-    const dao = await this.inboxDao();
-    return dao.countPending(agentId);
-  }
-  async listRecent(limit = 50) {
-    const dao = await this.inboxRecentDao();
-    const rows = await dao.listRecent(limit);
-    if (rows.length === 0) {
-      return { messages: [], count: 0 };
-    }
-    const specs = await this.listAgentSpecs();
-    const identityById = new Map;
-    for (const spec of specs) {
-      identityById.set(spec.id, {
-        agentId: spec.id,
-        memberLabel: spec.name,
-        agentType: spec.type
-      });
-    }
-    const replyCounts = await dao.countReplies(rows.map((r) => r.id));
-    const resolveEndpoint = (agentId) => identityById.get(agentId) ?? { agentId };
-    return {
-      messages: rows.map((row) => {
-        const replyCount = replyCounts.get(row.id) ?? 0;
-        return {
-          id: row.id,
-          fromId: row.from_id,
-          toId: row.to_id,
-          body: row.body,
-          status: row.status,
-          createdAt: new Date(row.created_at).toISOString(),
-          inReplyTo: row.in_reply_to,
-          ...row.from_id !== null ? { from: resolveEndpoint(row.from_id) } : {},
-          to: resolveEndpoint(row.to_id),
-          hasReply: replyCount > 0,
-          replyCount
-        };
-      }),
-      count: rows.length
-    };
+    return (await this.inboxService()).countQueued(agentId);
   }
   async replyToMessage(msgId, body) {
-    const dao = await this.inboxDao();
-    const original = await dao.getById(msgId);
-    if (original === undefined) {
+    const service = await this.inboxService();
+    const original = await service.get(msgId);
+    if (original === null)
       throw new Error(`No message found with id "${msgId}"`);
-    }
-    if (original.fromId === null) {
-      throw new Error(`Message "${msgId}" has no sender to reply to (operator-originated)`);
-    }
-    return this.sendMessage(original.toId, original.fromId, body, msgId);
+    const reply = await service.reply(msgId, original.toId, body);
+    return { msgId: reply.id, toId: reply.toId, status: reply.status, injected: false };
   }
   async assignTask(taskId, agentId) {
     validateAgentId(agentId);
@@ -91032,7 +91483,13 @@ class AgentCoordinationService {
     for (const id of shadowed) {
       this.ctx.output?.error(`agent spec "${id}" under .spur/agents/ is shadowed by the agent.fleet declaration`);
     }
-    return specs;
+    const addressable = specs.filter((spec) => {
+      if (!isReservedInboxId(spec.id))
+        return true;
+      this.ctx.output?.error(`agent spec "${spec.id}" uses a reserved inbox identity and is ignored`);
+      return false;
+    });
+    return addressable;
   }
   async listFleetMembers() {
     return (await this.fleetService().resolve(this.ctx.cwd)).members;
@@ -91061,27 +91518,8 @@ class AgentCoordinationService {
       openDb: () => this.ctx.getDb()
     });
   }
-  async inboxDao() {
-    const db = await this.ctx.getDb();
-    return new InboxMessageDao(db);
-  }
-  async emitMessageEvent(name, payload) {
-    const bus = this.ctx.eventBus;
-    try {
-      if (bus) {
-        bus.emit(name, { ...payload, severity: "info" });
-      } else {
-        await new SystemEventDao(await this.ctx.getDb()).insert({
-          id: crypto.randomUUID(),
-          event_name: name,
-          occurred_at: payload.createdAt,
-          actor: (name === "message.read" ? payload.toId : payload.fromId) ?? "operator",
-          payload_json: JSON.stringify(payload)
-        });
-      }
-    } catch (error) {
-      this.ctx.output?.error(`Message stored, but wake event failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
+  async inboxService() {
+    return new InboxService({ getDb: () => this.ctx.getDb() });
   }
   emitTaskAssignedEvent(payload) {
     const bus = this.ctx.eventBus;
@@ -91102,16 +91540,13 @@ class AgentCoordinationService {
       return null;
     }
   }
-  async inboxRecentDao() {
-    const db = await this.ctx.getDb();
-    return new InboxRecentDao(db);
-  }
 }
 var MessageNotFoundError;
 var init_agent_coordination_service = __esm(() => {
   init_src2();
   init_dist9();
   init_fleet_service();
+  init_inbox_service();
   MessageNotFoundError = class MessageNotFoundError extends Error {
   };
 });
@@ -93106,9 +93541,10 @@ async function dispatchToFleet(input, deps) {
   try {
     ({ messageId } = await deps.dispatcher.enqueue({
       member: member.instanceId,
-      fromId: `workflow-${input.runId}`,
+      fromId: "spur",
       body,
-      requestKey: `${input.runId}/${input.state}`
+      requestKey: `${input.runId}/${input.state}`,
+      parentRunId: input.runId
     }));
   } catch (error) {
     return {
@@ -103549,64 +103985,58 @@ class DeliveryReconciler {
   constructor(ctx) {
     this.ctx = ctx;
   }
-  async classify(agentId) {
-    const db = await this.ctx.getDb();
-    const rows = await new InboxUnfinishedDao(db).listUnfinished(agentId);
-    const runs = new CoordinationRunDao(db);
+  async inbox() {
+    return new InboxService({ getDb: () => this.ctx.getDb() });
+  }
+  async classify(agentId, rows) {
+    const requests = rows ?? await (await this.inbox()).requests(agentId);
     const unresolved = [];
-    for (const row of rows) {
+    for (const row of requests) {
       const base = {
         messageId: row.id,
-        toId: row.to_id,
-        injectAttempts: row.inject_attempts,
-        requestKey: row.request_key,
-        ...row.inject_error !== null && row.inject_error !== "" ? { injectError: row.inject_error } : {}
+        toId: row.toId,
+        injectAttempts: row.attempts,
+        requestKey: row.requestKey,
+        ...row.error !== null && row.error !== "" ? { injectError: row.error } : {}
       };
       if (row.status === "failed") {
         unresolved.push({
           ...base,
-          reason: row.inject_attempts >= MAX_INJECT_ATTEMPTS ? "attempts-exhausted" : "delivery-failed",
+          reason: row.attempts >= MAX_DELIVERY_ATTEMPTS ? "attempts-exhausted" : "delivery-failed",
           artifacts: []
         });
         continue;
       }
-      if (row.status === "injected" || row.status === "delivered") {
-        const runRow = (await runs.listByMessageId(row.id))[0];
-        if (runRow === undefined) {
+      if (row.status === "claimed" || row.status === "delivered") {
+        if (row.runId === null) {
           unresolved.push({ ...base, reason: "outcome-unknown", artifacts: [] });
           continue;
         }
-        const completed = runRow.completed_at !== null && runRow.status !== "running";
-        if (completed && runRow.outcome === "verified")
+        const completed = row.runStatus !== "running";
+        if (completed && row.runOutcome === "verified")
           continue;
         unresolved.push({
           ...base,
-          reason: !completed ? "outcome-unknown" : runRow.outcome === "errored" ? "delivery-failed" : runRow.outcome === "run-exit-only" ? "run-exit-only" : "outcome-unknown",
-          runId: runRow.run_id,
-          runStatus: runRow.status,
-          ...runRow.task_id !== null ? { taskId: runRow.task_id } : {},
-          artifacts: parseArtifactRefs2(runRow.artifact_refs_json)
+          reason: !completed ? "outcome-unknown" : row.runOutcome === "errored" ? "delivery-failed" : row.runOutcome === "run-exit-only" ? "run-exit-only" : "outcome-unknown",
+          runId: row.runId,
+          ...row.runStatus !== null ? { runStatus: row.runStatus } : {},
+          ...row.runTaskId !== null ? { taskId: row.runTaskId } : {},
+          artifacts: parseArtifactRefs2(row.runArtifactRefsJson)
         });
       }
     }
     return unresolved;
   }
   async reconcile(agentId) {
-    const db = await this.ctx.getDb();
-    const rows = await new InboxUnfinishedDao(db).listUnfinished(agentId);
-    const inbox = new InboxMessageDao(db);
-    const report = { unresolved: [], exhausted: [], scanned: rows.length };
-    for (const row of rows) {
-      if (row.status === "queued" && row.inject_attempts >= MAX_INJECT_ATTEMPTS) {
-        await inbox.markFailed(row.id, `attempts exhausted after ${MAX_INJECT_ATTEMPTS} deliveries`);
-        report.exhausted.push(row.id);
-      }
-    }
-    report.unresolved = await this.classify(agentId);
-    return report;
+    const service = await this.inbox();
+    const swept = await service.sweep();
+    const rows = await service.requests(agentId);
+    return { unresolved: await this.classify(agentId, rows), exhausted: swept.failed, scanned: rows.length };
   }
 }
 function parseArtifactRefs2(artifactRefsJson) {
+  if (artifactRefsJson === null)
+    return [];
   try {
     const parsed = JSON.parse(artifactRefsJson);
     return Array.isArray(parsed) ? parsed : [];
@@ -103614,9 +104044,8 @@ function parseArtifactRefs2(artifactRefsJson) {
     return [];
   }
 }
-var MAX_INJECT_ATTEMPTS = 3;
 var init_delivery_reconciler = __esm(() => {
-  init_src2();
+  init_inbox_service();
 });
 
 // ../../packages/app/src/services/execution-policy.ts
@@ -104683,7 +105112,11 @@ class FleetDispatcher {
     this.sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   }
   async enqueue(req) {
-    const sent = await this.deps.coordination.sendMessage(req.fromId, req.member, req.body, undefined, req.requestKey);
+    const sent = await this.deps.coordination.sendMessage(req.fromId, req.member, req.body, undefined, req.requestKey, {
+      kind: "request",
+      ...req.taskId !== undefined ? { taskId: req.taskId } : {},
+      ...req.parentRunId !== undefined ? { parentRunId: req.parentRunId } : {}
+    });
     return { messageId: sent.msgId, replayed: sent.replayed === true };
   }
   async receipt(messageId, member) {
@@ -104781,6 +105214,13 @@ class FleetGuestService {
     const joined = new Set(guests.map((g) => g.id));
     const requested = input.id?.trim();
     const id = requested !== undefined && requested !== "" ? requested : this.nextGuestId(role, declared, joined);
+    if (isReservedInboxId(id)) {
+      return {
+        ok: false,
+        code: "collision",
+        message: `guest id "${id}" is a reserved inbox identity \u2014 pass a free --id`
+      };
+    }
     const own = guests.find((g) => g.id === id);
     if (own !== undefined && own.sessionId !== null && own.sessionId === (input.sessionId ?? null)) {
       if (await this.heartbeat(id))
@@ -104854,7 +105294,10 @@ class FleetGuestService {
     return expired;
   }
   async pendingCount(id) {
-    return await new InboxMessageDao(await this.ctx.getDb()).countPending(id);
+    return await this.inbox().countQueued(id);
+  }
+  inbox() {
+    return new InboxService({ getDb: () => this.ctx.getDb() });
   }
   async retire(record) {
     const db = await this.ctx.getDb();
@@ -104862,10 +105305,9 @@ class FleetGuestService {
     if (claim !== null) {
       await new ProjectClaimDao(db).release(this.ctx.cwd, this.slot(record.id), record.id, claim.ownerEpoch);
     }
-    const unfinished = await new InboxUnfinishedDao(db).listUnfinished(record.id);
-    const claimed = unfinished.filter((row) => row.status === "injected").map((row) => row.id);
+    const claimed = (await this.inbox().list(record.id, "in", { limit: 500 })).messages.filter((row) => row.status === "claimed").map((row) => row.id);
     if (claimed.length > 0)
-      await new InboxMessageDao(db).release(claimed);
+      await this.inbox().release(claimed);
     if (record.runId !== "") {
       await new CoordinationRunDao(db).updateExit(record.runId, "exited", new Date().toISOString(), "[]", {
         messageIds: [],
@@ -104894,6 +105336,7 @@ class FleetGuestService {
 var GUEST_LEASE_TTL_MS, GUEST_ROLES, GUEST_RECORD_DIR, GUEST_CLAIM_PREFIX = "guest:";
 var init_fleet_guest_service = __esm(() => {
   init_src2();
+  init_inbox_service();
   GUEST_LEASE_TTL_MS = CLAIM_TTL_MS;
   GUEST_ROLES = ["scribe", "coder", "reviewer", "planner"];
   GUEST_RECORD_DIR = join44(".spur", "run", "guests");
@@ -108041,13 +108484,13 @@ class JobWorkerService {
 
 // ../../packages/app/src/services/occupant-wait.ts
 function projectLifecycle(input) {
-  const { latestInvokeEvent, pendingCount } = input;
+  const { latestInvokeEvent, queuedCount } = input;
   if (latestInvokeEvent === null)
     return "unknown";
   if (latestInvokeEvent.eventName === "agent.invoke.start")
     return "working";
   if (latestInvokeEvent.eventName === "agent.invoke.exit") {
-    return pendingCount === 0 ? "idle" : "unknown";
+    return queuedCount === 0 ? "idle" : "unknown";
   }
   return "unknown";
 }
@@ -108072,10 +108515,10 @@ async function snapshotOccupant(deps, specId, opts) {
   if (opts.runId !== undefined && opts.runId !== occupant.runId) {}
   const pin = { specId, runId, generation: occupant.generation };
   const latest = await deps.latestInvokeEvent(runId);
-  const pendingCount = await deps.countPending(specId);
+  const queuedCount = await deps.countQueued(specId);
   return {
     pin,
-    lifecycle: projectLifecycle({ latestInvokeEvent: latest, pendingCount }),
+    lifecycle: projectLifecycle({ latestInvokeEvent: latest, queuedCount }),
     startClock: deps.now(),
     latestInvoke: latest
   };
@@ -108126,8 +108569,8 @@ async function waitForOccupant(deps, opts) {
     if (occupant.generation > pin.generation) {
       throw new WaitError("run_replaced", `generation ${pin.generation} \u2192 ${occupant.generation}`);
     }
-    const pendingCount = await deps.countPending(pin.specId);
-    const lifecycle = projectLifecycle({ latestInvokeEvent: latestInvoke, pendingCount });
+    const queuedCount = await deps.countQueued(pin.specId);
+    const lifecycle = projectLifecycle({ latestInvokeEvent: latestInvoke, queuedCount });
     if (until === "invoke-exit") {
       if (latestInvoke !== null && latestInvoke.eventName === "agent.invoke.exit") {
         return { pin, satisfied: until };
@@ -110581,18 +111024,6 @@ import { randomUUID as randomUUID7 } from "crypto";
 function fleetTaskKeyPrefix(wbs) {
   return `${FLEET_TASK_KEY_PREFIX}${wbs}:`;
 }
-function parseFleetTaskAttempt(requestKey, wbs) {
-  const prefix = fleetTaskKeyPrefix(wbs);
-  if (!requestKey.startsWith(prefix))
-    return null;
-  const suffix = requestKey.slice(prefix.length);
-  if (!/^[1-9][0-9]*$/.test(suffix))
-    return null;
-  return Number.parseInt(suffix, 10);
-}
-function fleetTaskWbs(requestKey) {
-  return /^fleet:task:([^:]+):[1-9][0-9]*$/.exec(requestKey ?? "")?.[1];
-}
 
 class StrategyRuntime {
   ctx;
@@ -110640,6 +111071,15 @@ class StrategyRuntime {
     for (const member of (await this.ctx.fleet.resolve(normalized)).members) {
       unresolved.push(...options.readOnly ? await reconciler.classify(member.instanceId) : (await reconciler.reconcile(member.instanceId)).unresolved);
     }
+    if (!options.readOnly && this.ctx.guestExpiry !== undefined) {
+      try {
+        await this.ctx.guestExpiry();
+      } catch (error) {
+        this.ctx.logger?.warn("strategy resume: guest expiry failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
     return { strategy, version, orchestrator, unresolved, reconciled: true };
   }
   async tick(projectPath, opts) {
@@ -110662,7 +111102,7 @@ class StrategyRuntime {
       };
     }
     const db = await this.ctx.openDb(normalized);
-    const inbox = new InboxUnfinishedDao(db);
+    const inbox = new InboxService({ getDb: async () => db });
     const slots = new WriteSlotService(this.ctx);
     const dispatched = [];
     for (const decision of result.decisions) {
@@ -110685,7 +111125,8 @@ class StrategyRuntime {
           member: decision.instanceId,
           fromId: opts.orchestratorId,
           body: `/sp:dev-run ${wbs} --auto${resumeHint ? " --continue" : ""}`,
-          requestKey: `${fleetTaskKeyPrefix(wbs)}${attempt}`
+          requestKey: `${fleetTaskKeyPrefix(wbs)}${attempt}`,
+          taskId: wbs
         });
         dispatched.push(decision);
         this.startHeartbeat(normalized, decision.instanceId, opts.ownerEpoch);
@@ -110722,8 +111163,8 @@ class StrategyRuntime {
     const dispatcher = this.ctx.dispatcher;
     if (dispatcher === undefined)
       return { released: [] };
-    const rows = await new InboxUnfinishedDao(db).listUnfinished(holder.holderId);
-    const pending = rows.find((row) => (row.request_key ?? "").startsWith("fleet:task:"));
+    const rows = await new InboxService({ getDb: async () => db }).requests(holder.holderId);
+    const pending = rows.find((row) => row.taskId !== null);
     if (pending === undefined)
       return { released: [] };
     const receipt = await dispatcher.receipt(pending.id, holder.holderId);
@@ -110732,7 +111173,7 @@ class StrategyRuntime {
     this.stopHeartbeat(normalized);
     const slots = new WriteSlotService(this.ctx);
     await slots.validateResult(normalized, holder.holderId, holder.ownerEpoch, {
-      taskId: fleetTaskWbs(pending.request_key)
+      taskId: pending.taskId ?? undefined
     });
     const released = await slots.release(normalized, holder.holderId, holder.ownerEpoch);
     return { released: released ? [holder.holderId] : [] };
@@ -110806,7 +111247,7 @@ class StrategyRuntime {
         idleInstances.push(member);
       }
     }
-    const inbox = new InboxUnfinishedDao(db);
+    const inbox = new InboxService({ getDb: async () => db });
     const memberLifecycle = new Map;
     if (idleInstances.length > 0) {
       try {
@@ -110823,7 +111264,7 @@ class StrategyRuntime {
       const latest = attempts.latest;
       let state;
       if (latest !== null) {
-        const receipt = await this.ctx.dispatcher?.receipt(latest.row.id, latest.row.to_id);
+        const receipt = await this.ctx.dispatcher?.receipt(latest.row.id, latest.row.toId);
         state = {
           attempt: latest.attempt,
           ...receipt !== null && receipt !== undefined && receipt.status !== "outcome-unknown" ? { receipt: receipt.status } : {}
@@ -110854,22 +111295,18 @@ class StrategyRuntime {
     return { name, result, statusByWbs };
   }
   async readAttempts(inbox, wbs) {
-    const rows = await inbox.listByRequestKeyPrefix(fleetTaskKeyPrefix(wbs));
-    let latest = null;
-    for (const row of rows) {
-      const attempt = parseFleetTaskAttempt(row.request_key ?? "", wbs);
-      if (attempt === null)
-        continue;
-      if (latest === null || attempt > latest.attempt)
-        latest = { row, attempt };
-    }
-    return { count: rows.length, latest };
+    const attempts = await inbox.attempts(wbs);
+    return {
+      count: attempts.count,
+      latest: attempts.latest === null ? null : { row: attempts.latest, attempt: attempts.count }
+    };
   }
 }
 var DEFAULT_STRATEGY = "rest", FLEET_AUTO_TAG = "fleet:auto", MAX_DISPATCH_ATTEMPTS = 3, MAX_HOLD_DETAIL_IDS = 5, FLEET_TASK_KEY_PREFIX = "fleet:task:", restStrategy, gtdStrategy, STRATEGIES;
 var init_strategy_runtime = __esm(() => {
   init_src2();
   init_delivery_reconciler();
+  init_inbox_service();
   init_project_registry();
   init_write_slot_service();
   restStrategy = {
@@ -111246,220 +111683,6 @@ var init_supervisor_service = __esm(() => {
   RESTART_BACKOFF_SCHEDULE = [1000, 2000, 4000, 8000, 16000];
 });
 
-// ../../packages/app/src/services/system-event-retention.ts
-function resolveRetentionQuotas(config = {}, prefixes = SYSTEM_EVENT_PREFIXES) {
-  const defaultQuota = config.default ?? DEFAULT_SYSTEM_EVENT_RETENTION_QUOTA;
-  const overrides = config.prefixes ?? {};
-  return prefixes.map((prefix) => ({
-    prefix,
-    quota: overrides[prefix] ?? defaultQuota
-  }));
-}
-var DEFAULT_SYSTEM_EVENT_RETENTION_QUOTA = 1e4;
-var init_system_event_retention = __esm(() => {
-  init_event_names();
-});
-
-// ../../packages/app/src/services/system-event-tap.ts
-function registerSystemEventTap(bus, dao, logger, options = {}) {
-  const handlers = new Map;
-  const inFlight = new Set;
-  const diagnosticEnabled = options.diagnosticEnabled === true;
-  const quotas = resolveRetentionQuotas(options.retention);
-  for (const entry of SYSTEM_EVENT_CATALOG) {
-    if (entry.tier === "diagnostic" && !diagnosticEnabled)
-      continue;
-    const handler = (event) => {
-      const actor = extractSystemEventActor(event);
-      const p = persist(dao, entry.prefix, {
-        id: createId("sev"),
-        event_name: entry.name,
-        occurred_at: new Date().toISOString(),
-        actor,
-        payload_json: safeStringify(buildSystemEventEnvelope(entry, event, options.projectContext ?? systemEventProjectContext(""), options.secretValues, actor)),
-        ...extractSystemEventCorrelation(event)
-      }, quotas, logger);
-      inFlight.add(p);
-      p.finally(() => inFlight.delete(p));
-    };
-    handlers.set(entry.name, handler);
-    bus.on(entry.name, handler);
-  }
-  return {
-    unsubscribe: () => {
-      for (const [name, handler] of handlers) {
-        bus.off(name, handler);
-      }
-      handlers.clear();
-    },
-    flush: async () => {
-      while (inFlight.size > 0) {
-        await Promise.allSettled(inFlight);
-      }
-    }
-  };
-}
-async function persist(dao, prefix, input, quotas, logger) {
-  try {
-    await dao.insert(input);
-    await dao.pruneQuotas(quotas, prefix);
-  } catch (error) {
-    logger.warn("system_events tap: persist failed", {
-      name: input.event_name,
-      error: stringifyError(error)
-    });
-  }
-}
-function safeStringify(event) {
-  try {
-    return JSON.stringify(event ?? null);
-  } catch {
-    return null;
-  }
-}
-function extractSystemEventActor(event) {
-  if (event && typeof event === "object") {
-    const obj = event;
-    if (typeof obj.actor === "string" && obj.actor.length > 0)
-      return obj.actor;
-    if (typeof obj.agentId === "string" && obj.agentId.length > 0)
-      return obj.agentId;
-    if (typeof obj.memberId === "string" && obj.memberId.length > 0)
-      return obj.memberId;
-  }
-  return null;
-}
-function extractSystemEventCorrelation(event) {
-  const correlation = { run_id: null, entity_kind: null, entity_id: null, sequence: null };
-  if (!event || typeof event !== "object")
-    return correlation;
-  const obj = event;
-  const nested = obj.correlation && typeof obj.correlation === "object" ? obj.correlation : {};
-  const runId = obj.runId ?? obj.run_id ?? nested.runId;
-  if (typeof runId === "string" && runId.length > 0)
-    correlation.run_id = runId;
-  if (typeof obj.sequence === "number" && Number.isFinite(obj.sequence))
-    correlation.sequence = obj.sequence;
-  const entity = obj.entity;
-  if (entity && typeof entity === "object") {
-    const { kind, id } = entity;
-    if (typeof kind === "string" && kind.length > 0)
-      correlation.entity_kind = kind;
-    if (typeof id === "string" && id.length > 0)
-      correlation.entity_id = id;
-  }
-  if (typeof obj.entityKind === "string" && obj.entityKind.length > 0)
-    correlation.entity_kind = obj.entityKind;
-  if (typeof obj.entityId === "string" && obj.entityId.length > 0)
-    correlation.entity_id = obj.entityId;
-  return correlation;
-}
-function stringifyError(error) {
-  if (error instanceof Error)
-    return `${error.name}: ${error.message}`;
-  return String(error);
-}
-var init_system_event_tap = __esm(() => {
-  init_src2();
-  init_event_names();
-  init_system_event_envelope();
-  init_system_event_retention();
-});
-
-// ../../packages/app/src/services/system-event-catch-all.ts
-function genericSystemEventCatalogEntry(name) {
-  return {
-    name,
-    prefix: name.replace(/\..*/, ""),
-    source: "bus",
-    tier: "default",
-    persisted: true,
-    streamed: true,
-    payloadPolicy: "metadata-only",
-    renderer: GENERIC_SYSTEM_EVENT_RENDERER,
-    producerPackage: "spur",
-    subsystem: "unknown",
-    severity: "info",
-    description: "Uncataloged system event captured by the generic fallback; pending catalog promotion.",
-    metadataFields: [],
-    remediationKind: "none"
-  };
-}
-function ensureRetentionQuotaForPrefix(quotas, prefix, fallbackQuota) {
-  return quotas.some((quota) => quota.prefix === prefix) ? quotas : [...quotas, { prefix, quota: fallbackQuota }];
-}
-function createSystemEventCatchAllSink(options) {
-  const { dao, logger } = options;
-  const quotas = resolveRetentionQuotas(options.retention);
-  const fallbackQuota = options.retention?.default ?? DEFAULT_SYSTEM_EVENT_RETENTION_QUOTA;
-  const projectContext = options.projectContext ?? systemEventProjectContext("");
-  const secretValues = options.secretValues ?? [];
-  const driftWarned = new Set;
-  return async (name, payload) => {
-    const entry = genericSystemEventCatalogEntry(name);
-    const actor = extractSystemEventActor(payload);
-    try {
-      await dao.insert({
-        id: createId("sev"),
-        event_name: entry.name,
-        occurred_at: new Date().toISOString(),
-        actor,
-        payload_json: safeStringify(buildSystemEventEnvelope(entry, payload, projectContext, secretValues, actor)),
-        ...extractSystemEventCorrelation(payload)
-      });
-      await dao.pruneQuotas(ensureRetentionQuotaForPrefix(quotas, entry.prefix, fallbackQuota), entry.prefix);
-    } catch (error) {
-      logger.warn("system_events catch-all: persist failed", {
-        event: name,
-        error: error instanceof Error ? `${error.name}: ${error.message}` : String(error)
-      });
-      return;
-    }
-    if (!driftWarned.has(name)) {
-      driftWarned.add(name);
-      logger.warn(SYSTEM_EVENT_UNCATALOGED_WARN_EVENT, { event: name });
-    }
-  };
-}
-function installSystemEventCatchAll(bus, sink) {
-  const holder = bus;
-  const current = holder.emit;
-  if (current[CATCH_ALL_MARKER] === true) {
-    return { installed: false, flush: async () => {} };
-  }
-  const underlying = current.bind(bus);
-  const inFlight = new Set;
-  const wrapped = (event, ...args) => {
-    const result = underlying(event, ...args);
-    if (systemEventCatalogEntry(event) === undefined) {
-      const pending = Promise.resolve().then(() => sink(event, args[0]));
-      inFlight.add(pending);
-      pending.catch(() => {}).finally(() => {
-        inFlight.delete(pending);
-      });
-    }
-    return result;
-  };
-  Object.defineProperty(wrapped, CATCH_ALL_MARKER, { value: true });
-  holder.emit = wrapped;
-  return {
-    installed: true,
-    flush: async () => {
-      while (inFlight.size > 0) {
-        await Promise.allSettled([...inFlight]);
-      }
-    }
-  };
-}
-var GENERIC_SYSTEM_EVENT_RENDERER = "generic", SYSTEM_EVENT_UNCATALOGED_WARN_EVENT = "system_events.uncataloged", CATCH_ALL_MARKER = "spur.systemEventCatchAll";
-var init_system_event_catch_all = __esm(() => {
-  init_src2();
-  init_event_names();
-  init_system_event_envelope();
-  init_system_event_retention();
-  init_system_event_tap();
-});
-
 // ../../packages/app/src/services/system-event-emitter.ts
 class SystemEventEmitter {
   dao;
@@ -120938,11 +121161,16 @@ async function persistWorktreeRuns(input) {
   if (fromStat === undefined || !fromStat.isDirectory()) {
     throw new Error(`persist-out: source worktree does not exist or is not a directory: ${input.fromWorkdir}`);
   }
+  const fs = createNodeFileSystem2();
+  const fromReal = fs.realPath?.(fromDir) ?? fromDir;
+  const toReal = fs.realPath?.(toDir) ?? toDir;
+  if (fromReal === toReal) {
+    throw new Error(`persist-out: source and destination are the same tree (${fromDir}) \u2014 run it from the invoking tree, or the evidence is copied onto itself and lost with the worktree`);
+  }
   const fromRunDir = join67(fromDir, ".spur", "run");
   const toRunDir = join67(toDir, ".spur", "run");
   const fromRecordsDir = runStoragePaths(fromDir).recordsDir;
   const toRecordsDir = runStoragePaths(toDir).recordsDir;
-  const fs = createNodeFileSystem2();
   const fromEvidence = runStoragePaths(fromDir).evidenceDir;
   const toEvidence = runStoragePaths(toDir).evidenceDir;
   const evidenceCopies = [];
@@ -122377,6 +122605,7 @@ var init_src3 = __esm(() => {
   init_history_board_service();
   init_history_refresh_service();
   init_history_service();
+  init_inbox_service();
   init_inline_run_attribution();
   init_job_exclusion_guard();
   init_member_session2();
@@ -142511,27 +142740,26 @@ async function runAgentLifecycle(action, agentId, options, context) {
 async function settleClaimedMessages(context, claimed, outcome) {
   if (claimed.length === 0)
     return;
-  const coordination = new AgentCoordinationService(context);
+  const inbox = new InboxService({ getDb: () => context.getDb() });
   if (outcome === "accepted") {
-    await coordination.settleDelivered(claimed);
+    await inbox.settle(claimed, "accepted");
     return;
   }
-  const dao = new InboxMessageDao(await context.getDb());
   const releasable = [];
   const exhausted = [];
   for (const id of claimed) {
-    const row = await dao.getById(id);
-    if (row?.status !== "injected")
+    const row = await inbox.get(id);
+    if (row?.status !== "claimed")
       continue;
-    if (row.injectAttempts >= MAX_INJECT_ATTEMPTS)
+    if (row.attempts >= MAX_DELIVERY_ATTEMPTS)
       exhausted.push(id);
     else
       releasable.push(id);
   }
   if (releasable.length > 0)
-    await coordination.releasePending(releasable);
-  for (const id of exhausted) {
-    await coordination.settleFailed([id], `delivery not accepted: invocation never started after ${MAX_INJECT_ATTEMPTS} inject attempts`);
+    await inbox.release(releasable);
+  if (exhausted.length > 0) {
+    await inbox.settle(exhausted, "not-started", `delivery not accepted: invocation never started after ${MAX_DELIVERY_ATTEMPTS} inject attempts`);
   }
 }
 async function drainIntoPrompt(prompt, context, flags) {
@@ -142547,21 +142775,21 @@ async function drainIntoPrompt(prompt, context, flags) {
   const flagsOut = spec === undefined ? flags : { ...flags, "spec-id": spec.id, agent: drainAgentSelector(spec, context) };
   if (flags.drain !== true)
     return { prompt, flags: flagsOut, claimed: [] };
-  const inbox = await coordination.drainPending(recipient, flags.singleMessage === true ? { limit: 1 } : undefined);
-  if (inbox.count === 0)
+  const claimedRows = await new InboxService({ getDb: () => context.getDb() }).claim(recipient, flags.singleMessage === true ? 1 : 100);
+  if (claimedRows.length === 0)
     return { prompt, flags: flagsOut, claimed: [] };
-  const header = inbox.messages.map((m) => `- ${m.fromId ?? "operator"}: ${m.body}`).join(`
+  const header = claimedRows.map((m) => `- ${m.fromId || "operator"}: ${m.body}`).join(`
 `);
   const block = `Pending messages:
 ${header}`;
   const merged = prompt === undefined ? block : `${block}
 
 ${prompt}`;
-  const claimed = inbox.messages.map((m) => m.id);
-  const fleetTask = inbox.messages.map((message) => /^fleet:task:([^:]+):[1-9][0-9]*$/.exec(message.requestKey ?? "")?.[1]).find((wbs) => wbs !== undefined);
-  const parentRunId = inbox.messages.map((message) => /^([^:/][^/]*)\/[^/]+$/.exec(message.requestKey ?? "")?.[1]).find((runId) => runId !== undefined);
+  const claimed = claimedRows.map((m) => m.id);
+  const fleetTask = claimedRows.map((message) => message.taskId ?? /^fleet:task:([^:]+):[1-9][0-9]*$/.exec(message.requestKey ?? "")?.[1]).find((wbs) => wbs !== undefined);
+  const parentRunId = claimedRows.map((message) => message.parentRunId ?? /^([^:/][^/]*)\/[^/]+$/.exec(message.requestKey ?? "")?.[1]).find((runId) => runId !== undefined);
   const requestMessage = claimed.join(",");
-  const requestKeys = inbox.messages.map((message) => message.requestKey ?? null);
+  const requestKeys = claimedRows.map((message) => message.requestKey);
   return {
     prompt: merged,
     flags: {
@@ -142630,7 +142858,8 @@ async function makeFleetRuntime(context) {
       const { foldersConfig } = await resolvePlanningFolders(context.fs);
       const check = await makeCheckService(context);
       return await check.firstBlockingPrerequisite(context.fs.resolve(foldersConfig.active_folder), wbs);
-    }
+    },
+    guestExpiry: async () => await guestService(context).expire()
   });
 }
 async function runAgentLoop(context, flags, runtime = {}, deps) {
@@ -143272,7 +143501,7 @@ async function runAgentWait(context, specId, options) {
     return waitUsageError(context, options, "--until blocked has no first-class signal in this wave; use idle|working|invoke-exit");
   }
   const agentService = context.agentService();
-  const coordination = new AgentCoordinationService(context);
+  const inbox = new InboxService({ getDb: () => context.getDb() });
   const eventDao = new SystemEventDao(await context.getDb());
   const controller = new AbortController;
   const onSignal = () => controller.abort();
@@ -143292,7 +143521,7 @@ async function runAgentWait(context, specId, options) {
       try {
         result = await waitForOccupant({
           getOccupant: (id) => agentService.getOccupant({ specId: id }),
-          countPending: (id) => coordination.countPending(id),
+          countQueued: (id) => inbox.countQueued(id),
           latestInvokeEvent: (r) => readLatestInvokeEvent(eventDao, r),
           follow: (afterSequence) => followSystemEventsAfter(context.getDb, {
             afterSequence,
@@ -146882,7 +147111,7 @@ import { createRequire as createRequire3 } from "module";
 var CLI_CONFIG = {
   binaryName: "spur",
   binaryLabel: "spur",
-  binaryVersion: "0.4.17",
+  binaryVersion: "0.4.19",
   configDir: ".spur",
   configFile: ".spur/config.yaml",
   databaseFile: ".spur/spur.db"
@@ -147817,13 +148046,231 @@ function formatMaintenanceResult(r) {
 `);
 }
 
-// src/commands/message.ts
+// src/commands/message/inbox.ts
+init_src3();
+
+// src/commands/message/shared.ts
 init_src3();
-init_src2();
 var DEFAULT_FROM = "operator";
 var DEFAULT_WATCH_INTERVAL_MS = 2000;
-function registerMessageCommand(program, context) {
-  const noun = program.command("message").summary("send and inspect durable inter-agent messages");
+function inboxOf(context) {
+  return new InboxService({ getDb: () => context.getDb() });
+}
+async function resolveOrchestratorAddress(context) {
+  let fleet;
+  try {
+    fleet = new FleetService({
+      fs: context.fs,
+      spurConfig: await context.loadAgentConfig(context.cwd),
+      roles: context.agentRoles,
+      openDb: () => context.getDb()
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`message send could not load the project config: ${message}`);
+  }
+  const { state, instanceId } = await fleet.resolveOrchestrator(normalizeProjectPath(context.cwd));
+  if (state === "missing" || state === "unresolvable")
+    return null;
+  return typeof instanceId === "string" && instanceId !== "" ? instanceId : null;
+}
+function formatInboxLine(entry) {
+  const from = entry.fromId || DEFAULT_FROM;
+  const body = entry.body.length > 60 ? `${entry.body.slice(0, 57)}...` : entry.body;
+  return `${entry.id}	${entry.status}	${from}	${body}	${new Date(entry.createdAt).toISOString()}`;
+}
+function widenInboxRow(entry, hold) {
+  return {
+    ...entry,
+    injectAttempts: entry.attempts,
+    injectError: entry.error ?? null,
+    ...hold?.reason !== undefined ? { reason: hold.reason } : {},
+    ...hold?.runId !== undefined ? { runId: hold.runId } : {},
+    taskId: hold?.taskId ?? null,
+    ...hold?.runStatus !== undefined ? { runStatus: hold.runStatus } : {},
+    artifacts: hold?.artifacts ?? []
+  };
+}
+async function waitForMessageClaim(context, msgId, agentService, pin, timeoutMs, signal) {
+  const start = Date.now();
+  const deadline = timeoutMs === undefined ? Number.POSITIVE_INFINITY : start + timeoutMs;
+  const stallMs = Math.min(timeoutMs ?? DEFAULT_STALL_MS, DEFAULT_STALL_MS);
+  let lastPending = -1;
+  for (;; ) {
+    if (signal?.aborted)
+      throw new WaitError("timeout", "wait aborted");
+    const clock = Date.now();
+    if (clock >= deadline)
+      throw new WaitError("timeout", `wait timed out after ${timeoutMs}ms`);
+    const occupant = await agentService.getOccupant({ specId: pin.specId });
+    if (occupant === null)
+      throw new WaitError("occupant_gone", `occupant for specId "${pin.specId}" is gone`);
+    if (occupant.runId !== pin.runId)
+      throw new WaitError("run_replaced", `run ${pin.runId} replaced`);
+    if (occupant.generation > pin.generation)
+      throw new WaitError("run_replaced", `generation bumped`);
+    const row = await inboxOf(context).get(msgId);
+    if (row === null)
+      throw new WaitError("occupant_gone", `message ${msgId} disappeared`);
+    const pending = row.status === "queued" ? 1 : 0;
+    const progressed = lastPending >= 0 && pending !== lastPending;
+    if (pending === 0)
+      return;
+    if (lastPending >= 0 && !progressed && clock - start >= stallMs) {
+      throw new WaitError("wait_stalled", `inbox not draining within ${stallMs}ms`);
+    }
+    lastPending = pending;
+    await sendSleep(100, signal);
+  }
+}
+function sendSleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      resolve();
+    }, { once: true });
+  });
+}
+function parseInterval2(raw) {
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n <= 0)
+    return null;
+  return n;
+}
+function parseTimeout2(raw) {
+  if (raw === undefined || typeof raw === "boolean")
+    return;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n <= 0) {
+    throw new Error(`invalid --timeout "${raw}" (expected a positive integer ms)`);
+  }
+  return n;
+}
+function sendWaitFail(context, options, code, message) {
+  if (options.json) {
+    context.output.write(toEnvelopeJson({ error: { code, message } }, {
+      enveloped: options.jsonEnvelope,
+      error: { code: "INTERNAL_ERROR", message, details: { cliCode: code } }
+    }));
+  } else {
+    context.output.error(`${code}: ${message}`);
+  }
+  return 1;
+}
+async function readLatestInvokeEvent2(dao, runId) {
+  const rows = await dao.query({
+    run_id: runId,
+    names: ["agent.invoke.start", "agent.invoke.exit"],
+    limit: 1
+  });
+  const row = rows[0];
+  if (row === undefined)
+    return null;
+  return { eventName: row.event_name, sequence: row.sequence };
+}
+
+// src/commands/message/inbox.ts
+function registerMessageInboxCommand(noun, context) {
+  noun.command("inbox").description("List messages addressed to an agent.").requiredOption("--agent <id>", "Agent id").option("--unresolved", "Only messages the 0834 reconciler holds (delivery-failed | attempts-exhausted | outcome-unknown | run-exit-only)").option(...SHARED_OPTIONS.json).option(...SHARED_OPTIONS.jsonEnvelope).action(async (options) => {
+    const code = await runMessageInbox(context, options);
+    context.setExitCode(code);
+  });
+}
+async function runMessageInbox(context, options) {
+  const classify = options.json === true || options.unresolved === true;
+  let holds = new Map;
+  if (classify) {
+    const reconciler = new DeliveryReconciler(context);
+    holds = new Map((await reconciler.classify(options.agent)).map((u) => [u.messageId, u]));
+  }
+  const page = await inboxOf(context).list(options.agent, "in");
+  const messages = options.unresolved === true ? page.messages.filter((m) => holds.has(m.id)) : page.messages;
+  if (options.json) {
+    context.output.write(toEnvelopeJson({
+      messages: messages.map((m) => widenInboxRow(m, holds.get(m.id))),
+      count: messages.length
+    }, { enveloped: options.jsonEnvelope }));
+    return 0;
+  }
+  if (messages.length === 0) {
+    context.output.write(`No messages for ${options.agent}`);
+    return 0;
+  }
+  context.output.write(messages.map(formatInboxLine).join(`
+`));
+  return 0;
+}
+
+// src/commands/message/read.ts
+init_src3();
+function registerMessageReadCommand(noun, context) {
+  noun.command("read").description("Mark a message read by its recipient (the operator by default).").argument("<msg-id>", "Message id").option("--reader <id>", "Reader address", "operator").option(...SHARED_OPTIONS.json).option(...SHARED_OPTIONS.jsonEnvelope).action(async (msgId, options) => {
+    const jsonEnvelope = options.jsonEnvelope;
+    context.setExitCode(await runMessageRead(context, msgId, { ...options, jsonEnvelope }));
+  });
+}
+async function runMessageRead(context, msgId, options) {
+  try {
+    const receipt = await inboxOf(context).markRead(msgId, options.reader);
+    if (options.json) {
+      context.output.write(toEnvelopeJson(receipt, { enveloped: options.jsonEnvelope }));
+    } else {
+      context.output.write(receipt.transitioned ? `read ${msgId} by ${options.reader}` : `${msgId} was already read by ${options.reader}`);
+    }
+    return 0;
+  } catch (error) {
+    if (!(error instanceof MessageNotFoundError))
+      throw error;
+    writeJsonError(context.output, options, `message ${msgId} not found for ${options.reader}`, "VALIDATION_FAILED");
+    return 1;
+  }
+}
+
+// src/commands/message/reply.ts
+function registerMessageReplyCommand(noun, context) {
+  noun.command("reply").description("Thread a reply to a message.").argument("<msg-id>", "Message id to reply to").argument("<body>", "Reply body").option(...SHARED_OPTIONS.json).option(...SHARED_OPTIONS.jsonEnvelope).action(async (msgId, body, options) => {
+    const code = await runMessageReply(context, msgId, body, options);
+    context.setExitCode(code);
+  });
+}
+async function runMessageReply(context, msgId, body, options) {
+  const trimmed = body.trim();
+  if (trimmed === "") {
+    writeJsonError(context.output, options, "message reply requires a non-empty body", "VALIDATION_FAILED");
+    return 2;
+  }
+  const inbox = inboxOf(context);
+  const original = await inbox.get(msgId);
+  if (original === null) {
+    writeJsonError(context.output, options, `message ${msgId} not found`, "VALIDATION_FAILED");
+    return 1;
+  }
+  const reply = await inbox.reply(msgId, original.toId, trimmed);
+  if (options.json) {
+    context.output.write(toEnvelopeJson(reply, { enveloped: options.jsonEnvelope }));
+  } else {
+    context.output.write(`replied ${reply.id} \u2192 ${reply.toId}`);
+  }
+  return 0;
+}
+
+// src/commands/message/send.ts
+init_src3();
+init_src2();
+init_dist9();
+var SEND_UNTIL_STATES = new Set(["injected", "invoke-exit"]);
+function collectSendUntil(value, acc) {
+  if (!SEND_UNTIL_STATES.has(value)) {
+    throw new Error(`invalid --until "${value}" for send --wait (expected one of: ${[...SEND_UNTIL_STATES].join(", ")})`);
+  }
+  return [...acc, value];
+}
+function registerMessageSendCommand(noun, context) {
   noun.command("send").description("Enqueue a message for an agent. Use --wait to block until the recipient reaches a state.").argument("<body>", "Message body").option("--to <id>", "Recipient agent id (mutually exclusive with --role)").option("--role <name>", "Address by Layer-1 role or executor name; must resolve to exactly one materialized instance").option("--from <id>", "Sender id", DEFAULT_FROM).option("--request-key <key>", "Caller-minted idempotency key: the same key + payload replays the original receipt instead of enqueuing twice (0832)").option("--wait", "Block until the recipient occupant reaches --until (default: invoke-exit)").option(...SHARED_OPTIONS.untilMessage, collectSendUntil, []).option(...SHARED_OPTIONS.timeout, parseTimeout2).option(...SHARED_OPTIONS.json).option(...SHARED_OPTIONS.jsonEnvelope).action(async (body, options) => {
     const svc = new AgentCoordinationService(context);
     let toId = options.to;
@@ -147860,48 +148307,15 @@ function registerMessageCommand(program, context) {
       }
       toId = resolution.specId;
     }
-    const code = await runMessageSend(svc, context, body, {
+    const code = await runMessageSend(context, body, {
       ...options,
       to: toId ?? "",
       requestKey: typeof options.requestKey === "string" && options.requestKey.length > 0 ? options.requestKey.trim() : undefined
     });
     context.setExitCode(code);
   });
-  noun.command("inbox").description("List messages addressed to an agent.").requiredOption("--agent <id>", "Agent id").option("--unresolved", "Only messages the 0834 reconciler holds (delivery-failed | attempts-exhausted | outcome-unknown | run-exit-only)").option(...SHARED_OPTIONS.json).option(...SHARED_OPTIONS.jsonEnvelope).action(async (options) => {
-    const svc = new AgentCoordinationService(context);
-    const code = await runMessageInbox(svc, context, options);
-    context.setExitCode(code);
-  });
-  noun.command("reply").description("Thread a reply to a message.").argument("<msg-id>", "Message id to reply to").argument("<body>", "Reply body").option(...SHARED_OPTIONS.json).option(...SHARED_OPTIONS.jsonEnvelope).action(async (msgId, body, options) => {
-    const svc = new AgentCoordinationService(context);
-    const code = await runMessageReply(svc, context, msgId, body, options);
-    context.setExitCode(code);
-  });
-  noun.command("watch").description("Follow an agent inbox \u2014 surface new messages as they arrive (Ctrl-C to exit).").requiredOption("--agent <id>", "Agent id to watch").option("--interval <ms>", "Poll interval in milliseconds", String(DEFAULT_WATCH_INTERVAL_MS)).option(...SHARED_OPTIONS.jsonMessageStream).option(...SHARED_OPTIONS.jsonEnvelope).action(async (options) => {
-    const svc = new AgentCoordinationService(context);
-    const intervalMs = parseInterval2(options.interval);
-    if (intervalMs === null) {
-      writeJsonError(context.output, options, `invalid --interval "${options.interval}" (expected a positive integer ms)`, "VALIDATION_FAILED");
-      context.setExitCode(2);
-      return;
-    }
-    const controller = new AbortController;
-    const onSigInt = () => controller.abort();
-    process.on("SIGINT", onSigInt);
-    try {
-      await runMessageWatch(svc, context.output, {
-        agent: options.agent,
-        intervalMs,
-        json: options.json ?? false
-      }, {
-        signal: controller.signal
-      });
-    } finally {
-      process.off("SIGINT", onSigInt);
-    }
-  });
 }
-async function runMessageSend(svc, context, body, options) {
+async function runMessageSend(context, body, options) {
   const trimmed = body.trim();
   if (trimmed === "") {
     if (options.json) {
@@ -147918,22 +148332,36 @@ async function runMessageSend(svc, context, body, options) {
     }
     return 2;
   }
+  if (options.requestKey !== undefined && options.requestKey.trim() === "") {
+    writeJsonError(context.output, options, "message send requires a non-empty --request-key", "VALIDATION_FAILED");
+    return 2;
+  }
   if (options.to === "") {
-    if (options.json) {
-      context.output.write(toEnvelopeJson({ error: { code: "usage", message: "message send requires --to <id> or --role <name>" } }, {
-        enveloped: options.jsonEnvelope,
-        error: {
-          code: "INTERNAL_ERROR",
-          message: "message send requires --to <id> or --role <name>",
-          details: { cliCode: "usage" }
-        }
-      }));
-    } else {
-      context.output.error("message send requires --to <id> or --role <name>");
+    const resolved = await resolveOrchestratorAddress(context);
+    if (resolved === null) {
+      const message = "message send found no orchestrator member \u2014 pass --to <id> or --role <name>, or bind agent.fleet";
+      if (options.json) {
+        context.output.write(toEnvelopeJson({ error: { code: "usage", message } }, {
+          enveloped: options.jsonEnvelope,
+          error: { code: "INTERNAL_ERROR", message, details: { cliCode: "usage" } }
+        }));
+      } else {
+        context.output.error(message);
+      }
+      return 2;
     }
-    return 2;
+    options.to = resolved;
   }
   const from = options.from || DEFAULT_FROM;
+  for (const id of [from, options.to]) {
+    try {
+      validateAgentId(id);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      writeJsonError(context.output, options, message, "VALIDATION_FAILED");
+      return 1;
+    }
+  }
   let pinnedBeforeSend = null;
   if (options.wait === true) {
     const agentService = context.agentService();
@@ -147943,7 +148371,19 @@ async function runMessageSend(svc, context, body, options) {
     }
     pinnedBeforeSend = { specId: options.to, runId: occupant.runId, generation: occupant.generation };
   }
-  const result = await svc.sendMessage(from, options.to, trimmed, undefined, options.requestKey);
+  const sent = await inboxOf(context).send({
+    from,
+    to: options.to,
+    body: trimmed,
+    ...options.requestKey !== undefined ? { requestKey: options.requestKey } : {}
+  });
+  const result = {
+    msgId: sent.message.id,
+    toId: sent.message.toId,
+    status: sent.message.status,
+    injected: false,
+    ...options.requestKey !== undefined ? { replayed: sent.replayed, requestKey: options.requestKey } : {}
+  };
   if (options.wait !== true) {
     if (options.json) {
       context.output.write(toEnvelopeJson(result, { enveloped: options.jsonEnvelope }));
@@ -147971,7 +148411,7 @@ async function runMessageSend(svc, context, body, options) {
     for (const until of untilList) {
       if (until === "injected") {
         try {
-          await waitForPendingDrain(agentService, svc, pin, options.timeout, controller.signal);
+          await waitForMessageClaim(context, result.msgId, agentService, pin, options.timeout, controller.signal);
           satisfied = "injected";
           break;
         } catch (error) {
@@ -147986,7 +148426,7 @@ async function runMessageSend(svc, context, body, options) {
         try {
           const res = await waitForOccupant({
             getOccupant: (id) => agentService.getOccupant({ specId: id }),
-            countPending: (id) => svc.countPending(id),
+            countQueued: (id) => inboxOf(context).countQueued(id),
             latestInvokeEvent: (r) => readLatestInvokeEvent2(eventDao, r),
             follow: (afterSequence) => followSystemEventsAfter(context.getDb, {
               afterSequence,
@@ -148029,62 +148469,35 @@ async function runMessageSend(svc, context, body, options) {
     process.off("SIGTERM", onSignal);
   }
 }
-async function runMessageInbox(svc, context, options) {
-  const classify = options.json === true || options.unresolved === true;
-  let holds = new Map;
-  if (classify) {
-    const reconciler = new DeliveryReconciler(context);
-    const report = await reconciler.reconcile(options.agent);
-    holds = new Map(report.unresolved.map((u) => [u.messageId, u]));
+
+// src/commands/message/show.ts
+function registerMessageShowCommand(noun, context) {
+  noun.command("show").description("Print one message thread: the root and every reply, oldest first, both directions.").argument("<msg-id>", "Message id (or any id in its thread)").option(...SHARED_OPTIONS.json).option(...SHARED_OPTIONS.jsonEnvelope).action(async (msgId, options) => {
+    context.setExitCode(await runMessageShow(context, msgId, { json: options.json, jsonEnvelope: options.jsonEnvelope }));
+  });
+}
+async function runMessageShow(context, msgId, options) {
+  const rows = await inboxOf(context).thread(msgId);
+  if (rows.length === 0) {
+    writeJsonError(context.output, options, `message ${msgId} not found`, "VALIDATION_FAILED");
+    return 1;
   }
-  const inbox = await svc.getInbox(options.agent);
-  const messages = options.unresolved === true ? inbox.messages.filter((m) => holds.has(m.id)) : inbox.messages;
   if (options.json) {
-    context.output.write(toEnvelopeJson({
-      messages: messages.map((m) => widenInboxRow(m, holds.get(m.id))),
-      count: messages.length
-    }, { enveloped: options.jsonEnvelope }));
+    context.output.write(toEnvelopeJson({ messages: rows, count: rows.length }, { enveloped: options.jsonEnvelope }));
     return 0;
   }
-  if (messages.length === 0) {
-    context.output.write(`No messages for ${options.agent}`);
-    return 0;
-  }
-  context.output.write(messages.map(formatInboxLine).join(`
+  context.output.write(rows.map((row) => {
+    const from = row.fromId || DEFAULT_FROM;
+    const read = row.readAt === null ? "" : " (read)";
+    return `${new Date(row.createdAt).toISOString()}	${from} \u2192 ${row.toId}	${row.status}${read}
+${row.body}`;
+  }).join(`
+
 `));
   return 0;
 }
-function widenInboxRow(entry, hold) {
-  return {
-    ...entry,
-    injectAttempts: entry.injectAttempts,
-    injectError: entry.injectError,
-    reason: hold?.reason,
-    runId: hold?.runId,
-    taskId: hold?.taskId,
-    runStatus: hold?.runStatus,
-    artifacts: hold?.artifacts ?? []
-  };
-}
-async function runMessageReply(svc, context, msgId, body, options) {
-  const trimmed = body.trim();
-  if (trimmed === "") {
-    writeJsonError(context.output, options, "message reply requires a non-empty body", "VALIDATION_FAILED");
-    return 2;
-  }
-  const result = await svc.replyToMessage(msgId, trimmed);
-  if (options.json) {
-    context.output.write(toEnvelopeJson(result, { enveloped: options.jsonEnvelope }));
-  } else {
-    context.output.write(`replied ${result.msgId} \u2192 ${result.toId}`);
-  }
-  return 0;
-}
-function formatInboxLine(entry) {
-  const from = entry.fromId ?? DEFAULT_FROM;
-  const body = entry.body.length > 60 ? `${entry.body.slice(0, 57)}...` : entry.body;
-  return `${entry.id}	${entry.status}	${from}	${body}	${entry.createdAt}`;
-}
+
+// src/commands/message/watch.ts
 async function runMessageWatch(svc, output, options, runtime = {}) {
   const sleep = runtime.sleep ?? ((ms) => defaultSleep(ms, runtime.signal));
   const seen = new Set;
@@ -148094,9 +148507,9 @@ async function runMessageWatch(svc, output, options, runtime = {}) {
       return;
     if (runtime.maxIterations !== undefined && iteration >= runtime.maxIterations)
       return;
-    const inbox = await svc.getInbox(options.agent);
-    for (let i = inbox.messages.length - 1;i >= 0; i--) {
-      const msg = inbox.messages[i];
+    const page = await svc.list(options.agent, "in");
+    for (let i = page.messages.length - 1;i >= 0; i--) {
+      const msg = page.messages[i];
       if (!msg || seen.has(msg.id))
         continue;
       seen.add(msg.id);
@@ -148123,91 +148536,40 @@ function defaultSleep(ms, signal) {
     }, { once: true });
   });
 }
-function parseInterval2(raw) {
-  const n = Number.parseInt(raw, 10);
-  if (!Number.isFinite(n) || n <= 0)
-    return null;
-  return n;
-}
-var SEND_UNTIL_STATES = new Set(["injected", "invoke-exit"]);
-function collectSendUntil(value, acc) {
-  if (!SEND_UNTIL_STATES.has(value)) {
-    throw new Error(`invalid --until "${value}" for send --wait (expected one of: ${[...SEND_UNTIL_STATES].join(", ")})`);
-  }
-  return [...acc, value];
-}
-function parseTimeout2(raw) {
-  if (raw === undefined || typeof raw === "boolean")
-    return;
-  const n = Number.parseInt(raw, 10);
-  if (!Number.isFinite(n) || n <= 0) {
-    throw new Error(`invalid --timeout "${raw}" (expected a positive integer ms)`);
-  }
-  return n;
-}
-function sendSleep(ms, signal) {
-  return new Promise((resolve) => {
-    if (signal?.aborted) {
-      resolve();
+function registerMessageWatchCommand(noun, context) {
+  noun.command("watch").description("Follow an agent inbox \u2014 surface new messages as they arrive (Ctrl-C to exit).").requiredOption("--agent <id>", "Agent id to watch").option("--interval <ms>", "Poll interval in milliseconds", String(DEFAULT_WATCH_INTERVAL_MS)).option(...SHARED_OPTIONS.jsonMessageStream).option(...SHARED_OPTIONS.jsonEnvelope).action(async (options) => {
+    const intervalMs = parseInterval2(options.interval);
+    if (intervalMs === null) {
+      writeJsonError(context.output, options, `invalid --interval "${options.interval}" (expected a positive integer ms)`, "VALIDATION_FAILED");
+      context.setExitCode(2);
       return;
     }
-    const timer = setTimeout(resolve, ms);
-    signal?.addEventListener("abort", () => {
-      clearTimeout(timer);
-      resolve();
-    }, { once: true });
-  });
-}
-function sendWaitFail(context, options, code, message) {
-  if (options.json) {
-    context.output.write(toEnvelopeJson({ error: { code, message } }, {
-      enveloped: options.jsonEnvelope,
-      error: { code: "INTERNAL_ERROR", message, details: { cliCode: code } }
-    }));
-  } else {
-    context.output.error(`${code}: ${message}`);
-  }
-  return 1;
-}
-async function readLatestInvokeEvent2(dao, runId) {
-  const rows = await dao.query({
-    run_id: runId,
-    names: ["agent.invoke.start", "agent.invoke.exit"],
-    limit: 1
+    const controller = new AbortController;
+    const onSigInt = () => controller.abort();
+    process.on("SIGINT", onSigInt);
+    try {
+      await runMessageWatch(inboxOf(context), context.output, {
+        agent: options.agent,
+        intervalMs,
+        json: options.json ?? false
+      }, {
+        signal: controller.signal
+      });
+    } finally {
+      process.off("SIGINT", onSigInt);
+    }
   });
-  const row = rows[0];
-  if (row === undefined)
-    return null;
-  return { eventName: row.event_name, sequence: row.sequence };
 }
-async function waitForPendingDrain(agentService, coordination, pin, timeoutMs, signal) {
-  const start = Date.now();
-  const deadline = timeoutMs === undefined ? Number.POSITIVE_INFINITY : start + timeoutMs;
-  const stallMs = Math.min(timeoutMs ?? DEFAULT_STALL_MS, DEFAULT_STALL_MS);
-  let lastPending = -1;
-  for (;; ) {
-    if (signal?.aborted)
-      throw new WaitError("timeout", "wait aborted");
-    const clock = Date.now();
-    if (clock >= deadline)
-      throw new WaitError("timeout", `wait timed out after ${timeoutMs}ms`);
-    const occupant = await agentService.getOccupant({ specId: pin.specId });
-    if (occupant === null)
-      throw new WaitError("occupant_gone", `occupant for specId "${pin.specId}" is gone`);
-    if (occupant.runId !== pin.runId)
-      throw new WaitError("run_replaced", `run ${pin.runId} replaced`);
-    if (occupant.generation > pin.generation)
-      throw new WaitError("run_replaced", `generation bumped`);
-    const pending = await coordination.countPending(pin.specId);
-    const progressed = lastPending >= 0 && pending !== lastPending;
-    if (pending === 0)
-      return;
-    if (lastPending >= 0 && !progressed && clock - start >= stallMs) {
-      throw new WaitError("wait_stalled", `inbox not draining within ${stallMs}ms`);
-    }
-    lastPending = pending;
-    await sendSleep(100, signal);
-  }
+
+// src/commands/message/index.ts
+function registerMessageCommand(program, context) {
+  const noun = program.command("message").summary("send and inspect durable inter-agent messages");
+  registerMessageSendCommand(noun, context);
+  registerMessageInboxCommand(noun, context);
+  registerMessageShowCommand(noun, context);
+  registerMessageReadCommand(noun, context);
+  registerMessageReplyCommand(noun, context);
+  registerMessageWatchCommand(noun, context);
 }
 
 // src/commands/migrate.ts
@@ -154915,6 +155277,134 @@ var historyContract = {
   }).input(historyTriggerImportInputSchema).output(historyTriggerImportResponseSchema)
 };
 
+// ../../packages/contracts/src/inbox.ts
+init_zod();
+var INBOX_MESSAGE_KINDS = ["chat", "request"];
+var INBOX_MESSAGE_STATUSES = ["queued", "claimed", "delivered", "failed"];
+var inboxMessageSchema = object2({
+  id: string2(),
+  fromId: string2(),
+  toId: string2(),
+  body: string2(),
+  kind: _enum2(INBOX_MESSAGE_KINDS),
+  status: _enum2(INBOX_MESSAGE_STATUSES),
+  attempts: number2().int().nonnegative(),
+  error: string2().nullable(),
+  claimedAt: number2().int().nullable(),
+  deliveredAt: number2().int().nullable(),
+  readAt: number2().int().nullable(),
+  inReplyTo: string2().nullable(),
+  threadId: string2(),
+  requestKey: string2().nullable(),
+  taskId: string2().nullable(),
+  parentRunId: string2().nullable(),
+  createdAt: number2().int()
+});
+var inboxMemberSchema = object2({
+  id: string2(),
+  queued: number2().int().nonnegative(),
+  unread: number2().int().nonnegative()
+});
+var inboxRequestSchema = object2({
+  messageId: string2(),
+  requestKey: string2().nullable(),
+  status: _enum2(INBOX_MESSAGE_STATUSES),
+  attempts: number2().int().nonnegative(),
+  error: string2().nullable(),
+  runId: string2().nullable(),
+  taskId: string2().nullable(),
+  outcome: string2().nullable(),
+  reason: string2().nullable(),
+  hold: string2().nullable()
+});
+var inboxListInputSchema = object2({
+  member: string2().min(1),
+  direction: _enum2(["in", "out", "both"]).optional(),
+  limit: number2().int().positive().max(500).optional(),
+  cursor: string2().optional()
+});
+var inboxListResponseSchema = object2({
+  messages: array(inboxMessageSchema),
+  nextCursor: string2().nullable()
+});
+var inboxThreadInputSchema = object2({
+  id: string2().min(1)
+});
+var inboxSendInputSchema = object2({
+  to: string2().min(1).optional(),
+  from: string2().min(1).optional(),
+  body: string2().min(1),
+  kind: _enum2(INBOX_MESSAGE_KINDS).optional(),
+  requestKey: string2().min(1).optional(),
+  taskId: string2().min(1).optional(),
+  parentRunId: string2().min(1).optional(),
+  projectPath: string2().optional()
+});
+var inboxSendResponseSchema = object2({
+  message: inboxMessageSchema,
+  replayed: boolean2()
+});
+var inboxReplyInputSchema = object2({
+  id: string2().min(1),
+  from: string2().min(1),
+  body: string2().min(1)
+});
+var inboxReadInputSchema = object2({
+  id: string2().min(1),
+  reader: string2().min(1)
+});
+var inboxReadResponseSchema = object2({
+  readAt: number2().int(),
+  transitioned: boolean2()
+});
+var inboxRequestsInputSchema = object2({
+  limit: number2().int().positive().max(200).optional()
+});
+var inboxContract = {
+  list: oc.route({
+    method: "GET",
+    path: "/inbox/messages",
+    summary: "List one inbox address messages",
+    tags: ["inbox"]
+  }).input(inboxListInputSchema).output(inboxListResponseSchema),
+  thread: oc.route({
+    method: "GET",
+    path: "/inbox/messages/{id}/thread",
+    summary: "Read one message thread (root plus replies, oldest first)",
+    tags: ["inbox"]
+  }).input(inboxThreadInputSchema).output(array(inboxMessageSchema)),
+  send: oc.route({
+    method: "POST",
+    path: "/inbox/messages",
+    summary: "Send a message to a member inbox",
+    tags: ["inbox"]
+  }).input(inboxSendInputSchema).output(inboxSendResponseSchema),
+  reply: oc.route({
+    method: "POST",
+    path: "/inbox/messages/{id}/reply",
+    summary: "Reply in a thread, addressed to the original sender",
+    tags: ["inbox"]
+  }).input(inboxReplyInputSchema).output(inboxMessageSchema),
+  read: oc.route({
+    method: "POST",
+    path: "/inbox/messages/{id}/read",
+    summary: "Mark a message read by its recipient",
+    tags: ["inbox"]
+  }).input(inboxReadInputSchema).output(inboxReadResponseSchema),
+  requests: oc.route({
+    method: "GET",
+    path: "/inbox/requests",
+    summary: "List request results with delivery classification",
+    tags: ["inbox"]
+  }).input(inboxRequestsInputSchema).output(array(inboxRequestSchema)),
+  members: oc.route({
+    method: "GET",
+    path: "/inbox/members",
+    summary: "List inbox addresses with queued and unread counts",
+    tags: ["inbox"]
+  }).input(object2({})).output(array(inboxMemberSchema))
+};
+
 // ../../packages/contracts/src/planning-event.ts
 init_zod();
 var planningEventEnvelopeSchema = apiSuccessSchema(object2({
@@ -155351,6 +155841,7 @@ var contract = {
   board: { ...boardContract },
   feature: { ...featureContract },
   history: { ...historyContract },
+  inbox: { ...inboxContract },
   fleet: { ...fleetContract },
   processes: { ...processesContract },
   runs: { ...runsContract },
@@ -156344,6 +156835,9 @@ var databaseModule = {
   }
 };
 
+// ../server/src/modules/events/index.ts
+init_src3();
+
 // ../server/src/modules/sse/stream-helpers.ts
 function sendSseKeepalive(closed, controller, encoder) {
   if (closed.current)
@@ -156436,6 +156930,34 @@ function extractSystemEventActor2(event) {
 function sendKeepalive(closed, controller, encoder) {
   sendSseKeepalive(closed, controller, encoder);
 }
+var relayedContexts = new WeakSet;
+var relayedRowColumns = new WeakMap;
+function startMessageRelay(ctx) {
+  if (relayedContexts.has(ctx))
+    return;
+  relayedContexts.add(ctx);
+  const controller = new AbortController;
+  (async () => {
+    try {
+      const bus = ctx.eventBus();
+      const start = await (await ctx.systemEventDao()).latestSequence();
+      const stream = followSystemEventsAfter(() => ctx.getDb(), {
+        afterSequence: start,
+        match: (row) => row.event_name.startsWith("message."),
+        signal: controller.signal
+      });
+      for await (const row of stream) {
+        try {
+          const payload = JSON.parse(row.payload_json ?? "{}");
+          if (payload !== null && typeof payload === "object") {
+            relayedRowColumns.set(payload, { actor: row.actor, occurredAt: row.occurred_at });
+          }
+          bus.emit(row.event_name, payload);
+        } catch {}
+      }
+    } catch {}
+  })();
+}
 var eventsModule = {
   name: "events",
   mount(app, ctx) {
@@ -156447,6 +156969,7 @@ var eventsModule = {
     const diagnosticEnabled = typeof ctx.bootConfig === "function" && ctx.bootConfig().events.diagnostic === true;
     const diagnosticNames = diagnosticEnabled ? SYSTEM_EVENT_CATALOG.filter((entry) => entry.tier === "diagnostic" && entry.streamed).map((entry) => entry.name) : [];
     const streamNames = [...baseNames, ...diagnosticNames];
+    startMessageRelay(ctx);
     app.get("/api/events/planning", (c) => {
       const bus = ctx.eventBus();
       const closed = { current: false };
@@ -156485,14 +157008,15 @@ var eventsModule = {
               if (closed.current)
                 return;
               const entry = systemEventCatalogEntry(name);
-              const actor = extractSystemEventActor2(event);
+              const ledger = event !== null && typeof event === "object" ? relayedRowColumns.get(event) : undefined;
+              const actor = ledger !== undefined ? ledger.actor : extractSystemEventActor2(event);
               const envelope = {
                 eventName: name,
-                occurredAt: new Date().toISOString(),
+                occurredAt: ledger?.occurredAt ?? new Date().toISOString(),
                 actor,
                 prefix: entry?.prefix ?? name.split(".")[0],
                 renderer: entry?.renderer ?? "generic",
-                payload: buildSystemEventEnvelope(entry, event, projectContext, secretValues, actor)
+                payload: event !== null && typeof event === "object" && "schemaVersion" in event ? projectStoredSystemEventEnvelope(entry, event, projectContext, secretValues, actor) : buildSystemEventEnvelope(entry, event, projectContext, secretValues, actor)
               };
               try {
                 controller.enqueue(encoder.encode(`data: ${JSON.stringify(envelope)}
@@ -156730,11 +157254,10 @@ init_dist5();
 import { homedir as homedir17 } from "os";
 import { basename as basename20, join as join94, relative as relative19, resolve as resolve37 } from "path";
 // ../server/package.json
-var version3 = "0.4.17";
+var version3 = "0.4.19";
 
 // ../server/src/modules/health/index.ts
 var startedAt = Date.now();
-var OPERATOR_AGENT_ID = "board-operator";
 var healthModule = {
   name: "health",
   mount(app, ctx) {
@@ -157003,77 +157526,6 @@ var healthModule = {
         executors
       });
     });
-    app.get("/api/project/requests", async (c) => {
-      if (!ctx) {
-        return c.json({ requests: [] });
-      }
-      const limitRaw = c.req.query("limit");
-      const parsedLimit = limitRaw === undefined ? NaN : Number.parseInt(limitRaw, 10);
-      const limit = Number.isNaN(parsedLimit) || parsedLimit < 0 ? 50 : Math.min(parsedLimit, 200);
-      const path = normalizeProjectPath(ctx.cwd);
-      const openDb = () => ctx.getDb();
-      const fleet = new FleetService({
-        fs: ctx.fs,
-        reloadAgentConfig: () => ctx.reloadAgentConfig(),
-        openDb
-      });
-      const runtime = new StrategyRuntime({
-        openDb,
-        tasks: ctx.taskService(),
-        fleet,
-        dependencyBlocked: async () => null
-      });
-      let orchestrator = { state: "unresolvable", reason: "unavailable" };
-      try {
-        const { state, instanceId, holderId, reason } = await fleet.resolveOrchestrator(path);
-        orchestrator = { state, instanceId, holderId, reason };
-      } catch {
-        orchestrator = { state: "unresolvable", reason: "unavailable" };
-      }
-      const instanceId = orchestrator.state === "missing" || orchestrator.state === "unresolvable" ? undefined : orchestrator.instanceId;
-      if (instanceId === undefined) {
-        return c.json({ requests: [] });
-      }
-      const db = await openDb();
-      const unresolved = await new DeliveryReconciler({ getDb: openDb }).classify(instanceId);
-      try {
-        await new FleetGuestService({
-          cwd: ctx.cwd,
-          fs: ctx.fs ?? createNodeFileSystem2(ctx.cwd),
-          getDb: openDb
-        }).expire();
-      } catch {}
-      const reasonByMessage = new Map(unresolved.map((u) => [u.messageId, u.reason]));
-      const runs = new CoordinationRunDao(db);
-      const holdByTask = new Map;
-      try {
-        for (const h of (await runtime.selectNext(path, { readOnly: true })).holds) {
-          holdByTask.set(h.wbs, h.reason);
-        }
-      } catch {}
-      const REQUESTED_RUN_OUTCOMES = ["run-exit-only", "errored", "verified"];
-      const requests = [];
-      for (const row of await new InboxMessageDao(db).inbox(instanceId, 200)) {
-        if (row.fromId !== OPERATOR_AGENT_ID)
-          continue;
-        if (requests.length >= limit)
-          break;
-        const runRow = (await runs.listByMessageId(row.id))[0];
-        requests.push({
-          messageId: row.id,
-          requestKey: row.requestKey,
-          deliveryStatus: row.status,
-          injectAttempts: row.injectAttempts,
-          injectError: row.injectError,
-          runId: runRow?.run_id ?? null,
-          taskId: runRow?.task_id ?? null,
-          outcome: runRow !== undefined && REQUESTED_RUN_OUTCOMES.includes(runRow.outcome) ? runRow.outcome : null,
-          reason: reasonByMessage.get(row.id) ?? null,
-          hold: runRow?.task_id !== null && runRow?.task_id !== undefined ? holdByTask.get(runRow.task_id) ?? null : null
-        });
-      }
-      return c.json({ requests });
-    });
     app.get("/api/projects", async (c) => {
       if (!ctx) {
         return c.json({ projects: [] });
@@ -157735,130 +158187,6 @@ var jobsModule = {
   }
 };
 
-// ../server/src/modules/messages/index.ts
-init_src3();
-var messagesModule = {
-  name: "messages",
-  mount(app, ctx) {
-    if (!ctx)
-      return;
-    app.get("/api/messages/inbox", async (c) => {
-      const agent = c.req.query("agent");
-      if (!agent) {
-        return c.json({ error: "missing required query parameter: agent" }, 400);
-      }
-      const limit = parseLimit(c.req.query("limit"), 50);
-      const offset = parseOffset(c.req.query("offset"));
-      const svc = ctx.coordination();
-      const result = await svc.getInbox(agent, limit, offset);
-      return c.json(result);
-    });
-    app.get("/api/messages", async (c) => {
-      const limit = parseLimit(c.req.query("limit"), 50);
-      const svc = ctx.coordination();
-      const result = await svc.listRecent(limit);
-      return c.json(result);
-    });
-    app.post("/api/messages", async (c) => {
-      const parsed = await parseJsonBody(c);
-      if ("error" in parsed)
-        return c.json({ error: parsed.error }, 400);
-      const { to, body, from, requestKey, projectPath } = parsed;
-      if (typeof to !== "string" || to.length === 0)
-        return c.json({ error: 'field "to" is required' }, 400);
-      if (typeof body !== "string" || body.length === 0)
-        return c.json({ error: 'field "body" is required' }, 400);
-      if (from !== undefined && (typeof from !== "string" || from.length === 0)) {
-        return c.json({ error: 'field "from" must be a non-empty string when present' }, 400);
-      }
-      if (requestKey !== undefined && (typeof requestKey !== "string" || requestKey.length === 0)) {
-        return c.json({ error: 'field "requestKey" must be a non-empty string when present' }, 400);
-      }
-      if (projectPath !== undefined && (typeof projectPath !== "string" || projectPath.length === 0)) {
-        return c.json({ error: 'field "projectPath" must be a non-empty string when present' }, 400);
-      }
-      if (typeof projectPath === "string" && projectPath.length > 0) {
-        const served = normalizeProjectPath(ctx.cwd);
-        const claimed = normalizeProjectPath(projectPath);
-        if (claimed !== served) {
-          return c.json({ error: `project mismatch: request targets ${claimed}, server serves ${served}` }, 409);
-        }
-      }
-      const svc = ctx.coordination();
-      try {
-        const result = await svc.sendMessage(from ?? null, to, body, undefined, requestKey);
-        return c.json(result, 201);
-      } catch (err) {
-        return c.json({ error: errMsg(err) }, 400);
-      }
-    });
-    app.post("/api/messages/:id/reply", async (c) => {
-      const id = c.req.param("id");
-      const parsed = await parseJsonBody(c);
-      if ("error" in parsed)
-        return c.json({ error: parsed.error }, 400);
-      const { body } = parsed;
-      if (typeof body !== "string" || body.length === 0)
-        return c.json({ error: 'field "body" is required' }, 400);
-      const svc = ctx.coordination();
-      try {
-        const result = await svc.replyToMessage(id, body);
-        return c.json(result, 201);
-      } catch (err) {
-        return c.json({ error: errMsg(err) }, 400);
-      }
-    });
-    app.post("/api/messages/:id/read", async (c) => {
-      const id = c.req.param("id");
-      const parsed = await parseJsonBody(c);
-      if ("error" in parsed)
-        return c.json({ error: parsed.error }, 400);
-      const { reader } = parsed;
-      if (typeof reader !== "string" || reader.length === 0)
-        return c.json({ error: 'field "reader" is required' }, 400);
-      try {
-        return c.json(await ctx.coordination().markMessageRead(id, reader));
-      } catch (err) {
-        return c.json({ error: errMsg(err) }, err instanceof MessageNotFoundError ? 404 : 400);
-      }
-    });
-  }
-};
-async function parseJsonBody(c) {
-  let json;
-  try {
-    json = await c.req.json();
-  } catch {
-    return { error: "request body must be valid JSON" };
-  }
-  if (typeof json !== "object" || json === null || Array.isArray(json)) {
-    return { error: "request body must be a JSON object" };
-  }
-  return json;
-}
-function errMsg(err) {
-  if (err instanceof Error)
-    return err.message;
-  return String(err);
-}
-function parseLimit(raw, fallback) {
-  if (raw === undefined)
-    return fallback;
-  const parsed = Number.parseInt(raw, 10);
-  if (Number.isNaN(parsed) || parsed < 0)
-    return fallback;
-  return Math.min(parsed, 500);
-}
-function parseOffset(raw) {
-  if (raw === undefined)
-    return;
-  const trimmed = raw.trim();
-  if (!/^[0-9]+$/.test(trimmed))
-    return 0;
-  const parsed = Number(trimmed);
-  return Number.isSafeInteger(parsed) ? parsed : 0;
-}
-
 // ../server/src/modules/observability/index.ts
 init_src3();
 init_src2();
@@ -158563,7 +158891,6 @@ var builtins = [
   taskModule,
   featureModule,
   eventsModule,
-  messagesModule,
   jobsModule,
   processesModule,
   observabilityModule,
@@ -159889,8 +160216,207 @@ async function generateOpenApiSpec(pluginPaths = {}) {
   return spec;
 }
 
-// ../server/src/router.ts
+// ../server/src/modules/inbox/handlers.ts
+init_src3();
 var os5 = implement(contract);
+function toMessageDto(row) {
+  return {
+    id: row.id,
+    fromId: row.fromId,
+    toId: row.toId,
+    body: row.body,
+    kind: row.kind,
+    status: row.status,
+    attempts: row.attempts,
+    error: row.error,
+    claimedAt: row.claimedAt,
+    deliveredAt: row.deliveredAt,
+    readAt: row.readAt,
+    inReplyTo: row.inReplyTo,
+    threadId: row.threadId,
+    requestKey: row.requestKey,
+    taskId: row.taskId,
+    parentRunId: row.parentRunId,
+    createdAt: row.createdAt
+  };
+}
+function toOrpcError(error, fallback) {
+  if (error instanceof MessageNotFoundError)
+    return new ORPCError("NOT_FOUND", { message: error.message });
+  if (error instanceof RequestKeyConflictError2)
+    return new ORPCError("CONFLICT", { message: error.message });
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.startsWith("inbox message requires") || message.includes("must be a non-empty")) {
+    return new ORPCError("BAD_REQUEST", { message });
+  }
+  if (message.includes("malformed list cursor")) {
+    return new ORPCError("BAD_REQUEST", { message: "the list cursor is malformed" });
+  }
+  if (message.includes("already names a different message"))
+    return new ORPCError("CONFLICT", { message });
+  return new ORPCError("INTERNAL_SERVER_ERROR", { message: "the inbox request failed" });
+}
+function assertServedProject(ctx, projectPath) {
+  if (projectPath === undefined || projectPath === "")
+    return;
+  const served = normalizeProjectPath(ctx.cwd);
+  const claimed = normalizeProjectPath(projectPath);
+  if (claimed !== served) {
+    throw new ORPCError("CONFLICT", {
+      message: `project mismatch: request targets ${claimed}, server serves ${served}`
+    });
+  }
+}
+function fleetOver(ctx) {
+  const injected = ctx.fleetService;
+  if (typeof injected === "function")
+    return injected.call(ctx);
+  return new FleetService({
+    fs: ctx.fs,
+    reloadAgentConfig: () => ctx.reloadAgentConfig(),
+    openDb: () => ctx.getDb()
+  });
+}
+async function addressableRecipients(ctx) {
+  const addresses = new Set([OPERATOR_INBOX_ID, SPUR_INBOX_ID]);
+  try {
+    for (const spec of await ctx.coordination().listAgentSpecs())
+      addresses.add(spec.id);
+  } catch {}
+  try {
+    for (const member of await new FleetGuestService({
+      cwd: ctx.cwd,
+      fs: ctx.fs,
+      getDb: () => ctx.getDb()
+    }).list()) {
+      addresses.add(member.id);
+    }
+  } catch {}
+  try {
+    for (const member of await ctx.inbox().members())
+      addresses.add(member.id);
+  } catch {}
+  return addresses;
+}
+async function orchestratorAddress(ctx) {
+  try {
+    const { state, instanceId } = await fleetOver(ctx).resolveOrchestrator(normalizeProjectPath(ctx.cwd));
+    if (state === "missing" || state === "unresolvable")
+      return "";
+    return typeof instanceId === "string" ? instanceId : "";
+  } catch {
+    return "";
+  }
+}
+function createInboxHandlers(ctx) {
+  return {
+    list: os5.inbox.list.handler(async ({ input }) => {
+      try {
+        const page = await ctx.inbox().list(input.member, input.direction ?? "in", {
+          ...input.limit !== undefined ? { limit: input.limit } : {},
+          ...input.cursor !== undefined ? { cursor: input.cursor } : {}
+        });
+        return { messages: page.messages.map(toMessageDto), nextCursor: page.nextCursor };
+      } catch (error) {
+        throw toOrpcError(error, "BAD_REQUEST");
+      }
+    }),
+    thread: os5.inbox.thread.handler(async ({ input }) => {
+      const rows = await ctx.inbox().thread(input.id);
+      if (rows.length === 0)
+        throw new ORPCError("NOT_FOUND", { message: `no message ${input.id}` });
+      return rows.map(toMessageDto);
+    }),
+    send: os5.inbox.send.handler(async ({ input }) => {
+      assertServedProject(ctx, input.projectPath);
+      let to = input.to;
+      if (to === undefined) {
+        to = await orchestratorAddress(ctx);
+        if (to === "") {
+          throw new ORPCError("BAD_REQUEST", {
+            message: "no orchestrator member is bound for this project \u2014 pass `to` explicitly"
+          });
+        }
+      }
+      if (!(await addressableRecipients(ctx)).has(to)) {
+        throw new ORPCError("BAD_REQUEST", {
+          message: `unknown recipient "${to}" \u2014 no agent spec, fleet member, guest or inbox owns that address`
+        });
+      }
+      try {
+        const result = await ctx.inbox().send({
+          from: input.from ?? OPERATOR_INBOX_ID,
+          to,
+          body: input.body,
+          ...input.kind !== undefined ? { kind: input.kind } : {},
+          ...input.requestKey !== undefined ? { requestKey: input.requestKey } : {},
+          ...input.taskId !== undefined ? { taskId: input.taskId } : {},
+          ...input.parentRunId !== undefined ? { parentRunId: input.parentRunId } : {}
+        });
+        return { message: toMessageDto(result.message), replayed: result.replayed };
+      } catch (error) {
+        if (error instanceof ORPCError)
+          throw error;
+        throw toOrpcError(error, "BAD_REQUEST");
+      }
+    }),
+    reply: os5.inbox.reply.handler(async ({ input }) => {
+      try {
+        return toMessageDto(await ctx.inbox().reply(input.id, input.from, input.body));
+      } catch (error) {
+        throw toOrpcError(error, "NOT_FOUND");
+      }
+    }),
+    read: os5.inbox.read.handler(async ({ input }) => {
+      try {
+        const receipt = await ctx.inbox().markRead(input.id, input.reader);
+        return { readAt: receipt.readAt, transitioned: receipt.transitioned };
+      } catch (error) {
+        if (!(error instanceof MessageNotFoundError))
+          throw toOrpcError(error, "NOT_FOUND");
+        throw new ORPCError("NOT_FOUND", { message: "message not found for this reader" });
+      }
+    }),
+    requests: os5.inbox.requests.handler(async ({ input }) => {
+      const orchestratorId = await orchestratorAddress(ctx);
+      if (orchestratorId === "")
+        return [];
+      const limit = input.limit ?? 50;
+      const rows = await ctx.inbox().requests(orchestratorId);
+      const reconciler = new DeliveryReconciler({ getDb: () => ctx.getDb() });
+      const classified = await reconciler.classify(orchestratorId);
+      const reasonByMessage = new Map(classified.map((item) => [item.messageId, item.reason]));
+      const holdByTask = new Map;
+      try {
+        const runtime = new StrategyRuntime({
+          openDb: () => ctx.getDb(),
+          tasks: ctx.taskService(),
+          fleet: fleetOver(ctx),
+          dependencyBlocked: async () => null
+        });
+        const selected = await runtime.selectNext(normalizeProjectPath(ctx.cwd), { readOnly: true });
+        for (const hold of selected.holds)
+          holdByTask.set(hold.wbs, hold.reason);
+      } catch {}
+      return rows.slice(0, limit).map((row) => ({
+        messageId: row.id,
+        requestKey: row.requestKey,
+        status: row.status,
+        attempts: row.attempts,
+        error: row.error,
+        runId: row.runId ?? null,
+        taskId: row.runTaskId ?? row.taskId,
+        outcome: row.runOutcome ?? null,
+        reason: reasonByMessage.get(row.id) ?? null,
+        hold: holdByTask.get(row.runTaskId ?? row.taskId ?? "") ?? null
+      }));
+    }),
+    members: os5.inbox.members.handler(async () => ctx.inbox().members())
+  };
+}
+
+// ../server/src/router.ts
+var os6 = implement(contract);
 var EMPTY_BOARD_CATALOG = { catalogVersion: 1, host: null, modules: [] };
 var stubCtx = new Proxy({}, {
   get(_t, p) {
@@ -159899,7 +160425,7 @@ var stubCtx = new Proxy({}, {
 });
 function createRouter2(ctx) {
   return {
-    health: os5.health.handler(() => ({
+    health: os6.health.handler(() => ({
       status: "ok",
       timestamp: new Date().toISOString(),
       service: "spur",
@@ -159908,10 +160434,11 @@ function createRouter2(ctx) {
     task: createTaskHandlers(ctx ?? stubCtx),
     feature: createFeatureHandlers(ctx ?? stubCtx),
     history: createHistoryHandlers(ctx ?? stubCtx),
+    inbox: createInboxHandlers(ctx ?? stubCtx),
     board: {
-      modules: os5.board.modules.handler(() => ctx?.boardModules?.catalog ?? EMPTY_BOARD_CATALOG)
+      modules: os6.board.modules.handler(() => ctx?.boardModules?.catalog ?? EMPTY_BOARD_CATALOG)
     },
-    stream: os5.stream.handler(async () => {
+    stream: os6.stream.handler(async () => {
       throw new Error("SSE stream served by raw Hono route (modules/events)");
     })
   };
@@ -160100,6 +160627,7 @@ function createServerContext(appRt, options) {
   let featureSvc;
   let historyBoardSvc;
   let coordinationSvc;
+  let inboxSvc;
   let supervisorSvc;
   let processInventorySvc;
   let processRegistrySvc;
@@ -160276,6 +160804,11 @@ function createServerContext(appRt, options) {
       }
       return coordinationSvc;
     },
+    inbox() {
+      if (!inboxSvc)
+        inboxSvc = new InboxService({ getDb: this.getDb.bind(this) });
+      return inboxSvc;
+    },
     reloadAgentConfig: async () => {
       try {
         return await loadSpurConfig(cwd);
@@ -161784,6 +162317,7 @@ function registerWorkflowCleanCommand(workflow, context) {
 }
 
 // ../../packages/app/src/workflow/commit-guard.ts
+init_src();
 init_dist5();
 import { mkdirSync as mkdirSync23, readFileSync as readFileSync28, renameSync as renameSync10, writeFileSync as writeFileSync20 } from "fs";
 import { join as join100 } from "path";
@@ -161954,6 +162488,26 @@ function commitGuardStage(run, paths, options = {}) {
     foreign
   };
 }
+function foreignSessionOwner(cwd) {
+  try {
+    const raw = JSON.parse(readFileSync28(join100(cwd, ".spur", "context", ".session.json"), "utf8"));
+    const sessionId = typeof raw.owner?.sessionId === "string" ? raw.owner.sessionId : "";
+    if (sessionId === "")
+      return null;
+    const current = currentHostSessionId();
+    if (current === "" || current === sessionId)
+      return null;
+    return { host: typeof raw.owner?.host === "string" ? raw.owner.host : "unknown", sessionId };
+  } catch {
+    return null;
+  }
+}
+function currentHostSessionId() {
+  const transcript = getEnvVar("PI_SESSION_FILE") ?? "";
+  const stem = transcript.replace(/\.jsonl$/, "").split("/").pop() ?? "";
+  const pi = stem.includes("_") ? stem.split("_").pop() ?? "" : "";
+  return pi !== "" ? pi : (getEnvVar("CLAUDE_CODE_SESSION_ID") ?? "").trim();
+}
 function commitGuardCheck(run, options = {}) {
   try {
     const context = runContext(run, options);
@@ -161961,7 +162515,11 @@ function commitGuardCheck(run, options = {}) {
       return missingStart(run);
     const { base, git, written } = context;
     const foreign = [...changedSinceBase(base, git)].filter((path) => !written.has(path)).sort();
-    return report(0, [JSON.stringify({ foreign })]);
+    const owner = foreignSessionOwner(options.cwd ?? process.cwd());
+    const stderr = owner ? [
+      `commit-guard: another session owns this tree \u2014 .spur/context/.session.json records ${owner.host} ${owner.sessionId}; use a separate worktree (one writer per tree)`
+    ] : [];
+    return { ...report(0, [JSON.stringify({ foreign, ...owner ? { foreignSession: owner } : {} })], stderr) };
   } catch (err) {
     return report(1, [], [probeDiagnostic(err)]);
   }