@agentpulselabs/cli-plugin-pulse 1.1.3 → 1.1.5

package/src/runner/channelWalk.js

@@ -0,0 +1,42 @@
+import { constants } from 'node:fs';
+import { open, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { parsePosts } from '../hub/lib/channels.mjs';
+
+/**
+ * hub/lib/channels.mjs `channelFiles` without blocking the event loop: every roots/<repo>/.agents/<task>/channel.md
+ * changed since sinceMs, in the same order, with its size as well, so a caller can tell an unchanged file by its
+ * mtime and size without reading it.
+ */
+export async function channelFilesAsync(roots, sinceMs) {
+  const out = [];
+  for (const root of roots) {
+    let repos = [];
+    try { repos = await readdir(root); } catch { continue; }
+    for (const repo of repos) {
+      const dir = path.join(root, repo, '.agents');
+      let tasks = [];
+      try { tasks = await readdir(dir); } catch { continue; }
+      const found = await Promise.all(tasks.map(async (task) => {
+        const file = path.join(dir, task, 'channel.md');
+        try {
+          const st = await stat(file);
+          return st.isFile() && st.mtimeMs >= sinceMs ? { key: `${repo}/${task}`, task, repo, file, mtime: st.mtimeMs, size: st.size } : null;
+        } catch { return null; }
+      }));
+      out.push(...found.filter(Boolean));
+    }
+  }
+  return out;
+}
+
+/** A channel's posts, read without following a symlink: `{ posts, mtime }`, or null when it can't be read or is over maxBytes. */
+export async function readPostsAsync(file, maxBytes) {
+  let handle;
+  try {
+    handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+    const st = await handle.stat();
+    if (!st.isFile() || st.size > maxBytes) return null;
+    return { posts: parsePosts(await handle.readFile('utf8'), st.mtimeMs), mtime: st.mtimeMs };
+  } catch { return null; } finally { await handle?.close(); }
+}

package/src/runner/deliveryStates.js

@@ -134,18 +134,32 @@ export function createDeliveryStates(hub, bus, { now: clock = Date.now } = {}) {
    * waited BOUNCE_GRACE_MS for a recipient nobody can read: its sender gets one UNDELIVERABLE notice per recipient,
    * from the manager, with an id derived from the message and recipient. A notice is never itself bounced.
    */
-  function bounce(now = clock()) {
-    const rows = db.prepare(`SELECT d.message_id AS id, d.recipient, m.sender, m.type, m.body FROM deliveries d JOIN messages m ON m.id = d.message_id
+  const BOUNCE_FROM = `FROM deliveries d JOIN messages m ON m.id = d.message_id
       WHERE d.state = 'queued' AND m.expires_at > ? AND m.created_at <= ? AND m.created_at > ?
         AND m.sender <> 'manager' AND m.type <> 'UNDELIVERABLE' AND d.recipient NOT IN ('user', 'manager')
         AND NOT EXISTS (SELECT 1 FROM pulse_reported r WHERE r.message_id = m.id)
-        AND NOT EXISTS (SELECT 1 FROM pulse_bounced b WHERE b.message_id = d.message_id AND b.recipient = d.recipient)
-      ORDER BY m.created_at LIMIT ?`).all(now, now - BOUNCE_GRACE_MS, now - DEFAULT_TTL_MS, BOUNCE_BATCH);
+        AND NOT EXISTS (SELECT 1 FROM pulse_bounced b WHERE b.message_id = d.message_id AND b.recipient = d.recipient)`;
+  const bounceRows = db.prepare(`SELECT d.message_id AS id, d.recipient, m.sender, m.type, m.body ${BOUNCE_FROM} ORDER BY m.created_at LIMIT ?`);
+  const stillBounceable = db.prepare(`SELECT 1 AS found ${BOUNCE_FROM} AND d.message_id = ? AND d.recipient = ?`);
+  const bounceWindow = (now) => [now, now - BOUNCE_GRACE_MS, now - DEFAULT_TTL_MS];
+
+  function bounce(now = clock()) {
     const sent = [];
+    for (const step of bounceSteps({ now, sent })) step();
+    return sent;
+  }
+
+  /**
+   * The bounce as one step per candidate row, for capture's chunks: the candidates are read up front, and each step
+   * checks its row is still queued and not yet bounced or reported in the transaction it runs in. Pushes to `sent`.
+   */
+  function bounceSteps({ now = clock(), sent = [] } = {}) {
+    const rows = bounceRows.all(...bounceWindow(now), BOUNCE_BATCH);
     let dir = null;
-    for (const r of rows) {
+    return rows.map((r) => () => {
+      if (!stillBounceable.get(...bounceWindow(now), r.id, r.recipient)) return;
       const why = bus.reach(r.recipient, now);
-      if (why.state !== 'undeliverable') continue;
+      if (why.state !== 'undeliverable') return;
       dir ??= registry.directory(now);
       const id = edgeId('u', r.id, r.recipient);
       const reason = why.reason === 'stale' ? `its session ${why.session} has had no activity for ${why.idleMin} min`
@@ -157,8 +171,7 @@ export function createDeliveryStates(hub, bus, { now: clock = Date.now } = {}) {
       }, dir);
       q.bounced.run(r.id, r.recipient, env.error ? `error:${env.error}` : id, now);
       if (!env.error) sent.push({ id: r.id, to: r.recipient, notice: id });
-    }
-    return sent;
+    });
   }
 
   /**
@@ -216,5 +229,5 @@ export function createDeliveryStates(hub, bus, { now: clock = Date.now } = {}) {
     return [...open].filter(([, settled]) => settled).map(([id]) => id);
   }
 
-  return { readOnHook, managerFyi, reports, honest, withDelivery, status, senderOf, report, bounce, postedSince, settleNudges, settledNudgeRecipients };
+  return { readOnHook, managerFyi, reports, honest, withDelivery, status, senderOf, report, bounce, bounceSteps, postedSince, settleNudges, settledNudgeRecipients };
 }

package/src/runner/directoryCache.js

@@ -0,0 +1,34 @@
+import { ONLINE_MS } from '../hub/core/ids.mjs';
+
+const WATCHED = ['actors', 'presence'];
+
+/**
+ * `registry.directory(now)` for the runner's connection, built again only when it could come out different: after a
+ * write to actors or presence on this connection (temp triggers set a new random token, which a rollback puts back),
+ * after a commit on another connection (`PRAGMA data_version`), or once `now` crosses a presence's online edge
+ * (`last_seen + ONLINE_MS`), the only way the clock changes it. Callers share the array and must not change it.
+ */
+export function cachedDirectory(db, registry) {
+  db.prepare('CREATE TEMP TABLE IF NOT EXISTS pulse_directory_token (one INTEGER PRIMARY KEY CHECK (one = 1), token TEXT NOT NULL)').run();
+  db.prepare('INSERT OR IGNORE INTO temp.pulse_directory_token (one, token) VALUES (1, hex(randomblob(8)))').run();
+  for (const table of WATCHED) {
+    for (const op of ['INSERT', 'UPDATE', 'DELETE']) {
+      db.prepare(`CREATE TEMP TRIGGER IF NOT EXISTS pulse_directory_${table}_${op.toLowerCase()} AFTER ${op} ON main.${table}
+        BEGIN UPDATE temp.pulse_directory_token SET token = hex(randomblob(8)) WHERE one = 1; END`).run();
+    }
+  }
+  const token = db.prepare('SELECT token FROM temp.pulse_directory_token WHERE one = 1');
+  const version = db.prepare('PRAGMA data_version');
+  const lastEdge = db.prepare('SELECT MAX(last_seen) AS t FROM presence WHERE last_seen <= ?');
+  const nextEdge = db.prepare('SELECT MIN(last_seen) AS t FROM presence WHERE last_seen > ?');
+  let kept = null;
+  return (now = Date.now()) => {
+    const key = `${version.get().data_version}:${token.get().token}`;
+    if (kept && kept.key === key && now >= kept.from && now < kept.until) return kept.dir;
+    const dir = registry.directory(now);
+    const before = lastEdge.get(now - ONLINE_MS).t;
+    const after = nextEdge.get(now - ONLINE_MS).t;
+    kept = { key, dir, from: before == null ? -Infinity : before + ONLINE_MS, until: after == null ? Infinity : after + ONLINE_MS };
+    return dir;
+  };
+}

package/src/runner/facade.js

@@ -39,6 +39,8 @@ import { execFileBounded } from '../lib/subprocess.js';
 import { createBusIdentity, routedMessaging } from './busIdentity.js';
 import { createChannelDiscipline } from './channelDiscipline.js';
 import { createDeliveryStates } from './deliveryStates.js';
+import { UNMONITORED } from './loopMonitor.js';
+import { serial } from './serial.js';
 import { statusPage } from './statusPage.js';
 
 const WORKSPACE = path.resolve(HUB, '..');
@@ -133,6 +135,7 @@ export function plainCapture(db) {
     tx: (fn, { guard = null, label = 'write' } = {}) => withTx(db, () => { const out = fn(); if (guard) guard(); return out; }, label),
     applying: (fn) => fn(),
     pump: () => 0,
+    chunks: async (steps, { label = 'write' } = {}) => { withTx(db, () => { for (const step of steps) step(); }, label); return 1; },
   };
 }
 
@@ -292,13 +295,31 @@ const hasTable = (db, name) => Boolean(db.prepare("SELECT 1 AS found FROM sqlite
 /** Without a cloud lease (tests, a bare hub) this runner is the only one, as the local hub was. */
 const SOLE_LEASE = Object.freeze({ held: () => true, view: () => ({ holder: 'local', here: true }), onChange: () => {} });
 
+/**
+ * A lease that lapses here only while this process stalled (a long runner.db transaction holds the event loop) comes back
+ * as soon as the queued report is read. The manager pauses meanwhile and is stopped, killing its runs, only past this.
+ */
+export const MANAGER_STOP_GRACE_MS = 60e3;
+const MANAGER_LOG_MAX_BYTES = 1024 * 1024;
+
+/** state/manager.log: what the manager did wrong, with its time, also on stderr; one older file is kept. */
+export function managerLog(file, { echo = console.error } = {}) {
+  return (line) => {
+    echo(line);
+    try {
+      if ((fs.statSync(file, { throwIfNoEntry: false })?.size || 0) > MANAGER_LOG_MAX_BYTES) fs.renameSync(file, `${file}.1`);
+      fs.appendFileSync(file, `${new Date().toISOString()} ${line}\n`, { mode: 0o600 });
+    } catch { /* stderr has it */ }
+  };
+}
+
 export function serve({
   hub, capture = plainCapture(hub.db), port = 8890, listenHost = '127.0.0.1', stateDir = path.join(HUB, 'state'), dbFile = null,
   enableCollector = true, enableManager = true, collect = null, channelRoots = CHANNEL_ROOTS,
   transcriptsDir = path.join(os.homedir(), '.cursor', 'projects'), watchDir = watchRecursive, identity = null,
   lease = SOLE_LEASE, pulseUrl = null, health = () => ({ state: 'online' }), metrics = () => ({}), drivers = null,
   hookBudgetMs = HOOK_BUDGET_MS, writeBudgetMs = WRITE_BUDGET_MS, onWrite = () => {}, managerOptions = {}, workspaceRoot = WORKSPACE,
-  discipline: disciplineOptions = {},
+  discipline: disciplineOptions = {}, loop = UNMONITORED,
 } = {}) {
   const me = () => {
     const m = identity ? identity.current() : NOBODY;
@@ -320,8 +341,9 @@ export function serve({
     channelRoots, workspaceRoot, append: appendNoFollow, ...thresholds,
     publish: (message) => hub.messaging.publish(message, hub.registry.directory()),
   });
+  const logManager = managerOptions.log || managerLog(path.join(stateDir, 'manager.log'));
   const manager = enableManager
-    ? createManager({ hub, state: stateDir, onChange: () => graphs.clear(), held: () => lease.held(), fyi: (m) => delivery.managerFyi(m), ...managerOptions })
+    ? createManager({ hub, state: stateDir, onChange: () => graphs.clear(), held: () => lease.held(), fyi: (m) => delivery.managerFyi(m), ...managerOptions, log: logManager })
     : { start() {}, stop() {}, view() { return { state: 'offline', online: false, pending: 0 }; } };
   /** The manager's status, with the DONE and STATUS posts it has read (F2). */
   const managerView = () => ({ ...manager.view(), reports: delivery.reports() });
@@ -334,30 +356,65 @@ export function serve({
   }
   if (serverLease.error) console.error(`another hub server holds the lease (${serverLease.holder}); taking over`);
   const timers = [];
-  const every = (ms, fn) => { const t = setInterval(fn, ms); t.unref(); timers.push(t); };
+  const every = (ms, fn, name = 'timer') => { const t = setInterval(() => loop.tick(name, fn), ms); t.unref(); timers.push(t); };
   if (serverLease.token) {
-    every(10e3, () => { try { hub.leases.renew('server', serverLease.token, { ttlMs: 30e3 }); } catch (e) { console.error(`server lease renewal failed: ${e.message}`); } });
+    every(10e3, () => { try { hub.leases.renew('server', serverLease.token, { ttlMs: 30e3 }); } catch (e) { console.error(`server lease renewal failed: ${e.message}`); } }, 'server lease');
   }
   const releaseLease = () => { if (serverLease.token) { try { hub.leases.release('server', serverLease.token); } catch { /* closing */ } } };
   const wrote = () => { feed.dbWrite(); onWrite(); };
   /** The manager, the wake sweep and the scheduled nudge belong to the runner holding the user's manager lease (Q9). */
   const leaseHeld = () => lease.held();
+  const deliverySweep = serial(async () => {
+    try {
+      const settled = capture.tx(() => delivery.settleNudges(), { label: 'delivery sweep' });
+      const bounced = [];
+      await capture.chunks(delivery.bounceSteps({ sent: bounced }), { label: 'delivery bounce' });
+      if (settled + bounced.length) { caches.clear(); wrote(); }
+    } catch (e) { console.error(`delivery sweep failed: ${e.message}`); }
+  });
+  const staleSweep = serial(async () => {
+    try {
+      const seen = await discipline.scan();
+      if (leaseHeld() && capture.tx(() => discipline.sweep({ seen }).length, { label: 'stale sweep' })) { caches.clear(); wrote(); }
+    } catch (e) { console.error(`stale sweep failed: ${e.message}`); }
+  });
   if (enableManager) {
     if (leaseHeld()) manager.start();
-    lease.onChange((held) => { if (held) manager.start(); else manager.stop(); });
+    let lapsedAt = null;
+    let stopTimer = null;
+    lease.onChange((held) => {
+      const { fence } = lease.view();
+      if (held) {
+        clearTimeout(stopTimer);
+        stopTimer = null;
+        if (lapsedAt) {
+          logManager(`manager lease held again (fence ${fence})${fence !== lapsedAt.fence ? `; it moved from fence ${lapsedAt.fence}, so runs from before are stopped` : ''}`);
+          if (fence !== lapsedAt.fence) manager.stop();
+        }
+        lapsedAt = null;
+        manager.start();
+        return;
+      }
+      if (lapsedAt) return;
+      lapsedAt = { fence };
+      logManager(`manager lease lapsed here (fence ${fence}); runs in flight keep going, and are stopped if it is not back in ${MANAGER_STOP_GRACE_MS / 1000} s`);
+      stopTimer = setTimeout(() => {
+        stopTimer = null;
+        if (lease.held()) return;
+        logManager('manager lease still not held: the manager is stopped');
+        manager.stop();
+      }, MANAGER_STOP_GRACE_MS);
+      stopTimer.unref();
+    });
     every(60e3, () => {
       if (!leaseHeld()) return;
       try { if (capture.tx(() => sweepWakes(hub), { label: 'wake sweep' }).length) { caches.clear(); wrote(); } } catch (e) { console.error(`wake sweep failed: ${e.message}`); }
-      try {
-        if (capture.tx(() => delivery.settleNudges() + delivery.bounce().length, { label: 'delivery sweep' })) { caches.clear(); wrote(); }
-      } catch (e) { console.error(`delivery sweep failed: ${e.message}`); }
-    });
+      return deliverySweep();
+    }, 'wake and delivery sweep');
     every(disciplineSweepMs, () => {
       if (!leaseHeld()) return;
-      try {
-        if (capture.tx(() => discipline.sweep().length, { label: 'stale sweep' })) { caches.clear(); wrote(); }
-      } catch (e) { console.error(`stale sweep failed: ${e.message}`); }
-    });
+      return staleSweep();
+    }, 'stale sweep');
   }
   const runner = createRunner({ hub, drivers: drivers || defaultDrivers(), workspaceRoot: WORKSPACE, onChange: () => { graphs.clear(); wrote(); } });
   if (enableManager) runner.begin();
@@ -369,7 +426,7 @@ export function serve({
       });
       if (capture.tx(nudge, { label: 'scheduled nudge' })) { caches.clear(); wrote(); }
     } catch (e) { console.error(`scheduled nudge failed: ${e.message}`); }
-  });
+  }, 'scheduled nudge');
 
   const registeredAt = hasTable(hub.db, 'pulse_registered')
     ? hub.db.prepare('INSERT INTO pulse_registered (id, at) VALUES (?, ?) ON CONFLICT (id) DO UPDATE SET at = excluded.at')

package/src/runner/hubCapture.js

@@ -46,52 +46,89 @@ export function createHubCapture({ store, hubDir, roots, home, approvedRoots = [
     return { message: { ...message, meta: parse(message.meta) ?? {} }, to: snapshot.recipients([id]).get(id) || [] };
   }
 
-  return {
-    scan,
-    commands(change, db) {
-      const snapshot = new HubSnapshot(db);
-      const context = contextFor(db);
-      switch (change.tbl) {
-        case 'messages': {
-          if (change.op === 'delete') {
-            const recent = db.prepare('SELECT id, grp FROM recent_message WHERE id = ?').get(change.k1);
-            if (recent && !snapshot.messageExists(change.k1)) scan.messageGone(context, { id: recent.id, group: recent.grp });
-            return [];
-          }
-          const found = messageWithRecipients(snapshot, db, change.k1);
-          if (found) scan.messageRow(context, found.message, found.to);
-          return [];
-        }
-        case 'deliveries': {
-          if (change.op === 'delete') return [];
-          if (!store.known(change.k1)) {
-            const found = messageWithRecipients(snapshot, db, change.k1);
-            if (found) scan.messageRow(context, found.message, found.to);
-            return [];
-          }
-          const row = snapshot.receipt(change.k1, change.k2);
-          scan.receiptRow(context, { messageId: change.k1, recipient: change.k2, state: store.receiptState(change.k1, change.k2), row });
-          return [];
-        }
-        case 'actors': {
-          const row = db.prepare('SELECT * FROM actors WHERE id = ?').get(change.k1);
-          if (row) scan.actorRow(context, rowActor(row));
-          return [];
-        }
-        case 'facts': {
-          const row = db.prepare('SELECT kind, key, payload, updated_at FROM facts WHERE kind = ? AND key = ?').get(change.k1, change.k2);
-          if (row) scan.factRow(context, { ...row });
-          else if (REMOVABLE_KINDS.includes(change.k1)) scan.factRemoved(context, change.k1, change.k2);
+  const actorById = (db, id) => db.prepare('SELECT * FROM actors WHERE id = ?').get(id);
+  const factByKey = (db, kind, key) => db.prepare('SELECT kind, key, payload, updated_at FROM facts WHERE kind = ? AND key = ?').get(kind, key);
+
+  function commandsIn(snapshot, context, change, db) {
+    switch (change.tbl) {
+      case 'messages': {
+        if (change.op === 'delete') {
+          const recent = db.prepare('SELECT id, grp FROM recent_message WHERE id = ?').get(change.k1);
+          if (recent && !snapshot.messageExists(change.k1)) scan.messageGone(context, { id: recent.id, group: recent.grp });
           return [];
         }
-        case 'events': {
-          const event = db.prepare('SELECT id, at, kind, actor, payload FROM events WHERE id = ?').get(change.k1);
-          if (event) scan.eventRow(context, { ...event, payload: parse(event.payload) ?? {} });
+        const found = messageWithRecipients(snapshot, db, change.k1);
+        if (found) scan.messageRow(context, found.message, found.to);
+        return [];
+      }
+      case 'deliveries': {
+        if (change.op === 'delete') return [];
+        if (!store.known(change.k1)) {
+          const found = messageWithRecipients(snapshot, db, change.k1);
+          if (found) scan.messageRow(context, found.message, found.to);
           return [];
         }
-        default:
-          return [];
+        const row = snapshot.receipt(change.k1, change.k2);
+        scan.receiptRow(context, { messageId: change.k1, recipient: change.k2, state: store.receiptState(change.k1, change.k2), row });
+        return [];
+      }
+      case 'actors': {
+        const row = actorById(db, change.k1);
+        if (row) scan.actorRow(context, rowActor(row));
+        return [];
+      }
+      case 'facts': {
+        const row = factByKey(db, change.k1, change.k2);
+        if (row) scan.factRow(context, { ...row });
+        else if (REMOVABLE_KINDS.includes(change.k1)) scan.factRemoved(context, change.k1, change.k2);
+        return [];
+      }
+      case 'events': {
+        const event = db.prepare('SELECT id, at, kind, actor, payload FROM events WHERE id = ?').get(change.k1);
+        if (event) scan.eventRow(context, { ...event, payload: parse(event.payload) ?? {} });
+        return [];
       }
+      default:
+        return [];
+    }
+  }
+
+  /** The keys of every removable fact the hub still has, as the sweep's fact pass would count them present. */
+  function presentFacts(db) {
+    const present = new Map(REMOVABLE_KINDS.map((kind) => [kind, new Set()]));
+    const statement = db.prepare('SELECT key, payload FROM facts WHERE kind = ?');
+    for (const kind of REMOVABLE_KINDS.filter((k) => FACT_KINDS.includes(k))) {
+      for (const row of statement.all(kind)) {
+        const fact = parse(row.payload);
+        if (!fact) continue;
+        present.get(kind).add(row.key);
+        if (kind === 'delivery') for (const stream of fact.streams || []) present.get('stream').add(stream.key);
+      }
+    }
+    return present;
+  }
+
+  function removeDropped(context, db) {
+    const present = presentFacts(db);
+    for (const kind of REMOVABLE_KINDS) {
+      for (const entity of store.entities(`fact:${kind}:`)) {
+        const key = entity.slice(`fact:${kind}:`.length);
+        if (!present.get(kind).has(key)) scan.factRemoved(context, kind, key);
+      }
+    }
+  }
+
+  return {
+    scan,
+    commands(change, db) {
+      return commandsIn(new HubSnapshot(db), contextFor(db), change, db);
+    },
+
+    /** `commands` for one drained page of journal rows, which share one scan context. */
+    batch(db) {
+      const snapshot = new HubSnapshot(db);
+      let context = null;
+      return (change) => commandsIn(snapshot, (context ??= contextFor(db)), change, db);
     },
 
     /**
@@ -103,7 +140,7 @@ export function createHubCapture({ store, hubDir, roots, home, approvedRoots = [
       const context = contextFor(db);
       switch (change.tbl) {
         case 'actors': {
-          const row = db.prepare('SELECT * FROM actors WHERE id = ?').get(change.k1);
+          const row = actorById(db, change.k1);
           if (!row) return;
           const actor = rowActor(row);
           const entity = `actor:${actor.id}`;
@@ -116,7 +153,7 @@ export function createHubCapture({ store, hubDir, roots, home, approvedRoots = [
           return;
         }
         case 'facts': {
-          const row = db.prepare('SELECT kind, key, payload, updated_at FROM facts WHERE kind = ? AND key = ?').get(change.k1, change.k2);
+          const row = factByKey(db, change.k1, change.k2);
           const fact = row && parse(row.payload);
           if (!fact || !FACT_KINDS.includes(row.kind)) return;
           scan.factCommands(context, { ...row }, fact).forEach((item, index) => {
@@ -141,20 +178,32 @@ export function createHubCapture({ store, hubDir, roots, home, approvedRoots = [
       const snapshot = new HubSnapshot(db);
       const context = contextFor(db);
       for (const actor of snapshot.actors()) scan.actorRow(context, actor);
-      const present = new Map(REMOVABLE_KINDS.map((kind) => [kind, new Set()]));
-      for (const row of snapshot.facts(ALL_FACT_KINDS)) {
-        const fact = scan.factRow(context, row);
-        if (!fact) continue;
-        present.get(row.kind)?.add(row.key);
-        if (row.kind === 'delivery') for (const stream of fact.streams || []) present.get('stream').add(stream.key);
-      }
-      for (const kind of REMOVABLE_KINDS) {
-        for (const entity of store.entities(`fact:${kind}:`)) {
-          const key = entity.slice(`fact:${kind}:`.length);
-          if (!present.get(kind).has(key)) scan.factRemoved(context, kind, key);
-        }
-      }
+      for (const row of snapshot.facts(ALL_FACT_KINDS)) scan.factRow(context, row);
+      removeDropped(context, db);
       return context.report;
     },
+
+    /**
+     * The sweep as steps for capture's chunks, in the sweep's own order: each actor and fact read again when its step
+     * runs (a row written between chunks is swept as it is then), and the removed facts last, from the keys the hub
+     * holds at that moment, so a fact added mid-sweep is never taken for a removed one.
+     */
+    sweepSteps(db) {
+      let context = null;
+      const current = () => (context ??= contextFor(db));
+      const ids = db.prepare('SELECT id FROM actors ORDER BY rowid').all().map((row) => row.id);
+      const facts = new HubSnapshot(db).factKeys(ALL_FACT_KINDS);
+      return [
+        ...ids.map((id) => () => {
+          const row = actorById(db, id);
+          if (row) scan.actorRow(current(), rowActor(row));
+        }),
+        ...facts.map(({ kind, key }) => () => {
+          const row = factByKey(db, kind, key);
+          if (row) scan.factRow(current(), { ...row });
+        }),
+        () => removeDropped(current(), db),
+      ];
+    },
   };
 }

package/src/runner/loopMonitor.js

@@ -0,0 +1,89 @@
+import { monitorEventLoopDelay } from 'node:perf_hooks';
+
+/** The window `runner.loopDelay` in daemon-health.json covers, in one-minute histograms. */
+export const LOOP_WINDOW_MS = 5 * 60e3;
+/** A tick that holds the event loop this long is logged as `loop_stall`, with its name. */
+export const STALL_MS = 2_000;
+const MINUTE_MS = 60e3;
+const PROBE_MS = 100;
+const RESOLUTION_MS = 20;
+
+const ms = (ns) => Math.round(ns / 1e5) / 10;
+
+/**
+ * The runner's event-loop delay (perf_hooks.monitorEventLoopDelay), kept as one histogram per minute for the last five:
+ * `view()` gives the window's exact max, the worst minute's p99 and the median of the minutes' p50s (histograms of
+ * this kind can't be merged). `tick(name, fn)` runs a tick under its name: one whose synchronous part runs past
+ * stallMs is logged as `loop_stall` with that name, and any other stall the probe sees is logged with the name of the
+ * tick that started last.
+ */
+export function createLoopMonitor({ log, windowMs = LOOP_WINDOW_MS, stallMs = STALL_MS, now = () => performance.now() }) {
+  const minutes = [];
+  const open = () => {
+    const histogram = monitorEventLoopDelay({ resolution: RESOLUTION_MS });
+    histogram.enable();
+    return { at: now(), histogram };
+  };
+  let live = open();
+  let current = null;
+  let claimed = false;
+  let last = now();
+
+  const probe = setInterval(() => {
+    const at = now();
+    const gap = at - last - PROBE_MS;
+    last = at;
+    if (gap > stallMs && !claimed) log('loop_stall', { ms: Math.round(gap), tick: current?.name ?? 'untracked', ...(current ? { running: current.running } : {}) });
+    claimed = false;
+    if (at - live.at >= MINUTE_MS) {
+      live.histogram.disable();
+      minutes.push(live);
+      while (minutes.length && at - minutes[0].at >= windowMs) minutes.shift();
+      live = open();
+    }
+  }, PROBE_MS);
+  probe.unref();
+
+  function tick(name, fn) {
+    const entry = { name, running: true };
+    current = entry;
+    const started = now();
+    const settle = () => { entry.running = false; };
+    let out;
+    try {
+      out = fn();
+    } finally {
+      const held = now() - started;
+      if (held > stallMs) {
+        claimed = true;
+        log('loop_stall', { ms: Math.round(held), tick: name });
+      }
+    }
+    if (out && typeof out.then === 'function') out.then(settle, settle);
+    else settle();
+    return out;
+  }
+
+  function view() {
+    const all = [...minutes, live].filter((m) => m.histogram.count > 0);
+    if (!all.length) return { p50Ms: null, p99Ms: null, maxMs: null, windowMs, minutes: 0 };
+    const p50s = all.map((m) => m.histogram.percentile(50)).sort((a, b) => a - b);
+    return {
+      p50Ms: ms(p50s[Math.floor(p50s.length / 2)]),
+      p99Ms: ms(Math.max(...all.map((m) => m.histogram.percentile(99)))),
+      maxMs: ms(Math.max(...all.map((m) => m.histogram.max))),
+      windowMs,
+      minutes: all.length,
+    };
+  }
+
+  function close() {
+    clearInterval(probe);
+    live.histogram.disable();
+  }
+
+  return { tick, view, close };
+}
+
+/** For a facade served without a runner process (tests): ticks run as they are. */
+export const UNMONITORED = Object.freeze({ tick: (name, fn) => fn(), view: () => null, close() {} });

package/src/runner/runnerHub.js

@@ -4,6 +4,7 @@ import { openHub } from '../hub/core/hub.mjs';
 import { HubError } from '../lib/errors.js';
 import { OUTBOX_MAX_PENDING, RunnerStore, SEED_META } from '../lib/runnerStore.js';
 import { createCapture, installCapture } from './capture.js';
+import { cachedDirectory } from './directoryCache.js';
 import { installRunnerSchema } from './runnerSchema.js';
 
 /**
@@ -73,7 +74,8 @@ export async function openRunnerHub({ directory, stateDir, mapping, now = Date.n
   const init = await RunnerStore.open(directory, { now, maxPending });
   const { file } = init;
   init.close();
-  const hub = openHub(stateDir, file);
+  const opened = openHub(stateDir, file);
+  const hub = { ...opened, registry: { ...opened.registry, directory: cachedDirectory(opened.db, opened.registry) } };
   installCapture(hub.db);
   installRunnerSchema(hub.db);
   const store = new RunnerStore({ db: hub.db, file, now, maxPending });