perf: cheaper ingest — no re-parse of live hooked transcripts, delta hook writes, lighter pollers

- Session sync leaves a transcript alone while hooks feed its session live
  (active, newest event a hook's, touched within DASHBOARD_SYNC_LIVE_HOOK_MS,
  default 5 min) and catches it up once quiet; a hook-created session (which
  importSession skips anyway) is only snapshotted, never parsed.
- Hook writer keeps a per-transcript mark (applied after commit): an
  unchanged TranscriptCache result skips token/compaction/API-error/turn
  writes, a grown one walks only the entries after the last one handled.
- Codex usage: one stamp query per pass instead of one row per journal;
  between full passes (first + every 5 min) only the newest day folders and
  journals written in the last hour are statted; fork parents resolved from
  the table or a full walk.
- Cursor/Antigravity polls back off to 60 s after idle passes
  (server/lib/backoff-poll.js); lane sync runs only while another dashboard
  shares the data dir (checked every 30 s).

server/lib/cursor-usage.js

@@ -182,14 +182,7 @@ function writeSession(f, now) {
   const endedAt = active ? null : lastWrite;
   const name = firstPrompt(f.path) || existing?.name || `Cursor ${f.id.slice(0, 8)}`;
   if (existing) {
-    updateSession.run(
-      name,
-      status,
-      endedAt,
-      lastWrite,
-      cwd,
-      f.id
-    );
+    updateSession.run(name, status, endedAt, lastWrite, cwd, f.id);
     return "session_updated";
   }
   insertSession.run(
@@ -206,6 +199,9 @@ function writeSession(f, now) {
 }
 
 let running = null;
+// Fresh sessions the last pass left for a later one to settle (the poll keeps
+// its base pace while there are any).
+let lastPending = 0;
 
 /**
  * One pass over every transcript: a changed one is re-read, an unchanged one
@@ -217,11 +213,15 @@ function ingestCursorUsage({ broadcast = () => {}, now = Date.now() } = {}) {
   running = (async () => {
     let read = 0;
     let written = 0;
+    let pending = 0; // still-fresh sessions a later pass may have to settle
     for (const f of transcriptFiles()) {
       try {
         const seen = getSeen.get(f.path);
         if (seen && seen.mtime_ms === f.mtime) {
-          if (fresh(f.mtime, now)) continue;
+          if (fresh(f.mtime, now)) {
+            pending += 1;
+            continue;
+          }
           const s = stmts.getSession.get(f.id);
           if (s && s.tool === "cursor" && s.status === "active") {
             settle.run(new Date(f.mtime).toISOString(), s.id);
@@ -242,6 +242,7 @@ function ingestCursorUsage({ broadcast = () => {}, now = Date.now() } = {}) {
       }
       await new Promise((r) => setImmediate(r));
     }
+    lastPending = pending;
     return { files: read, sessions: written };
   })().finally(() => {
     running = null;
@@ -249,18 +250,21 @@ function ingestCursorUsage({ broadcast = () => {}, now = Date.now() } = {}) {
   return running;
 }
 
-/** First pass at once (in the background), then every DASHBOARD_CURSOR_POLL_MS (default 15 s; 0 disables). */
+/**
+ * First pass at once (in the background), then every DASHBOARD_CURSOR_POLL_MS
+ * (default 15 s; 0 disables) — slowed to once a minute after a pass that read
+ * nothing, wrote nothing and left no fresh session to settle, and back to the
+ * base pace as soon as one finds work.
+ */
 function startCursorUsagePoll(broadcast) {
   const POLL_MS = process.env.DASHBOARD_CURSOR_POLL_MS
     ? Number(process.env.DASHBOARD_CURSOR_POLL_MS)
     : 15_000;
   if (!Number.isFinite(POLL_MS) || POLL_MS <= 0) return;
-  const tick = () => {
-    ingestCursorUsage({ broadcast }).catch(() => {});
-  };
-  tick();
-  const timer = setInterval(tick, POLL_MS);
-  if (timer.unref) timer.unref();
+  require("./backoff-poll").startBackoffPoll(
+    () => ingestCursorUsage({ broadcast }).then((r) => r.files + r.sessions + lastPending > 0),
+    { baseMs: POLL_MS }
+  );
 }
 
 module.exports = {