@agentpulselabs/cli-plugin-pulse 1.1.2 → 1.1.5

package/src/runner/capture.js

@@ -1,3 +1,4 @@
+import { setTimeout as sleep } from 'node:timers/promises';
 import { withTx } from '../hub/core/db.mjs';
 
 /**
@@ -18,6 +19,17 @@ const SCHEMA = [
   'CREATE TABLE IF NOT EXISTS pulse_capture (id INTEGER PRIMARY KEY AUTOINCREMENT, tbl TEXT NOT NULL, op TEXT NOT NULL, k1 TEXT NOT NULL, k2 TEXT)',
 ];
 
+/** One chunk of swept or pumped work holds the write lock and the event loop about this long, then yields. */
+export const CHUNK_MS = 50;
+/**
+ * Between chunks the lock is left free this long (writeInChunks' pause, without blocking the loop); longer while
+ * another connection is writing (it committed since the last pause), because its busy handler sleeps up to 100 ms
+ * between tries and would otherwise rarely land in a short gap.
+ */
+export const CHUNK_PAUSE_MS = 15;
+export const WRITER_PAUSE_MS = 120;
+const JOURNAL_PAGE = 200;
+
 function triggerSql({ table, keys, ops }) {
   return ops.map((op) => {
     const row = op === 'DELETE' ? 'OLD' : 'NEW';
@@ -37,30 +49,40 @@ export function installCapture(db) {
  * Turns every captured hub write into outbox commands inside the transaction that made it.
  *
  * `tx(fn, { guard })` runs fn in one write transaction (the ported core's own withTx calls join it), drains the trigger
- * journal through `mapping.commands(change, db)` into the outbox, then runs `guard`; a guard that throws rolls the
+ * rows fn added through `mapping.commands(change, db)` into the outbox, then runs `guard`; a guard that throws rolls the
  * hub write and its commands back together. `applying(fn)` writes with the triggers off, for rows that came from the
  * cloud: other connections never see the flag set, because SQLite serializes writers and the flag is set and reset
- * inside one write transaction. `pump()` drains what writes outside any `tx` left in the journal.
+ * inside one write transaction. `pump({ budgetMs })` drains what writes on other connections (the collect worker) left
+ * in the journal, oldest first, for at most budgetMs per transaction. `chunks(steps)` runs steps in capture
+ * transactions of about CHUNK_MS each, leaving the event loop and the lock free between them (`yieldLock`).
  */
 export function createCapture({ db, store, mapping, log = () => {} }) {
-  const journal = db.prepare('SELECT id, tbl, op, k1, k2 FROM pulse_capture ORDER BY id');
-  const clear = db.prepare('DELETE FROM pulse_capture WHERE id <= ?');
+  const journal = db.prepare('SELECT id, tbl, op, k1, k2 FROM pulse_capture WHERE id > ? ORDER BY id LIMIT ?');
+  const newest = db.prepare('SELECT COALESCE(MAX(id), 0) AS id FROM pulse_capture');
+  const waiting = db.prepare('SELECT EXISTS (SELECT 1 FROM pulse_capture) AS found');
+  const clear = db.prepare('DELETE FROM pulse_capture WHERE id > ? AND id <= ?');
   const setApplying = db.prepare('UPDATE pulse_ctx SET applying = ? WHERE one = 1');
+  const dataVersion = db.prepare('PRAGMA data_version');
+  let lastVersion = null;
+  const batchOf = () => (mapping.batch ? mapping.batch(db) : (change) => mapping.commands(change, db));
 
-  function drain() {
-    const rows = journal.all();
-    if (!rows.length) return 0;
-    const latest = new Map();
-    for (const row of rows) {
-      const id = `${row.tbl}\0${row.k1}\0${row.k2 ?? ''}`;
-      latest.delete(id);
-      latest.set(id, row);
-    }
+  const entityOf = (row) => `${row.tbl}\0${row.k1}\0${row.k2 ?? ''}`;
+
+  /**
+   * Commands for one page of journal rows, each entity once at its latest row in the page, in row order. Stops after
+   * the row at which `over()` turns true; returns the id of the last row it is done with and what it queued. Rows
+   * before that whose entity comes again later in the page are left to that later row.
+   */
+  function drainPage(rows, commands, over) {
+    const lastAt = new Map(rows.map((row, index) => [entityOf(row), index]));
     const entries = [];
-    for (const { tbl, op, k1, k2 } of latest.values()) {
+    let done = rows.length - 1;
+    for (const [index, row] of rows.entries()) {
+      if (lastAt.get(entityOf(row)) !== index) continue;
+      const { tbl, op, k1, k2 } = row;
       const change = { tbl, op, k1, k2 };
       try {
-        entries.push(...mapping.commands(change, db));
+        entries.push(...commands(change));
       } catch (error) {
         // A full outbox refuses the write itself (507 pulse_backlog), so the caller is told.
         if (error.code === 'pulse_backlog') throw error;
@@ -71,16 +93,36 @@ export function createCapture({ db, store, mapping, log = () => {} }) {
         );
         log('capture_failed', { tbl, op, code: error?.code || 'capture_failed' });
       }
+      if (index < rows.length - 1 && over()) { done = index; break; }
     }
     if (entries.length) store.enqueue(entries);
-    clear.run(rows.at(-1).id);
-    return entries.length;
+    return { last: rows[done].id, queued: entries.length, all: done === rows.length - 1 };
+  }
+
+  /** Drains journal rows after `after`, a page at a time, until none are left or `budgetMs` has passed. */
+  function drain({ after = 0, budgetMs = Infinity } = {}) {
+    const started = performance.now();
+    const over = () => performance.now() - started >= budgetMs;
+    const commands = batchOf();
+    let last = after;
+    let queued = 0;
+    for (;;) {
+      const rows = journal.all(last, JOURNAL_PAGE);
+      if (!rows.length) break;
+      const page = drainPage(rows, commands, over);
+      queued += page.queued;
+      last = page.last;
+      if (!page.all || rows.length < JOURNAL_PAGE || over()) break;
+    }
+    if (last > after) clear.run(after, last);
+    return queued;
   }
 
   function tx(fn, { guard = null, label = 'capture' } = {}) {
     return withTx(db, () => {
+      const mark = newest.get().id;
       const out = fn();
-      drain();
+      drain({ after: mark });
       if (guard) guard();
       return out;
     }, label);
@@ -97,7 +139,28 @@ export function createCapture({ db, store, mapping, log = () => {} }) {
     }, 'apply');
   }
 
-  const pump = () => withTx(db, drain, 'capture pump');
+  const pump = ({ budgetMs = Infinity } = {}) => withTx(db, () => drain({ budgetMs }), 'capture pump');
+  const pending = () => Boolean(waiting.get().found);
+  const yieldLock = () => {
+    const version = dataVersion.get().data_version;
+    const writing = lastVersion !== null && version !== lastVersion;
+    lastVersion = version;
+    return sleep(writing ? WRITER_PAUSE_MS : CHUNK_PAUSE_MS);
+  };
+
+  async function chunks(steps, { budgetMs = CHUNK_MS, label = 'capture chunk' } = {}) {
+    let i = 0;
+    let n = 0;
+    while (i < steps.length) {
+      const started = performance.now();
+      n += 1;
+      tx(() => {
+        do steps[i++](); while (i < steps.length && performance.now() - started < budgetMs);
+      }, { label: `${label} (chunk ${n})` });
+      if (i < steps.length) await yieldLock();
+    }
+    return n;
+  }
 
-  return { tx, applying, pump, drain };
+  return { tx, applying, pump, pending, chunks, yieldLock, drain };
 }

package/src/runner/channelDiscipline.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { channelFiles, normRole, parsePosts } from '../hub/lib/channels.mjs';
 import { isTerminal } from '../hub/lib/closure.mjs';
+import { channelFilesAsync, readPostsAsync } from './channelWalk.js';
 
 /**
  * Pulse 1.1.2: the delivery-discipline rules as checks in the runner, from the Cursor hook and a sweep.
@@ -129,6 +130,9 @@ function readPosts(file) {
   } catch { return null; } finally { if (fd !== undefined) fs.closeSync(fd); }
 }
 
+/** What E3 needs of a channel: its newest post, how many posts it has and its mtime; null when it can't be read. */
+const staleState = (read) => (read ? { last: read.posts[read.posts.length - 1] || null, count: read.posts.length, mtime: read.mtime } : null);
+
 const keyOf = (file) => {
   const m = file.match(new RegExp(`(?:^|/)(${NAME})/\\.agents/(${NAME})/channel\\.md$`));
   return m ? `${m[1]}/${m[2]}` : null;
@@ -352,49 +356,79 @@ export function createChannelDiscipline(hub, {
   }
 
   /** E3's owner of a channel's newest post: the session that wrote it, else the agent of that stream and role, else its architect. */
-  function ownerOf(key, last) {
+  function ownerOf(key, last, directory) {
     const wrote = q.author.get(key, last.role, last.head);
     if (wrote) return wrote.session;
-    const dir = registry.directory();
+    const dir = directory();
     const crew = dir.filter((a) => a.streamKey === key && normRole(a.role) === last.role).sort((a, b) => (b.seenAt || 0) - (a.seenAt || 0));
     if (crew.length) return crew[0].id;
     const arch = dir.find((a) => a.isArchitect && (a.streams || []).includes(key));
     return last.role === 'ARCHITECT' && arch ? arch.id : null;
   }
 
-  function architectOf(key, owner) {
-    const dir = registry.directory();
+  function architectOf(key, owner, directory) {
+    const dir = directory();
     const a = owner ? dir.find((d) => d.id === owner) : null;
     if (a && a.deliveryId) return a.deliveryId;
     const arch = dir.find((d) => d.isArchitect && (d.streams || []).includes(key));
     return arch ? arch.deliveryId || arch.id : null;
   }
 
+  /** E3's view of every channel written in the last STALE_WATCH_MS, read now: `[{ key, file, state }]`. */
+  const channelStates = (now) => channelFiles(channelRoots, now - STALE_WATCH_MS).map((c) => ({ key: c.key, file: c.file, state: staleState(readPosts(c.file)) }));
+
+  /** What `scan` last read of each channel, by its mtime and size: an unchanged file is not read again. */
+  const marks = new Map();
+
+  /**
+   * The same view as the sweep's own read, without blocking the event loop or holding a transaction: the walk and the
+   * reads are asynchronous, and only channels whose mtime or size moved since the last scan are read and parsed.
+   */
+  async function scan(now = clock()) {
+    const out = [];
+    const live = new Set();
+    for (const c of await channelFilesAsync(channelRoots, now - STALE_WATCH_MS)) {
+      live.add(c.file);
+      const mark = marks.get(c.file);
+      let state = mark && mark.mtime === c.mtime && mark.size === c.size ? mark.state : undefined;
+      if (state === undefined) {
+        state = staleState(await readPostsAsync(c.file, CHANNEL_MAX_BYTES));
+        if (state) marks.set(c.file, { mtime: c.mtime, size: c.size, state });
+        else marks.delete(c.file);
+      }
+      out.push({ key: c.key, file: c.file, state });
+    }
+    for (const file of marks.keys()) if (!live.has(file)) marks.delete(file);
+    return out;
+  }
+
   /**
    * E3, from the lease holder's sweep: each channel written in the last STALE_WATCH_MS whose newest post is not
    * terminal. Its age counts from when this runner first saw that post (never before the runner started), not from
-   * the header, whose zone and date are unknown. Returns the messages it sent.
+   * the header, whose zone and date are unknown. `seen` is a `scan` taken before the sweep's transaction; without it
+   * the channels are read here. Returns the messages it sent.
    */
-  function sweep(now = clock()) {
+  function sweep({ now = clock(), seen = null } = {}) {
     const sent = [];
     const live = new Set();
-    for (const c of channelFiles(channelRoots, now - STALE_WATCH_MS)) {
-      const read = readPosts(c.file);
-      const last = read && read.posts[read.posts.length - 1];
+    let dir = null;
+    const directory = () => (dir ??= registry.directory());
+    for (const c of seen ?? channelStates(now)) {
+      const last = c.state?.last;
       if (!last) continue;
       live.add(c.key);
       if (isTerminal(last)) { q.staleDrop.run(c.key); continue; }
-      const sig = `${last.role}\0${last.head}\0${read.posts.length}`;
+      const sig = `${last.role}\0${last.head}\0${c.state.count}`;
       let row = q.stale.get(c.key);
       if (!row || row.sig !== sig) {
-        q.staleSet.run(c.key, c.file, sig, Math.max(started, Math.min(now, read.mtime)));
+        q.staleSet.run(c.key, c.file, sig, Math.max(started, Math.min(now, c.state.mtime)));
         row = q.stale.get(c.key);
       }
       const age = now - row.first_seen;
       const quiet = `${Math.floor(age / 60e3)} min`;
       const lastLine = `\`## [${last.role}] … ${last.head.slice(0, 120)}\``;
       if (age >= staleAskMs && !row.asked_at) {
-        const owner = ownerOf(c.key, last);
+        const owner = ownerOf(c.key, last, directory);
         q.staleAsked.run(now, owner, c.key);
         row.owner = owner;
         if (owner) {
@@ -410,7 +444,7 @@ export function createChannelDiscipline(hub, {
       if (age >= staleEscalateMs && !row.escalated_at) {
         q.staleEscalated.run(now, c.key);
         const body = `\`${c.key}\` has had no post for ${quiet}; its last post ${lastLine} is not terminal.${row.owner ? ` STATUS? went to \`${row.owner}\` with no post since.` : ' Pulse found no owner to ask.'}`;
-        const architect = architectOf(c.key, row.owner);
+        const architect = architectOf(c.key, row.owner, directory);
         for (const topic of [...(architect && architect !== row.owner ? [`delivery/${architect}`] : []), 'user']) {
           const env = publish({ from: 'manager', fromName: 'Pulse', topic, type: 'STALE', body, meta: { stale: c.key } });
           if (env && !env.error) sent.push({ key: c.key, to: topic, type: 'STALE' });
@@ -421,5 +455,5 @@ export function createChannelDiscipline(hub, {
     return sent;
   }
 
-  return { onHook, sweep };
+  return { onHook, scan, sweep };
 }

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')