@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-IRUTEHCE.js

@@ -0,0 +1,960 @@
+import {
+  isMailboxReceiptRecordV2,
+  normalizeRecipient,
+  validateSendType
+} from "./chunk-FWNLEZYG.js";
+import {
+  withSqliteExperimentalWarningSuppressed
+} from "./chunk-LX5QWLBL.js";
+import {
+  projectSlug
+} from "./chunk-SAFHACFA.js";
+
+// src/coordination/mailbox-constants.ts
+var AGENT_STALE_MS = 6e4;
+var CLIENT_STALE_MS = 6e4;
+var HEARTBEAT_THROTTLE_MS = 5e3;
+var LINE_SEPARATOR = "\n";
+var MAILBOX_AWARENESS_INTERVAL_MS = 3e4;
+var MAILBOX_HEARTBEAT_INTERVAL_MS = 3e4;
+var HQ_MAILBOX_SNAPSHOT_MIN_INTERVAL_MS = 1e4;
+var PULSE_MIN_READ_INTERVAL_MS = 3e4;
+var UNREAD_CHECK_MIN_INTERVAL_MS = 1e3;
+var AUTO_COMPACT_INTERVAL_MS = 3e5;
+var AUTO_COMPACT_READ_MAX_AGE_MS = 6e5;
+var AUTO_COMPACT_DEFAULT_TTL_MS = 864e5;
+var AUTO_COMPACT_TYPE_TTL_MS = {
+  status: 18e5
+  // 30 min
+};
+var MAILBOX_MAX_QUERY_LIMIT = 500;
+var MAILBOX_MAX_ACK_BATCH = 500;
+
+// src/coordination/mailbox-credential-store.ts
+import * as crypto from "node:crypto";
+var CREDENTIAL_STORE_FILE = "_mailbox_credentials.json";
+var MAX_CREDENTIAL_TTL = {
+  agent: 7 * 24 * 60 * 60 * 1e3,
+  // 7 days
+  operator: 24 * 60 * 60 * 1e3,
+  // 24 hours
+  service: 30 * 24 * 60 * 60 * 1e3
+  // 30 days
+};
+var ROTATION_OVERLAP_MS = 60 * 60 * 1e3;
+function createMailboxCredential(opts, now = Date.now()) {
+  const ttlMs = Math.min(opts.ttlMs, MAX_CREDENTIAL_TTL[opts.kind]);
+  const credentialId = crypto.randomUUID();
+  const secret = crypto.randomBytes(32).toString("hex");
+  const verifierKey = crypto.createHash("sha256").update(secret).digest();
+  const verifier = crypto.createHmac("sha256", verifierKey).update(credentialId).digest("hex");
+  return {
+    credential: {
+      credentialId,
+      verifier,
+      verifierAlgorithm: "hmac-sha256",
+      principalId: opts.principalId,
+      projectId: opts.projectId,
+      capabilities: opts.capabilities,
+      kind: opts.kind,
+      issuedAt: new Date(now).toISOString(),
+      expiresAt: new Date(now + ttlMs).toISOString(),
+      notBefore: opts.notBefore?.toISOString(),
+      status: "active",
+      statusChangedAt: new Date(now).toISOString(),
+      supersedes: opts.supersedes,
+      lastModifiedBy: opts.issuedBy
+    },
+    secret
+  };
+}
+function redactMailboxCredential(credential) {
+  const { verifier: _verifier, verifierAlgorithm: _algorithm, ...rest } = credential;
+  return rest;
+}
+function verifyMailboxCredential(credential, secret, now = Date.now()) {
+  if (credential === void 0) {
+    return { valid: false, reason: "credential not found" };
+  }
+  const rotationStillValid = credential.status === "rotated_out" && credential.rotationValidUntil !== void 0 && new Date(credential.rotationValidUntil).getTime() >= now;
+  if (credential.status !== "active" && !rotationStillValid) {
+    return { valid: false, reason: `credential is ${credential.status}`, credential };
+  }
+  if (new Date(credential.expiresAt).getTime() <= now) {
+    return { valid: false, reason: "credential expired", credential };
+  }
+  if (credential.notBefore !== void 0 && new Date(credential.notBefore).getTime() > now) {
+    return { valid: false, reason: "credential not yet valid", credential };
+  }
+  const verifierKey = crypto.createHash("sha256").update(secret).digest();
+  const expected = crypto.createHmac("sha256", verifierKey).update(credential.credentialId).digest("hex");
+  const actualBytes = Buffer.from(credential.verifier, "hex");
+  const expectedBytes = Buffer.from(expected, "hex");
+  if (actualBytes.length !== expectedBytes.length || !crypto.timingSafeEqual(actualBytes, expectedBytes)) {
+    return { valid: false, reason: "invalid secret" };
+  }
+  return { valid: true, credential };
+}
+
+// src/coordination/global-mailbox-paths.ts
+import * as path from "node:path";
+var GLOBAL_MAILBOX_FILE = "_mailbox.jsonl";
+var GLOBAL_MAILBOX_CLIENT_REGISTRY_FILE = "_mailbox.clients.json";
+function resolveProjectDir(projectRoot, globalRoot) {
+  return path.join(globalRoot, "projects", projectSlug(projectRoot));
+}
+
+// src/coordination/mailbox-message-codec.ts
+var MESSAGE_TYPES = /* @__PURE__ */ new Set([
+  "note",
+  "ask",
+  "assign",
+  "steer",
+  "btw",
+  "broadcast",
+  "status",
+  "result",
+  "review",
+  "control"
+]);
+var PRIORITIES = /* @__PURE__ */ new Set(["low", "normal", "high"]);
+var AUDIENCES = /* @__PURE__ */ new Set(["all", "leaders"]);
+var TASK_STATUSES = /* @__PURE__ */ new Set([
+  "pending",
+  "in_progress",
+  "completed",
+  "failed",
+  "idle",
+  "running",
+  "streaming",
+  "waiting_user",
+  "error",
+  "offline",
+  "busy"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requiredString(record, key) {
+  const value = record[key];
+  if (typeof value !== "string") {
+    throw new TypeError(`mailbox message field "${key}" must be a string`);
+  }
+  return value;
+}
+function optionalString(record, key) {
+  const value = record[key];
+  if (value === void 0) return {};
+  if (typeof value !== "string") {
+    throw new TypeError(`mailbox message field "${key}" must be a string when present`);
+  }
+  return { [key]: value };
+}
+function parseMessageType(value) {
+  if (value === "info") return "note";
+  if (value === "task") return "assign";
+  if (typeof value === "string" && MESSAGE_TYPES.has(value)) {
+    return value;
+  }
+  throw new TypeError('mailbox message field "type" is invalid');
+}
+function normalizeMailboxMessageType(value) {
+  return parseMessageType(value);
+}
+function resolveSendType(type, to) {
+  const normalizedTo = normalizeRecipient(to);
+  const resolved = type ?? (normalizedTo === "*" || normalizedTo.startsWith("@session:") ? "broadcast" : "note");
+  validateSendType(resolved, normalizedTo);
+  return resolved;
+}
+function resolveSendTypeSafe(type, to) {
+  try {
+    return { ok: true, type: resolveSendType(type, to) };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+function parsePriority(value) {
+  if (typeof value === "string" && PRIORITIES.has(value)) {
+    return value;
+  }
+  if (typeof value === "string") return "normal";
+  throw new TypeError('mailbox message field "priority" must be a string');
+}
+function parseAudience(value) {
+  if (value === void 0 || value === "all") return void 0;
+  if (typeof value === "string" && AUDIENCES.has(value)) {
+    return value;
+  }
+  throw new TypeError('mailbox message field "audience" is invalid');
+}
+function parseReadReceipts(record, to) {
+  const value = record["readBy"];
+  if (value === void 0) {
+    const legacyReadAt = record["readAt"];
+    return record["read"] === true && typeof legacyReadAt === "string" ? { [to || "unknown"]: legacyReadAt } : {};
+  }
+  if (!isRecord(value)) {
+    throw new TypeError('mailbox message field "readBy" must be an object');
+  }
+  const receipts = {};
+  for (const [agentId, timestamp] of Object.entries(value)) {
+    if (typeof timestamp !== "string") {
+      throw new TypeError("mailbox message read receipt timestamps must be strings");
+    }
+    receipts[agentId] = timestamp;
+  }
+  return receipts;
+}
+function parseTaskContext(value) {
+  if (value === void 0) return void 0;
+  if (!isRecord(value)) {
+    throw new TypeError('mailbox message field "taskContext" must be an object');
+  }
+  const status = value["status"];
+  if (status !== void 0 && (typeof status !== "string" || !TASK_STATUSES.has(status))) {
+    throw new TypeError("mailbox message taskContext status is invalid");
+  }
+  return {
+    ...optionalString(value, "agentRole"),
+    ...optionalString(value, "agentName"),
+    ...optionalString(value, "taskId"),
+    ...status === void 0 ? {} : { status }
+  };
+}
+function parseSessionAffinity(value) {
+  if (value === void 0) return void 0;
+  if (!isRecord(value)) {
+    throw new TypeError('mailbox message field "sessionAffinity" must be an object');
+  }
+  const sessionId = value["sessionId"];
+  const reportId = value["reportId"];
+  const kind = optionalString(value, "kind");
+  if (sessionId !== void 0) {
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+      throw new TypeError("mailbox message sessionAffinity.sessionId must be a non-empty string");
+    }
+    return {
+      sessionId,
+      ...optionalString(value, "reportId"),
+      ...kind
+    };
+  }
+  if (typeof reportId !== "string" || reportId.length === 0) {
+    throw new TypeError(
+      "mailbox message sessionAffinity.reportId must be a non-empty string when sessionId is absent"
+    );
+  }
+  return {
+    reportId,
+    ...kind
+  };
+}
+function parseMailboxMessage(value) {
+  if (!isRecord(value)) throw new TypeError("mailbox message must be an object");
+  const to = value["to"] === void 0 ? "" : requiredString(value, "to");
+  const completed = value["completed"];
+  if (typeof completed !== "boolean") {
+    throw new TypeError('mailbox message field "completed" must be a boolean');
+  }
+  const taskContext = parseTaskContext(value["taskContext"]);
+  const audience = parseAudience(value["audience"]);
+  const sessionAffinity = parseSessionAffinity(value["sessionAffinity"]);
+  return {
+    id: requiredString(value, "id"),
+    from: requiredString(value, "from"),
+    to,
+    type: parseMessageType(value["type"]),
+    ...audience === void 0 ? {} : { audience },
+    subject: requiredString(value, "subject"),
+    body: requiredString(value, "body"),
+    priority: parsePriority(value["priority"]),
+    readBy: parseReadReceipts(value, to),
+    completed,
+    timestamp: requiredString(value, "timestamp"),
+    ...optionalString(value, "completedBy"),
+    ...optionalString(value, "outcome"),
+    ...optionalString(value, "completedAt"),
+    ...optionalString(value, "deletedAt"),
+    ...optionalString(value, "deletedBy"),
+    ...optionalString(value, "replyTo"),
+    ...optionalString(value, "senderSessionId"),
+    ...optionalString(value, "expiresAt"),
+    ...taskContext === void 0 ? {} : { taskContext },
+    ...sessionAffinity === void 0 ? {} : { sessionAffinity }
+  };
+}
+function isAckRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && value["__ack"] === true;
+}
+function applyAckToMessage(msg, ack) {
+  if (ack.read && !(ack.readerId in msg.readBy)) {
+    msg.readBy[ack.readerId] = ack.timestamp;
+  }
+  if (ack.completed && !msg.completed) {
+    msg.completed = true;
+    msg.completedBy = ack.completedBy ?? ack.readerId;
+    msg.completedAt = ack.timestamp;
+  }
+  if (ack.outcome !== void 0 && msg.outcome !== ack.outcome) {
+    msg.outcome = ack.outcome;
+  }
+  if (ack.deleted === true) {
+    msg.deletedAt = ack.timestamp;
+    msg.deletedBy = ack.deletedBy ?? ack.readerId;
+  }
+  if (ack.deleted === false) {
+    delete msg.deletedAt;
+    delete msg.deletedBy;
+  }
+}
+
+// src/coordination/mailbox-receipt-folding.ts
+function isFanOutRecipient(to) {
+  if (to === "*") return true;
+  if (to.startsWith("@session:")) return true;
+  return !to.includes("@") && !to.includes("#");
+}
+function materializeMessage(msg, msgReceipts) {
+  const recipientState = foldRecipientState(msg, msgReceipts);
+  const legacyGlobalCompletion = classifyLegacyCompletion(msg, msgReceipts);
+  return {
+    ...msg,
+    recipientState,
+    ...legacyGlobalCompletion ? { legacyGlobalCompletion: true } : {}
+  };
+}
+function foldRecipientState(msg, v2Receipts) {
+  const state = {};
+  for (const [actorId, readAt] of Object.entries(msg.readBy)) {
+    state[actorId] = { actorId, readAt };
+  }
+  if (msg.completed && msg.completedBy && !isFanOutRecipient(msg.to)) {
+    const existing = state[msg.completedBy] ?? { actorId: msg.completedBy };
+    state[msg.completedBy] = {
+      ...existing,
+      completedAt: msg.completedAt ?? msg.timestamp,
+      completedBy: msg.completedBy,
+      ...msg.outcome !== void 0 ? { outcome: msg.outcome } : {}
+    };
+  }
+  const sorted = [...v2Receipts].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  for (const receipt of sorted) {
+    const actorId = receipt.actorId;
+    const existing = state[actorId] ?? { actorId };
+    const readAt = existing.readAt ?? (receipt.read === true ? receipt.timestamp : void 0);
+    let completedAt = existing.completedAt;
+    let completedBy = existing.completedBy;
+    if (receipt.completed === true) {
+      completedAt = receipt.timestamp;
+      completedBy = actorId;
+    } else if (receipt.completed === false) {
+      completedAt = void 0;
+      completedBy = void 0;
+    }
+    const outcome = receipt.outcome !== void 0 ? receipt.outcome : existing.outcome;
+    state[actorId] = { actorId, readAt, completedAt, completedBy, outcome };
+  }
+  return state;
+}
+function classifyLegacyCompletion(msg, v2Receipts) {
+  if (!msg.completed) return false;
+  if (v2Receipts.some((r) => r.completed === true)) return false;
+  return isFanOutRecipient(msg.to);
+}
+
+// src/coordination/sqlite-mailbox-rows.ts
+var MALFORMED_TIMESTAMP = "last_seen_at NOT GLOB '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]T*'";
+function withoutAggregateCompletion(message) {
+  const stored = {
+    ...message,
+    completed: message.legacyGlobalCompletion === true
+  };
+  if (!stored.completed) {
+    delete stored.completedBy;
+    delete stored.completedAt;
+  }
+  delete stored.outcome;
+  return stored;
+}
+function persistMessage(db, message, legacyGlobalCompletion = false) {
+  const stored = { ...message, readBy: { ...message.readBy } };
+  delete stored.recipientState;
+  delete stored.legacyGlobalCompletion;
+  db.prepare(`
+      INSERT INTO messages(
+        id, from_id, to_id, type, priority, timestamp, completed, completed_at,
+        deleted_at, sender_session_id, reply_to, expires_at,
+        legacy_global_completion, data
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        from_id = excluded.from_id,
+        to_id = excluded.to_id,
+        type = excluded.type,
+        priority = excluded.priority,
+        timestamp = excluded.timestamp,
+        completed = excluded.completed,
+        completed_at = excluded.completed_at,
+        deleted_at = excluded.deleted_at,
+        sender_session_id = excluded.sender_session_id,
+        reply_to = excluded.reply_to,
+        expires_at = excluded.expires_at,
+        legacy_global_completion = excluded.legacy_global_completion,
+        data = excluded.data
+    `).run(
+    message.id,
+    message.from,
+    message.to,
+    message.type,
+    message.priority,
+    message.timestamp,
+    message.completed ? 1 : 0,
+    message.completedAt ?? null,
+    message.deletedAt ?? null,
+    message.senderSessionId ?? null,
+    message.replyTo ?? null,
+    message.expiresAt ?? null,
+    legacyGlobalCompletion ? 1 : 0,
+    JSON.stringify(stored)
+  );
+}
+function persistReceipt(db, messageId, state) {
+  db.prepare(`
+      INSERT INTO message_receipts(
+        message_id, actor_id, read_at, completed_at, completed_by, outcome
+      ) VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(message_id, actor_id) DO UPDATE SET
+        read_at = excluded.read_at,
+        completed_at = excluded.completed_at,
+        completed_by = excluded.completed_by,
+        outcome = excluded.outcome
+    `).run(
+    messageId,
+    state.actorId,
+    state.readAt ?? null,
+    state.completedAt ?? null,
+    state.completedBy ?? null,
+    state.outcome ?? null
+  );
+}
+function materializeMessageRows(db, rows) {
+  if (rows.length === 0) return [];
+  const receiptRows = [];
+  for (const ids of chunk(
+    rows.map((row) => row.id),
+    400
+  )) {
+    const receiptSql = `
+        SELECT message_id, actor_id, read_at, completed_at, completed_by, outcome
+        FROM message_receipts
+        WHERE message_id IN (${ids.map(() => "?").join(", ")})
+      `;
+    receiptRows.push(...db.prepare(receiptSql).all(...ids));
+  }
+  const receiptState = /* @__PURE__ */ new Map();
+  for (const row of receiptRows) {
+    const states = receiptState.get(row.message_id) ?? {};
+    states[row.actor_id] = {
+      actorId: row.actor_id,
+      ...row.read_at !== null ? { readAt: row.read_at } : {},
+      ...row.completed_at !== null ? { completedAt: row.completed_at } : {},
+      ...row.completed_by !== null ? { completedBy: row.completed_by } : {},
+      ...row.outcome !== null ? { outcome: row.outcome } : {}
+    };
+    receiptState.set(row.message_id, states);
+  }
+  return rows.map((row) => {
+    const base = JSON.parse(row.data);
+    const recipientState = receiptState.get(row.id) ?? {};
+    const readBy = { ...base.readBy };
+    for (const state of Object.values(recipientState)) {
+      if (state.readAt !== void 0) readBy[state.actorId] = state.readAt;
+    }
+    return {
+      ...base,
+      readBy,
+      recipientState,
+      ...row.legacy_global_completion === 1 ? { legacyGlobalCompletion: true } : {}
+    };
+  });
+}
+function deleteMessages(db, ids) {
+  for (const chunkIds of chunk(ids, 400)) {
+    db.prepare(`DELETE FROM messages WHERE id IN (${chunkIds.map(() => "?").join(", ")})`).run(
+      ...chunkIds
+    );
+  }
+}
+function* chunk(values, size) {
+  for (let start = 0; start < values.length; start += size) {
+    yield values.slice(start, start + size);
+  }
+}
+function persistAgent(db, agent) {
+  db.prepare(`
+      INSERT INTO agents(
+        agent_id, session_id, name, role, status, current_tool, current_task,
+        iterations, tool_calls, registered_at, last_seen_at, pid, source
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(agent_id) DO UPDATE SET
+        session_id = excluded.session_id,
+        name = excluded.name,
+        role = excluded.role,
+        status = excluded.status,
+        current_tool = excluded.current_tool,
+        current_task = excluded.current_task,
+        iterations = excluded.iterations,
+        tool_calls = excluded.tool_calls,
+        registered_at = excluded.registered_at,
+        last_seen_at = excluded.last_seen_at,
+        pid = excluded.pid,
+        source = excluded.source
+    `).run(
+    agent.agentId,
+    agent.sessionId,
+    agent.name,
+    agent.role ?? null,
+    agent.status,
+    agent.currentTool ?? null,
+    agent.currentTask ?? null,
+    agent.iterations,
+    agent.toolCalls,
+    agent.registeredAt,
+    agent.lastSeenAt,
+    agent.pid,
+    agent.source ?? null
+  );
+}
+function readAgents(db) {
+  const rows = db.prepare("SELECT * FROM agents").all();
+  const agents = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const agent = {
+      agentId: String(row["agent_id"]),
+      sessionId: String(row["session_id"]),
+      name: String(row["name"]),
+      ...row["role"] !== null ? { role: String(row["role"]) } : {},
+      status: row["status"],
+      ...row["current_tool"] !== null ? { currentTool: String(row["current_tool"]) } : {},
+      ...row["current_task"] !== null ? { currentTask: String(row["current_task"]) } : {},
+      iterations: Number(row["iterations"]),
+      toolCalls: Number(row["tool_calls"]),
+      registeredAt: String(row["registered_at"]),
+      lastSeenAt: String(row["last_seen_at"]),
+      pid: Number(row["pid"]),
+      ...row["source"] !== null ? { source: row["source"] } : {}
+    };
+    agents.set(agent.agentId, agent);
+  }
+  return agents;
+}
+function pruneAgents(db, maxAgeMs = AGENT_STALE_MS) {
+  const cutoff = new Date(Date.now() - Math.max(0, maxAgeMs)).toISOString();
+  const result = db.prepare(`DELETE FROM agents WHERE last_seen_at < ? OR ${MALFORMED_TIMESTAMP}`).run(cutoff);
+  return Number(result.changes);
+}
+function persistClient(db, client) {
+  db.prepare(`
+      INSERT INTO clients(
+        client_id, session_id, name, source, registered_at, last_seen_at, pid
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(client_id) DO UPDATE SET
+        session_id = excluded.session_id,
+        name = excluded.name,
+        source = excluded.source,
+        registered_at = excluded.registered_at,
+        last_seen_at = excluded.last_seen_at,
+        pid = excluded.pid
+    `).run(
+    client.clientId,
+    client.sessionId,
+    client.name,
+    client.source,
+    client.registeredAt,
+    client.lastSeenAt,
+    client.pid
+  );
+}
+function readClients(db) {
+  const rows = db.prepare("SELECT * FROM clients").all();
+  const clients = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const client = {
+      clientId: String(row["client_id"]),
+      sessionId: String(row["session_id"]),
+      name: String(row["name"]),
+      source: row["source"],
+      registeredAt: String(row["registered_at"]),
+      lastSeenAt: String(row["last_seen_at"]),
+      pid: Number(row["pid"])
+    };
+    clients.set(client.clientId, client);
+  }
+  return clients;
+}
+function pruneClients(db) {
+  const cutoff = new Date(Date.now() - CLIENT_STALE_MS).toISOString();
+  const result = db.prepare(`DELETE FROM clients WHERE last_seen_at < ? OR ${MALFORMED_TIMESTAMP}`).run(cutoff);
+  return Number(result.changes);
+}
+function persistCredential(db, credential) {
+  db.prepare(`
+      INSERT INTO credentials(credential_id, status, principal_id, expires_at, data)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(credential_id) DO UPDATE SET
+        status = excluded.status,
+        principal_id = excluded.principal_id,
+        expires_at = excluded.expires_at,
+        data = excluded.data
+    `).run(
+    credential.credentialId,
+    credential.status,
+    credential.principalId,
+    credential.expiresAt,
+    JSON.stringify(credential)
+  );
+}
+
+// src/coordination/sqlite-mailbox-schema.ts
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+import { loadRuntimeDatabaseSync } from "@wrongstack/persistence";
+
+// src/coordination/mailbox-parse-state.ts
+function parseMailboxFile(raw) {
+  return createMailboxParseState(raw).projections;
+}
+function createMailboxParseState(raw) {
+  const state = {
+    messages: [],
+    projections: [],
+    indexById: /* @__PURE__ */ new Map(),
+    receiptsByMessage: /* @__PURE__ */ new Map()
+  };
+  ingestMailboxChunk(state, raw);
+  return state;
+}
+function ingestMailboxChunk(state, chunk2) {
+  const firstNewIndex = state.messages.length;
+  const ackRecords = [];
+  const staleExisting = /* @__PURE__ */ new Set();
+  for (const line of chunk2.split(LINE_SEPARATOR)) {
+    if (line.trim().length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (isMailboxReceiptRecordV2(parsed)) {
+      const list = state.receiptsByMessage.get(parsed.messageId);
+      if (list) list.push(parsed);
+      else state.receiptsByMessage.set(parsed.messageId, [parsed]);
+      for (const index2 of state.indexById.get(parsed.messageId) ?? []) {
+        if (index2 < firstNewIndex) staleExisting.add(index2);
+      }
+      continue;
+    }
+    if (isAckRecord(parsed)) {
+      ackRecords.push(parsed);
+      continue;
+    }
+    let message;
+    try {
+      message = parseMailboxMessage(parsed);
+    } catch {
+      continue;
+    }
+    const index = state.messages.length;
+    state.messages.push(message);
+    const indices = state.indexById.get(message.id);
+    if (indices) indices.push(index);
+    else state.indexById.set(message.id, [index]);
+  }
+  for (const ack of ackRecords) {
+    const indices = state.indexById.get(ack.messageId);
+    if (indices === void 0 || indices.length === 0) continue;
+    const index = indices[indices.length - 1];
+    applyAckToMessage(state.messages[index], ack);
+    if (index < firstNewIndex) staleExisting.add(index);
+  }
+  for (const index of staleExisting) {
+    const message = state.messages[index];
+    state.projections[index] = materializeMessage(
+      message,
+      state.receiptsByMessage.get(message.id) ?? []
+    );
+  }
+  for (let index = firstNewIndex; index < state.messages.length; index++) {
+    const message = state.messages[index];
+    state.projections.push(
+      materializeMessage(message, state.receiptsByMessage.get(message.id) ?? [])
+    );
+  }
+}
+
+// src/coordination/mailbox-registry-codec.ts
+function parseAgentRegistryEntry(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const v = value;
+  if (typeof v.agentId !== "string") return null;
+  if (typeof v.sessionId !== "string") return null;
+  const statuses = ["idle", "busy", "running", "streaming", "waiting_user", "error"];
+  const status = typeof v.status === "string" && statuses.includes(v.status) ? v.status : "idle";
+  return {
+    ...v,
+    agentId: v.agentId,
+    sessionId: v.sessionId,
+    name: typeof v.name === "string" ? v.name : v.agentId,
+    registeredAt: typeof v.registeredAt === "string" ? v.registeredAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+    lastSeenAt: typeof v.lastSeenAt === "string" ? v.lastSeenAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+    iterations: typeof v.iterations === "number" && Number.isFinite(v.iterations) ? v.iterations : 0,
+    toolCalls: typeof v.toolCalls === "number" && Number.isFinite(v.toolCalls) ? v.toolCalls : 0,
+    pid: typeof v.pid === "number" && Number.isFinite(v.pid) ? v.pid : 0,
+    status
+  };
+}
+function parseClientRegistryEntry(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const v = value;
+  if (typeof v.clientId !== "string") return null;
+  if (typeof v.sessionId !== "string") return null;
+  const sources = ["repl", "tui", "webui", "http"];
+  const source = typeof v.source === "string" && sources.includes(v.source) ? v.source : "http";
+  return {
+    ...v,
+    clientId: v.clientId,
+    sessionId: v.sessionId,
+    name: typeof v.name === "string" ? v.name : v.clientId,
+    registeredAt: typeof v.registeredAt === "string" ? v.registeredAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+    lastSeenAt: typeof v.lastSeenAt === "string" ? v.lastSeenAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+    pid: typeof v.pid === "number" && Number.isFinite(v.pid) ? v.pid : 0,
+    source
+  };
+}
+
+// src/coordination/sqlite-mailbox-schema.ts
+var SQLITE_MAILBOX_SCHEMA_VERSION = 2;
+var DatabaseSyncCtor;
+function loadDatabaseSync() {
+  if (DatabaseSyncCtor) return DatabaseSyncCtor;
+  return withSqliteExperimentalWarningSuppressed(() => {
+    DatabaseSyncCtor = loadRuntimeDatabaseSync();
+    return DatabaseSyncCtor;
+  });
+}
+function initializeSchema(ctx) {
+  const { db } = ctx;
+  db.exec(`
+      CREATE TABLE IF NOT EXISTS mailbox_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS messages (
+        id TEXT PRIMARY KEY,
+        from_id TEXT NOT NULL,
+        to_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        priority TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        completed INTEGER NOT NULL DEFAULT 0,
+        completed_at TEXT,
+        deleted_at TEXT,
+        sender_session_id TEXT,
+        reply_to TEXT,
+        expires_at TEXT,
+        legacy_global_completion INTEGER NOT NULL DEFAULT 0,
+        data TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS message_receipts (
+        message_id TEXT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+        actor_id TEXT NOT NULL,
+        read_at TEXT,
+        completed_at TEXT,
+        completed_by TEXT,
+        outcome TEXT,
+        PRIMARY KEY (message_id, actor_id)
+      );
+      CREATE TABLE IF NOT EXISTS agents (
+        agent_id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        role TEXT,
+        status TEXT NOT NULL,
+        current_tool TEXT,
+        current_task TEXT,
+        iterations INTEGER NOT NULL,
+        tool_calls INTEGER NOT NULL,
+        registered_at TEXT NOT NULL,
+        last_seen_at TEXT NOT NULL,
+        pid INTEGER NOT NULL,
+        source TEXT
+      );
+      CREATE TABLE IF NOT EXISTS clients (
+        client_id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        source TEXT NOT NULL,
+        registered_at TEXT NOT NULL,
+        last_seen_at TEXT NOT NULL,
+        pid INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS credentials (
+        credential_id TEXT PRIMARY KEY,
+        status TEXT NOT NULL,
+        principal_id TEXT NOT NULL,
+        expires_at TEXT NOT NULL,
+        data TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_messages_to_timestamp ON messages(to_id, timestamp DESC);
+      CREATE INDEX IF NOT EXISTS idx_messages_from_timestamp ON messages(from_id, timestamp DESC);
+      CREATE INDEX IF NOT EXISTS idx_messages_type_timestamp ON messages(type, timestamp DESC);
+      CREATE INDEX IF NOT EXISTS idx_messages_deleted_at ON messages(deleted_at);
+      CREATE INDEX IF NOT EXISTS idx_messages_session_timestamp ON messages(sender_session_id, timestamp DESC);
+      CREATE INDEX IF NOT EXISTS idx_messages_reply_timestamp ON messages(reply_to, timestamp DESC);
+      CREATE INDEX IF NOT EXISTS idx_receipts_actor ON message_receipts(actor_id, message_id);
+      CREATE INDEX IF NOT EXISTS idx_agents_last_seen ON agents(last_seen_at);
+      CREATE INDEX IF NOT EXISTS idx_clients_last_seen ON clients(last_seen_at);
+      CREATE INDEX IF NOT EXISTS idx_credentials_status ON credentials(status, expires_at);
+    `);
+  db.prepare("INSERT INTO mailbox_meta(key, value) VALUES (?, ?) ON CONFLICT(key) DO NOTHING").run(
+    "schema_version",
+    String(SQLITE_MAILBOX_SCHEMA_VERSION)
+  );
+  const schema = db.prepare("SELECT value FROM mailbox_meta WHERE key = ?").get("schema_version");
+  const foundVersion = Number(schema?.value);
+  if (!Number.isInteger(foundVersion) || foundVersion < 1 || foundVersion > SQLITE_MAILBOX_SCHEMA_VERSION) {
+    throw new Error(
+      `Unsupported mailbox SQLite schema ${schema?.value ?? "missing"}; this build supports ${SQLITE_MAILBOX_SCHEMA_VERSION}`
+    );
+  }
+  if (foundVersion < SQLITE_MAILBOX_SCHEMA_VERSION) {
+    db.prepare("UPDATE mailbox_meta SET value = ? WHERE key = ?").run(
+      String(SQLITE_MAILBOX_SCHEMA_VERSION),
+      "schema_version"
+    );
+  }
+  migrateLegacyCredentials(ctx);
+}
+function migrateLegacyCredentials(ctx) {
+  const { db } = ctx;
+  const marker = db.prepare("SELECT value FROM mailbox_meta WHERE key = ?").get("legacy_credentials_imported");
+  if (marker !== void 0) return;
+  const legacyPath = path2.join(ctx.projectDir, CREDENTIAL_STORE_FILE);
+  const credentials = [];
+  try {
+    for (const line of fs.readFileSync(legacyPath, "utf8").split(/\r?\n/u)) {
+      if (!line.trim()) continue;
+      try {
+        const credential = JSON.parse(line);
+        if (typeof credential.credentialId === "string" && typeof credential.verifier === "string" && typeof credential.principalId === "string")
+          credentials.push(credential);
+      } catch {
+      }
+    }
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT") throw error;
+  }
+  ctx.transaction(() => {
+    for (const credential of credentials) persistCredential(db, credential);
+    db.prepare("INSERT INTO mailbox_meta(key, value) VALUES (?, ?)").run(
+      "legacy_credentials_imported",
+      (/* @__PURE__ */ new Date()).toISOString()
+    );
+  });
+}
+function migrateLegacyFiles(ctx) {
+  const { db } = ctx;
+  const marker = db.prepare("SELECT value FROM mailbox_meta WHERE key = ?").get("legacy_files_imported");
+  if (marker !== void 0) return;
+  const messages = readLegacyMessages(ctx.projectDir);
+  const agents = readLegacyRegistry(
+    path2.join(ctx.projectDir, "_mailbox.registry.json"),
+    parseAgentRegistryEntry
+  );
+  const clients = readLegacyRegistry(
+    path2.join(ctx.projectDir, GLOBAL_MAILBOX_CLIENT_REGISTRY_FILE),
+    parseClientRegistryEntry
+  );
+  ctx.transaction(() => {
+    for (const message of messages) {
+      const projection = message;
+      persistMessage(db, message, projection.legacyGlobalCompletion === true);
+      for (const state of Object.values(projection.recipientState ?? {})) {
+        persistReceipt(db, message.id, state);
+      }
+    }
+    for (const agent of agents.values()) persistAgent(db, agent);
+    for (const client of clients.values()) persistClient(db, client);
+    db.prepare("INSERT INTO mailbox_meta(key, value) VALUES (?, ?)").run(
+      "legacy_files_imported",
+      (/* @__PURE__ */ new Date()).toISOString()
+    );
+  });
+}
+function readLegacyMessages(projectDir) {
+  try {
+    return parseMailboxFile(fs.readFileSync(path2.join(projectDir, GLOBAL_MAILBOX_FILE), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+function readLegacyRegistry(filePath, parseEntry) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    const result = /* @__PURE__ */ new Map();
+    for (const [id, value] of Object.entries(raw)) {
+      const parsed = parseEntry(value);
+      if (parsed !== null) result.set(id, parsed);
+    }
+    return result;
+  } catch (error) {
+    if (error.code === "ENOENT") return /* @__PURE__ */ new Map();
+    throw error;
+  }
+}
+
+export {
+  AGENT_STALE_MS,
+  CLIENT_STALE_MS,
+  HEARTBEAT_THROTTLE_MS,
+  MAILBOX_AWARENESS_INTERVAL_MS,
+  MAILBOX_HEARTBEAT_INTERVAL_MS,
+  HQ_MAILBOX_SNAPSHOT_MIN_INTERVAL_MS,
+  PULSE_MIN_READ_INTERVAL_MS,
+  UNREAD_CHECK_MIN_INTERVAL_MS,
+  AUTO_COMPACT_INTERVAL_MS,
+  AUTO_COMPACT_READ_MAX_AGE_MS,
+  AUTO_COMPACT_DEFAULT_TTL_MS,
+  AUTO_COMPACT_TYPE_TTL_MS,
+  MAILBOX_MAX_QUERY_LIMIT,
+  MAILBOX_MAX_ACK_BATCH,
+  normalizeMailboxMessageType,
+  resolveSendType,
+  resolveSendTypeSafe,
+  isFanOutRecipient,
+  MAX_CREDENTIAL_TTL,
+  ROTATION_OVERLAP_MS,
+  createMailboxCredential,
+  redactMailboxCredential,
+  verifyMailboxCredential,
+  withoutAggregateCompletion,
+  persistMessage,
+  persistReceipt,
+  materializeMessageRows,
+  deleteMessages,
+  persistAgent,
+  readAgents,
+  pruneAgents,
+  persistClient,
+  readClients,
+  pruneClients,
+  persistCredential,
+  resolveProjectDir,
+  loadDatabaseSync,
+  initializeSchema,
+  migrateLegacyFiles
+};
+//# sourceMappingURL=chunk-IRUTEHCE.js.map