@humwick/server 0.130.2 → 0.130.4

package/src/db/pairs.ts

@@ -4,7 +4,7 @@ import { matchAgents } from "../agent-ref";
 import { getAgent, listAgents } from "./agents.ts";
 import { getDb } from "./connection.ts";
 import { rowToPair } from "./mappers.ts";
-import { sendMessage } from "./messages.ts";
+import { sendMessageWithResultInternal } from "./messages.ts";
 export { closeOpenPairsForAgent } from "./pair-maintenance.ts";
 import type {
   AgentCard,
@@ -26,8 +26,8 @@ function expirePendingPairs(now: number = Date.now()): void {
     .run(now, now, now);
 }
 
-function getOpenPairForAgent(agentId: string): PairSession | null {
-  expirePendingPairs();
+function getOpenPairForAgent(agentId: string, now: number = Date.now()): PairSession | null {
+  expirePendingPairs(now);
   const row = getDb().query(`
     SELECT * FROM pairs
     WHERE status IN ('pending', 'active') AND (requester_id = ? OR target_id = ?)
@@ -45,7 +45,7 @@ function pairPeer(pair: PairSession, agentId: string): string {
   return pair.requesterId === agentId ? pair.targetId : pair.requesterId;
 }
 
-function resolvePairTarget(target: string, requesterId: string): {
+function resolvePairTarget(target: string, requesterId: string, now: number = Date.now()): {
   ok: true;
   agent: AgentCard;
 } | {
@@ -64,7 +64,7 @@ function resolvePairTarget(target: string, requesterId: string): {
   const busy: Array<{ agent: AgentCard; pair: PairSession }> = [];
   const available: AgentCard[] = [];
   for (const agent of live) {
-    const openPair = getOpenPairForAgent(agent.id);
+    const openPair = getOpenPairForAgent(agent.id, now);
     if (openPair) busy.push({ agent, pair: openPair });
     else available.push(agent);
   }
@@ -81,8 +81,8 @@ function resolvePairTarget(target: string, requesterId: string): {
   return { ok: true, agent: available[0]! };
 }
 
-function pairSystemMessage(pair: PairSession, to: string, event: string, subject: string, body: string): Message {
-  return sendMessage({
+function pairSystemMessage(pair: PairSession, to: string, event: string, subject: string, body: string, now: number = Date.now()): Message {
+  return sendMessageWithResultInternal({
     from: "system",
     to,
     kind: "pair",
@@ -95,17 +95,17 @@ function pairSystemMessage(pair: PairSession, to: string, event: string, subject
       targetId: pair.targetId,
       pairStatus: pair.status,
     },
-  });
+  }, false, {}, now).message;
 }
 
-export function getPair(id: string): PairSession | null {
-  expirePendingPairs();
+export function getPair(id: string, now: number = Date.now()): PairSession | null {
+  expirePendingPairs(now);
   const row = getDb().query("SELECT * FROM pairs WHERE id = ?").get(id) as any;
   return row ? rowToPair(row) : null;
 }
 
-export function listPairs(filter?: { agentId?: string; status?: PairStatus }): PairSession[] {
-  expirePendingPairs();
+export function listPairs(filter?: { agentId?: string; status?: PairStatus }, now: number = Date.now()): PairSession[] {
+  expirePendingPairs(now);
   const conditions: string[] = [];
   const params: any[] = [];
   if (filter?.agentId) {
@@ -120,7 +120,7 @@ export function listPairs(filter?: { agentId?: string; status?: PairStatus }): P
   return (getDb().query(`SELECT * FROM pairs ${where} ORDER BY updated_at DESC LIMIT 100`).all(...params) as any[]).map(rowToPair);
 }
 
-export function createPair(input: CreatePairInput): {
+export function createPair(input: CreatePairInput, now: number = Date.now()): {
   ok: true;
   pair: PairSession;
   invite: Message;
@@ -131,25 +131,23 @@ export function createPair(input: CreatePairInput): {
   matches?: AgentCard[];
   busy?: Array<{ agent: AgentCard; pair: PairSession }>;
 } {
-  expirePendingPairs();
+  expirePendingPairs(now);
   const requester = getAgent(input.from);
   if (!requester) return { ok: false, code: "invalid", error: `requester agent ${input.from} not registered` };
   if (requester.status === "offline" || !requester.ready) return { ok: false, code: "offline", error: `requester agent ${input.from} is not online and ready` };
-  const requesterPair = getOpenPairForAgent(input.from);
+  const requesterPair = getOpenPairForAgent(input.from, now);
   if (requesterPair) return { ok: false, code: "busy", error: `requester is already paired`, busy: [{ agent: requester, pair: requesterPair }] };
 
-  const resolved = resolvePairTarget(input.target, input.from);
+  const resolved = resolvePairTarget(input.target, input.from, now);
   if (!resolved.ok) return resolved;
   if (resolved.agent.id === input.from) return { ok: false, code: "invalid", error: "cannot pair with yourself" };
-
-  const now = Date.now();
   const ttlMs = Math.min(Math.max(input.ttlMs ?? DEFAULT_PAIR_TTL_MS, 10_000), MAX_PAIR_TTL_MS);
   const id = randomUUID();
   getDb().query(`
     INSERT INTO pairs (id, requester_id, target_id, status, objective, meta, created_at, updated_at, expires_at)
     VALUES (?, ?, ?, 'pending', ?, ?, ?, ?, ?)
   `).run(id, input.from, resolved.agent.id, input.objective ?? null, JSON.stringify(input.meta ?? {}), now, now, now + ttlMs);
-  const pair = getPair(id)!;
+  const pair = getPair(id, now)!;
   const objective = pair.objective ? `\n\nObjective:\n${pair.objective}` : "";
   const invite = pairSystemMessage(
     pair,
@@ -163,14 +161,14 @@ export function createPair(input: CreatePairInput): {
       "Accept with POST /api/pairs/{id}/accept using your agentId.",
       "Reject with POST /api/pairs/{id}/reject using your agentId.",
       "Pairing is exclusive: each agent can be in at most one pending or active pair.",
-    ].join("\n"),
+    ].join("\n"), now
   );
   return { ok: true, pair, invite };
 }
 
-export function acceptPair(id: string, input: PairActionInput): { ok: true; pair: PairSession; notices: Message[] } | { ok: false; error: string; code: "not_found" | "forbidden" | "busy" | "invalid" } {
-  expirePendingPairs();
-  const pair = getPair(id);
+export function acceptPair(id: string, input: PairActionInput, now: number = Date.now()): { ok: true; pair: PairSession; notices: Message[] } | { ok: false; error: string; code: "not_found" | "forbidden" | "busy" | "invalid" } {
+  expirePendingPairs(now);
+  const pair = getPair(id, now);
   if (!pair) return { ok: false, code: "not_found", error: "pair not found" };
   if (pair.status !== "pending") return { ok: false, code: "invalid", error: `pair is ${pair.status}` };
   if (pair.targetId !== input.agentId) return { ok: false, code: "forbidden", error: "only the target agent can accept this pair" };
@@ -180,61 +178,56 @@ export function acceptPair(id: string, input: PairActionInput): { ok: true; pair
   if (!requester || requester.status === "offline" || !requester.ready) return { ok: false, code: "invalid", error: "requester agent is no longer online and ready" };
 
   for (const agentId of [pair.requesterId, pair.targetId]) {
-    const open = getOpenPairForAgent(agentId);
+    const open = getOpenPairForAgent(agentId, now);
     if (open && open.id !== pair.id) return { ok: false, code: "busy", error: `${agentId} is already paired` };
   }
-
-  const now = Date.now();
   getDb().query("UPDATE pairs SET status = 'active', accepted_at = ?, updated_at = ? WHERE id = ? AND status = 'pending'")
     .run(now, now, id);
-  const active = getPair(id)!;
+  const active = getPair(id, now)!;
   const notices = [
-    pairSystemMessage(active, active.requesterId, "accepted", `Pair accepted by ${active.targetId}`, `Pair ${active.id} is active. Send pair messages with POST /api/pairs/${active.id}/messages.`),
-    pairSystemMessage(active, active.targetId, "accepted", `Pair active with ${active.requesterId}`, `Pair ${active.id} is active. Send pair messages with POST /api/pairs/${active.id}/messages.`),
+    pairSystemMessage(active, active.requesterId, "accepted", `Pair accepted by ${active.targetId}`, `Pair ${active.id} is active. Send pair messages with POST /api/pairs/${active.id}/messages.`, now),
+    pairSystemMessage(active, active.targetId, "accepted", `Pair active with ${active.requesterId}`, `Pair ${active.id} is active. Send pair messages with POST /api/pairs/${active.id}/messages.`, now),
   ];
   return { ok: true, pair: active, notices };
 }
 
-export function rejectPair(id: string, input: PairActionInput): { ok: true; pair: PairSession; notice: Message } | { ok: false; error: string; code: "not_found" | "forbidden" | "invalid" } {
-  expirePendingPairs();
-  const pair = getPair(id);
+export function rejectPair(id: string, input: PairActionInput, now: number = Date.now()): { ok: true; pair: PairSession; notice: Message } | { ok: false; error: string; code: "not_found" | "forbidden" | "invalid" } {
+  expirePendingPairs(now);
+  const pair = getPair(id, now);
   if (!pair) return { ok: false, code: "not_found", error: "pair not found" };
   if (pair.status !== "pending") return { ok: false, code: "invalid", error: `pair is ${pair.status}` };
   if (pair.targetId !== input.agentId) return { ok: false, code: "forbidden", error: "only the target agent can reject this pair" };
-  const now = Date.now();
   getDb().query("UPDATE pairs SET status = 'rejected', ended_at = ?, ended_by = ?, updated_at = ? WHERE id = ?")
     .run(now, input.agentId, now, id);
-  const rejected = getPair(id)!;
+  const rejected = getPair(id, now)!;
   const reason = input.reason ? `\n\nReason:\n${input.reason}` : "";
-  const notice = pairSystemMessage(rejected, rejected.requesterId, "rejected", `Pair rejected by ${input.agentId}`, `Pair ${rejected.id} was rejected.${reason}`);
+  const notice = pairSystemMessage(rejected, rejected.requesterId, "rejected", `Pair rejected by ${input.agentId}`, `Pair ${rejected.id} was rejected.${reason}`, now);
   return { ok: true, pair: rejected, notice };
 }
 
-export function endPair(id: string, input: PairActionInput): { ok: true; pair: PairSession; notice?: Message } | { ok: false; error: string; code: "not_found" | "forbidden" | "invalid" } {
-  expirePendingPairs();
-  const pair = getPair(id);
+export function endPair(id: string, input: PairActionInput, now: number = Date.now()): { ok: true; pair: PairSession; notice?: Message } | { ok: false; error: string; code: "not_found" | "forbidden" | "invalid" } {
+  expirePendingPairs(now);
+  const pair = getPair(id, now);
   if (!pair) return { ok: false, code: "not_found", error: "pair not found" };
   if (!pairParticipant(pair, input.agentId)) return { ok: false, code: "forbidden", error: "only pair participants can hang up" };
   if (!OPEN_PAIR_STATUSES.includes(pair.status as any)) return { ok: false, code: "invalid", error: `pair is ${pair.status}` };
-  const now = Date.now();
   getDb().query("UPDATE pairs SET status = 'ended', ended_at = ?, ended_by = ?, updated_at = ? WHERE id = ?")
     .run(now, input.agentId, now, id);
-  const ended = getPair(id)!;
+  const ended = getPair(id, now)!;
   const reason = input.reason ? `\n\nReason:\n${input.reason}` : "";
   const peer = pairPeer(ended, input.agentId);
-  const notice = pairSystemMessage(ended, peer, "ended", `Pair ended by ${input.agentId}`, `Pair ${ended.id} ended.${reason}`);
+  const notice = pairSystemMessage(ended, peer, "ended", `Pair ended by ${input.agentId}`, `Pair ${ended.id} ended.${reason}`, now);
   return { ok: true, pair: ended, notice };
 }
 
-export function sendPairMessage(id: string, input: PairMessageInput): { ok: true; pair: PairSession; message: Message } | { ok: false; error: string; code: "not_found" | "forbidden" | "invalid" } {
-  expirePendingPairs();
-  const pair = getPair(id);
+export function sendPairMessage(id: string, input: PairMessageInput, now: number = Date.now()): { ok: true; pair: PairSession; message: Message } | { ok: false; error: string; code: "not_found" | "forbidden" | "invalid" } {
+  expirePendingPairs(now);
+  const pair = getPair(id, now);
   if (!pair) return { ok: false, code: "not_found", error: "pair not found" };
   if (pair.status !== "active") return { ok: false, code: "invalid", error: `pair is ${pair.status}` };
   if (!pairParticipant(pair, input.from)) return { ok: false, code: "forbidden", error: "only pair participants can send pair messages" };
   const to = pairPeer(pair, input.from);
-  const now = Date.now();
-  const message = sendMessage({
+  const message = sendMessageWithResultInternal({
     from: input.from,
     to,
     kind: "pair",
@@ -246,7 +239,7 @@ export function sendPairMessage(id: string, input: PairMessageInput): { ok: true
       requesterId: pair.requesterId,
       targetId: pair.targetId,
     },
-  });
+  }, false, {}, now).message;
   getDb().query("UPDATE pairs SET last_message_at = ?, updated_at = ? WHERE id = ?").run(now, now, id);
-  return { ok: true, pair: getPair(id)!, message };
+  return { ok: true, pair: getPair(id, now)!, message };
 }

package/src/db/plan-dispatch-schema.ts

@@ -1,4 +1,4 @@
-// #3660 — plan autopilot tables (see plan-dispatch-store.ts); dependency-free so the startup catalog can include it.
+// #3660 — plan autopilot tables (see plan-dispatch-store.ts) and ready-node notice state (plan-ready-notices.ts); dependency-free so the startup catalog can include it.
 export const PLAN_DISPATCH_SCHEMA_SQL = `
   CREATE TABLE IF NOT EXISTS task_executions (task_id INTEGER PRIMARY KEY, execution TEXT NOT NULL, updated_at INTEGER NOT NULL);
   CREATE TABLE IF NOT EXISTS plan_dispatch (
@@ -14,4 +14,8 @@ export const PLAN_DISPATCH_SCHEMA_SQL = `
   CREATE TABLE IF NOT EXISTS plan_ci_blocks (
     run_id TEXT PRIMARY KEY, plan_id TEXT NOT NULL, task_id INTEGER NOT NULL, sha TEXT NOT NULL,
     incident_ids TEXT NOT NULL, wait_key TEXT NOT NULL, retry_note TEXT NOT NULL, retried_at INTEGER
+  );
+  CREATE TABLE IF NOT EXISTS plan_ready_notices (
+    plan_id TEXT NOT NULL, node_id TEXT NOT NULL, ready_since INTEGER NOT NULL, notified_at INTEGER,
+    PRIMARY KEY (plan_id, node_id)
   )`;

package/src/db/plan-ready-notices.ts

@@ -0,0 +1,43 @@
+// #3660 — durable "ready since / already told" state per plan node, so a hub restart neither
+// loses the unstarted-ready clock nor repeats a notice. A row exists exactly while the node is
+// ready-and-unstarted; leaving ready deletes it, so re-entering ready starts a fresh clock.
+import { getDb } from "./connection.ts";
+
+export interface ReadyPlanScan { planId: string; nodeIds: string[] }
+export interface DueReadyNodes { planId: string; nodes: Array<{ nodeId: string; readySince: number }> }
+
+/** Reconcile every scanned plan's ready set; plans absent from `scans` (archived, done, deleted,
+ * coordinator-less) lose their rows. Returns the nodes ready for >= `dueMs` and not yet notified. */
+export function syncPlanReadyNotices(args: { scans: ReadyPlanScan[]; now: number; dueMs: number }): DueReadyNodes[] {
+  const db = getDb();
+  const scanned = new Set(args.scans.map(scan => scan.planId));
+  for (const { plan_id } of db.query("SELECT DISTINCT plan_id FROM plan_ready_notices").all() as Array<{ plan_id: string }>) {
+    if (!scanned.has(plan_id)) db.query("DELETE FROM plan_ready_notices WHERE plan_id = ?").run(plan_id);
+  }
+  const due: DueReadyNodes[] = [];
+  for (const scan of args.scans) {
+    const keep = new Set(scan.nodeIds);
+    const rows = db.query("SELECT node_id, ready_since, notified_at FROM plan_ready_notices WHERE plan_id = ?").all(scan.planId) as
+      Array<{ node_id: string; ready_since: number; notified_at: number | null }>;
+    const nodes: DueReadyNodes["nodes"] = [];
+    const known = new Set<string>();
+    for (const row of rows) {
+      if (!keep.has(row.node_id)) { db.query("DELETE FROM plan_ready_notices WHERE plan_id = ? AND node_id = ?").run(scan.planId, row.node_id); continue; }
+      known.add(row.node_id);
+      if (row.notified_at === null && row.ready_since <= args.now - args.dueMs) nodes.push({ nodeId: row.node_id, readySince: row.ready_since });
+    }
+    for (const nodeId of keep) if (!known.has(nodeId)) db.query("INSERT INTO plan_ready_notices(plan_id, node_id, ready_since) VALUES(?, ?, ?)").run(scan.planId, nodeId, args.now);
+    if (nodes.length) due.push({ planId: scan.planId, nodes });
+  }
+  return due;
+}
+
+export function markPlanReadyNoticed(args: { planId: string; nodeIds: string[]; now: number }): void {
+  const stmt = getDb().query("UPDATE plan_ready_notices SET notified_at = ? WHERE plan_id = ? AND node_id = ? AND notified_at IS NULL");
+  for (const nodeId of args.nodeIds) stmt.run(args.now, args.planId, nodeId);
+}
+
+export const PLAN_READY_NOTICE_WRITE_OPS = {
+  "plans.readyNotices.sync": { offLoop: true, idempotent: true, fn: syncPlanReadyNotices },
+  "plans.readyNotices.mark": { offLoop: true, idempotent: true, fn: markPlanReadyNoticed },
+};

package/src/db/plan-tools-include-migration.ts

@@ -0,0 +1,36 @@
+// #3812 — backfill relay_plan_start/import into stored per-tool allowlists (the lean coordinator
+// from #3472 froze before they existed, so tools/list never carried them).
+// Narrow: only an include list already holding relay_plan_get, and not excluding the tool.
+// json_insert, not parse+reserialize (#1456); patches `$.relay.tools` and its `sources` mirror, and
+// the -v1-backup namespace, whose bytes are served while the matrix flag is off.
+import { getDb } from "./connection.ts";
+import { runMigrationOnce } from "./migration-marker.ts";
+
+const PROFILE_NAMESPACES = ["agent-profile", "agent-profile-override", "agent-profile-override-v1-backup"] as const;
+const SELECTION_PATHS = ["$.relay.tools", "$.sources.agentRelay.mcp"] as const;
+const BACKFILLED_TOOLS = ["relay_plan_start", "relay_plan_import"] as const;
+const EVIDENCE_TOOL = "relay_plan_get";
+
+export function backfillPlanToolsIntoToolIncludes(): void {
+  runMigrationOnce("plan-tools-include-backfill-v1", () => {
+    const db = getDb();
+    const namespaces = PROFILE_NAMESPACES.map(() => "?").join(", ");
+    // The outer table is aliased: inside the subqueries a bare `value` binds to json_each.value.
+    const holds = (path: string, field: "include" | "exclude", tool: string) =>
+      `EXISTS (SELECT 1 FROM json_each(c.value, '${path}.${field}') je WHERE je.value = '${tool}')`;
+    db.transaction(() => {
+      for (const path of SELECTION_PATHS) {
+        for (const tool of BACKFILLED_TOOLS) {
+          db.query(
+            `UPDATE config AS c SET value = json_insert(c.value, '${path}.include[#]', ?)
+             WHERE c.namespace IN (${namespaces}) AND json_valid(c.value)
+               AND json_type(c.value, '${path}.include') = 'array'
+               AND ${holds(path, "include", EVIDENCE_TOOL)}
+               AND NOT ${holds(path, "include", tool)}
+               AND NOT ${holds(path, "exclude", tool)}`,
+          ).run(tool, ...PROFILE_NAMESPACES);
+        }
+      }
+    })();
+  });
+}

package/src/db/plans-write-ops.ts

@@ -1,7 +1,9 @@
 import { createPlanRow, deletePlan, replacePlanIfVersion, setPlanArchived } from "./plans.ts";
+import { PLAN_READY_NOTICE_WRITE_OPS } from "./plan-ready-notices.ts";
 import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 
 export const PLANS_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
+  ...PLAN_READY_NOTICE_WRITE_OPS,
   "plans.create": { offLoop: true, idempotent: false, fn: (args: { input: Parameters<typeof createPlanRow>[0] }, ctx: WriterOpContext) => createPlanRow(args.input, ctx.now) },
   "plans.replace": { offLoop: true, idempotent: false, fn: (args: { input: Parameters<typeof replacePlanIfVersion>[0]; changedBy?: string }, ctx: WriterOpContext) => replacePlanIfVersion(args.input, args.changedBy, ctx.now, false) },
   "plans.setArchived": { offLoop: true, idempotent: true, fn: (args: { id: string; archived: boolean }, ctx: WriterOpContext) => setPlanArchived(args.id, args.archived, ctx.now) },

package/src/db/presence-buffer.ts

@@ -104,6 +104,11 @@ export function snapshotBufferedPresence(): PresenceSnapshot {
  *  current, and the caller's surrounding status/ready predicates constrain the match. */
 export function bufferedLiveAgentIds(cutoff: number): string[] {
   const ids: string[] = [];
+  const snapshot = writerPresenceSnapshot();
+  if (snapshot) {
+    for (const beat of snapshot) if (beat.lastSeen > cutoff) ids.push(beat.id);
+    return ids;
+  }
   for (const [id, pending] of pendingPresence) {
     if (pending.lastSeen > cutoff) ids.push(id);
   }

package/src/db/presence-loop.ts

@@ -1,3 +1,4 @@
+import { framed } from "../hub-metrics";
 import { assertMainThreadState } from "./main-thread-state";
 // Lifecycle glue for the coalesced presence buffer. Kept outside agents.ts so its writer-op body
 // never depends on the gateway-facing facade (ADR 0001 §3.1).
@@ -6,53 +7,47 @@ import { errMessage } from "@humwick/sdk";
 import { PRESENCE_FLUSH_MS } from "../config";
 import { drainPendingLandSettleSideEffects } from "../land-settle-dispatch";
 import { onShutdown } from "../shutdown";
-import { flushPresence } from "./agents.ts";
+import { flushPresenceAsync } from "./presence-write.ts";
 import { pendingPresence } from "./presence-buffer.ts";
 
 let presenceFlushTimer: ReturnType<typeof setInterval> | undefined;
-let asyncPresenceFlusher: (() => Promise<{ flushed: number }>) | undefined;
 let removeShutdownHook: (() => void) | undefined;
 
-/** Attach the gateway-backed normal-tick flusher without importing the gateway into agents.ts. */
-export function setAsyncPresenceFlusher(flusher: () => Promise<{ flushed: number }>): void {
-  assertMainThreadState("presence-loop.ts");
-  asyncPresenceFlusher = flusher;
-}
-
 /** Start the periodic presence-buffer flush loop (server boot). */
 export function startPresenceFlushLoop(intervalMs: number = PRESENCE_FLUSH_MS): void {
   assertMainThreadState("presence-loop.ts");
   if (presenceFlushTimer) return;
-  presenceFlushTimer = setInterval(() => {
-    const flush = asyncPresenceFlusher;
-    if (!flush) return flushPresenceQuietly(); // Bootstrap/isolated compatibility fallback.
-    void flush().catch((err) => console.warn(`[presence] flush failed: ${errMessage(err)}`));
-  }, intervalMs);
+  presenceFlushTimer = setInterval(framed("timer presence-flush", () =>
+    flushPresenceAsync().catch((err) => console.warn(`[presence] flush failed: ${errMessage(err)}`))), intervalMs);
   presenceFlushTimer.unref?.();
-  process.once("beforeExit", flushPresenceQuietly);
-  removeShutdownHook = onShutdown("presence", () => {
-    drainPendingLandSettleSideEffects();
-    stopPresenceFlushLoop();
+  process.once("beforeExit", flushPresenceBeforeExit);
+  removeShutdownHook = onShutdown("presence", async () => {
+    await drainPendingLandSettleSideEffects();
+    await stopPresenceFlushLoop();
   });
 }
 
 /** Stop the loop and persist whatever is buffered (graceful shutdown / test teardown). */
-export function stopPresenceFlushLoop(): void {
+function detachPresenceLoop(): void {
   assertMainThreadState("presence-loop.ts");
   removeShutdownHook?.();
   removeShutdownHook = undefined;
-  process.removeListener("beforeExit", flushPresenceQuietly);
+  process.removeListener("beforeExit", flushPresenceBeforeExit);
   if (presenceFlushTimer) clearInterval(presenceFlushTimer);
   presenceFlushTimer = undefined;
-  flushPresenceQuietly();
 }
 
-function flushPresenceQuietly(): void {
-  try { flushPresence(); } catch (err) { console.warn(`[presence] flush failed: ${errMessage(err)}`); }
+export async function stopPresenceFlushLoop(): Promise<void> {
+  detachPresenceLoop();
+  await flushPresenceAsync();
+}
+
+function flushPresenceBeforeExit(): void {
+  void flushPresenceAsync().catch(err => console.warn(`[presence] flush failed: ${errMessage(err)}`));
 }
 
 /** Test-only: drop the buffered presence and stop the flush loop. */
 export function resetPresenceBufferForTests(): void {
   pendingPresence.clear();
-  stopPresenceFlushLoop();
+  detachPresenceLoop();
 }

package/src/db/presence-write.ts

@@ -3,7 +3,6 @@ import { assertMainThreadState } from "./main-thread-state";
 // Kept outside agents.ts because the writer registry imports the op body from that module; importing
 // the gateway there would make the writer-stack cycle gateway → write-ops → agents → gateway.
 
-import { setAsyncPresenceFlusher } from "./presence-loop.ts";
 import { settlePendingPresenceFlush, snapshotPendingPresenceFlush, type PresenceFlushPayload } from "./presence-buffer.ts";
 import { getGateway } from "./gateway.ts";
 
@@ -31,8 +30,3 @@ export function flushPresenceAsync(now: number = Date.now()): Promise<{ flushed:
     .finally(() => { activeFlush = undefined; });
   return activeFlush;
 }
-
-// The timer remains owned by presence-loop.ts for its synchronous shutdown guarantee, while normal ticks
-// arrive here through an injected callback. This direction deliberately avoids a writer-op → gateway
-// dependency cycle; the callback carries no DB closure across the worker seam.
-setAsyncPresenceFlusher(flushPresenceAsync);

package/src/db/project-entries-async.ts

@@ -1,3 +1,5 @@
+import { randomUUID } from "node:crypto";
+import type { writeProjectEntry, promoteBlackboardEntry } from "./project-entries";
 // Async project-entries facades (T4060 hub on-loop). Kept outside
 // project-entries.ts to avoid a gateway cycle.
 import { getGateway } from "./gateway.ts";
@@ -16,3 +18,15 @@ export const searchProjectEntriesAsync = (
   query: string,
   opts: ProjectEntrySearchOptions = {},
 ): Promise<ProjectEntrySearchResult[]> => read("projectEntries.search", { projectId, query, ...opts });
+
+export const getProjectEntryAsync = (id: string): Promise<ProjectEntry | null> => read("projectEntries.get", { id });
+export const getProjectEntryChainAsync = (id: string): Promise<ProjectEntry[]> => read("projectEntries.chain", { id });
+export const listActiveEntriesInAreaAsync = (projectId: string, area: string): Promise<ProjectEntry[]> => read("projectEntries.inArea", { projectId, area });
+export const countActivePinnedEntriesInAreaAsync = (projectId: string, area: string): Promise<number> => read("projectEntries.countPinnedInArea", { projectId, area });
+
+export const writeProjectEntryAsync = (input: Parameters<typeof writeProjectEntry>[0], requestId: string = randomUUID()): Promise<ProjectEntry> =>
+  getGateway().write("projectEntries.write", input, { idempotencyKey: requestId }) as unknown as Promise<ProjectEntry>;
+export const retractProjectEntryAsync = (id: string): Promise<ProjectEntry | null> =>
+  getGateway().write("projectEntries.retract", { id }) as unknown as Promise<ProjectEntry | null>;
+export const promoteBlackboardEntryAsync = (input: Parameters<typeof promoteBlackboardEntry>[0], requestId: string = randomUUID()): Promise<ProjectEntry> =>
+  getGateway().write("projectEntries.promoteBlackboard", input, { idempotencyKey: requestId }) as unknown as Promise<ProjectEntry>;

package/src/db/project-entries-read-ops.ts

@@ -1,10 +1,14 @@
 // Project-entries reader operations (T4060 hub on-loop). The MCP memory/project
 // read tools ran these scans synchronously on the event loop — including the
 // temp-B-TREE display ORDER BY over cells whose rows are ~95% retracted.
-import { listProjectEntries, searchProjectEntries } from "./project-entries.ts";
+import { countActivePinnedEntriesInArea, getProjectEntry, getProjectEntryChain, listActiveEntriesInArea, listProjectEntries, searchProjectEntries } from "./project-entries.ts";
 import type { ProjectEntryKind, ProjectEntryStatus, ProjectEntrySearchOptions } from "../types";
 
 export const PROJECT_ENTRIES_READ_OPS = {
+  "projectEntries.get": (args: { id: string }) => getProjectEntry(args.id),
+  "projectEntries.chain": (args: { id: string }) => getProjectEntryChain(args.id),
+  "projectEntries.inArea": (args: { projectId: string; area: string }) => listActiveEntriesInArea(args.projectId, args.area),
+  "projectEntries.countPinnedInArea": (args: { projectId: string; area: string }) => countActivePinnedEntriesInArea(args.projectId, args.area),
   "projectEntries.list": (args: {
     projectId: string;
     kind?: ProjectEntryKind;

package/src/db/project-entries-write-ops.ts

@@ -0,0 +1,8 @@
+import { promoteBlackboardEntry, retractProjectEntry, writeProjectEntry } from "./project-entries";
+import type { WriterOpSpec } from "./write-ops";
+
+export const PROJECT_ENTRIES_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = {
+  "projectEntries.write": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof writeProjectEntry>[0], ctx) => writeProjectEntry(args, ctx.now) },
+  "projectEntries.retract": { offLoop: true, idempotent: true, fn: (args: { id: string }, ctx) => retractProjectEntry(args.id, ctx.now) },
+  "projectEntries.promoteBlackboard": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof promoteBlackboardEntry>[0], ctx) => promoteBlackboardEntry(args, ctx.now) },
+};

package/src/db/project-entries.ts

@@ -1,7 +1,7 @@
 import { isolateMemoryEntry } from "../memory-entry-safety";
 import { validateProjectEntryText } from "../validation";
 import { randomUUID } from "node:crypto";
-import { getDb, writeTransaction, ValidationError } from "./connection.ts";
+import { getDb, inWriteTransaction, ValidationError } from "./connection.ts";
 import { getEntry as getBlackboardEntry, listEntries as listBlackboardEntries } from "./blackboard.ts";
 import { parseJson } from "../utils";
 import {
@@ -211,7 +211,7 @@ function assertProjectKnowledge(projectId: string): void {
   }
 }
 
-export function writeProjectEntry(input: WriteProjectEntryInput): ProjectEntry {
+export function writeProjectEntry(input: WriteProjectEntryInput, now: number = Date.now()): ProjectEntry {
   validateProjectEntryText(input);
   assertProjectKnowledge(input.projectId);
   assertKind(input.kind);
@@ -234,8 +234,7 @@ export function writeProjectEntry(input: WriteProjectEntryInput): ProjectEntry {
     supersedes = latestEntryByTitle(input.projectId, input.kind, input.title)?.id;
   }
   const id = projectEntryId();
-  const now = Date.now();
-  writeTransaction(() => {
+  inWriteTransaction(() => {
     let inheritedAreas: string[] | null = null;
     if (supersedes) {
       const previous = getProjectEntry(supersedes);
@@ -404,21 +403,25 @@ export function countActivePinnedEntriesInArea(projectId: string, area: string):
 }
 
 /** #3410 — active entries of one cell that name `area`, newest first. Same index as the count above. */
-export function listActiveEntriesInArea(projectId: string, area: string): ProjectEntry[] {
-  const rows = getDb().query(`
+export function buildActiveEntriesInAreaQuery(projectId: string, area: string): { sql: string; params: string[] } {
+  return { sql: `
     SELECT * FROM project_entries
     WHERE project_id = ? AND status = 'active' AND areas LIKE ? ESCAPE '\\'
     ORDER BY updated_at DESC, created_at DESC, id DESC
-  `).all(projectId, `%${escapeLike(JSON.stringify(area))}%`) as ProjectEntryRow[];
-  return rows.map(rowToEntry);
+  `, params: [projectId, `%${escapeLike(JSON.stringify(area))}%`] };
 }
 
-export function retractProjectEntry(id: string): ProjectEntry | null {
+export function listActiveEntriesInArea(projectId: string, area: string): ProjectEntry[] {
+  const { sql, params } = buildActiveEntriesInAreaQuery(projectId, area);
+  return (getDb().query(sql).all(...params) as ProjectEntryRow[]).map(rowToEntry);
+}
+
+export function retractProjectEntry(id: string, now: number = Date.now()): ProjectEntry | null {
   const existing = getProjectEntry(id);
   if (!existing) return null;
   assertStatus("retracted");
   getDb().query("UPDATE project_entries SET status = 'retracted', updated_at = ? WHERE id = ?")
-    .run(Date.now(), id);
+    .run(now, id);
   return getProjectEntry(id);
 }
 
@@ -472,7 +475,7 @@ function activePromotedEntry(projectId: string, originRef: string): ProjectEntry
  * project supersedes the prior promoted copy rather than duplicating it, so the durable
  * ledger holds at most one active entry per promoted finding while keeping the full
  * supersede chain for audit. */
-export function promoteBlackboardEntry(input: PromoteBlackboardEntryInput): ProjectEntry {
+export function promoteBlackboardEntry(input: PromoteBlackboardEntryInput, now: number = Date.now()): ProjectEntry {
   const source = getBlackboardEntry(input.blackboardEntryId);
   if (!source) throw new ValidationError(`blackboard entry ${input.blackboardEntryId} not found`);
   if (source.status !== "active") {
@@ -489,7 +492,7 @@ export function promoteBlackboardEntry(input: PromoteBlackboardEntryInput): Proj
     source: "promoted",
     originRef: source.id,
     ...(existing ? { supersedes: existing.id } : {}),
-  });
+  }, now);
 }
 
 export interface UnpromotedBlackboardSummary {

package/src/db/project-journal.ts

@@ -203,7 +203,7 @@ export function setProjectJournalFields(input: {
   fields: Record<string, string | null>;
   changedBy: string;
   now?: number;
-}): ProjectJournalFieldChange[] {
+}, submittedAt: number = Date.now()): ProjectJournalFieldChange[] {
   const entries = Object.entries(input.fields);
   if (!entries.length) throw new ValidationError("fields must name at least one journal field");
   const plan: Array<{ field: ProjectJournalField; value: string | null; previous: string | null }> = [];
@@ -222,7 +222,7 @@ export function setProjectJournalFields(input: {
     plan.push({ field, value: value === "" ? null : value, previous });
   }
 
-  const now = input.now ?? Date.now();
+  const now = input.now ?? submittedAt;
   const changes: ProjectJournalFieldChange[] = [];
   writeTransaction(() => {
     for (const { field, value, previous } of plan) {

package/src/db/project-trust-approvals.ts

@@ -68,9 +68,9 @@ export interface UpsertProjectTrustApprovalInput {
 /** Records `approvedValue` as the trusted content for this (profile, repo, capability), replacing
  * any prior approval — used both by the operator-triggered dashboard approve action and by the
  * gate's own grandfather-on-first-encounter path (decision #4). */
-export function upsertProjectTrustApproval(input: UpsertProjectTrustApprovalInput): ProjectTrustApproval {
+export function upsertProjectTrustApproval(input: UpsertProjectTrustApprovalInput, submittedAt: number = Date.now()): ProjectTrustApproval {
   return writeTransaction(() => {
-    const now = Date.now();
+    const now = submittedAt;
     const existing = getDb().query(`
       SELECT id FROM project_trust_approvals WHERE profile_name = ? AND repo_key = ? AND capability = ?
     `).get(input.profileName, input.repoKey, input.capability) as { id: string } | null;

package/src/db/prompt-templates.ts

@@ -74,8 +74,8 @@ export function listTemplates(category?: string): PromptTemplateRecord[] {
   return templates;
 }
 
-export function upsertTemplate(slug: string, template: string): void {
-  const now = Date.now();
+export function upsertTemplate(slug: string, template: string, submittedAt: number = Date.now()): void {
+  const now = submittedAt;
   if (versionedPromptSlot(slug)) {
     throw new ValidationError("Use the versioned prompt writer with expectedVersion and actor");
   }
@@ -83,11 +83,11 @@ export function upsertTemplate(slug: string, template: string): void {
   if ((result.changes ?? 0) === 0) throw new ValidationError(`prompt template ${slug} not found`);
 }
 
-export function resetTemplate(slug: string): void {
+export function resetTemplate(slug: string, submittedAt: number = Date.now()): void {
   if (versionedPromptSlot(slug)) {
     throw new ValidationError("Use the versioned prompt writer with expectedVersion and actor");
   }
-  const now = Date.now();
+  const now = submittedAt;
   const result = getDb().query("UPDATE prompt_templates SET template = default_template, updated_at = ? WHERE slug = ?").run(now, slug);
   if ((result.changes ?? 0) === 0) throw new ValidationError(`prompt template ${slug} not found`);
 }