hotsheet 0.18.1-beta.1 → 0.19.0-beta.1

package/dist/cli.js

@@ -15198,6 +15198,132 @@ var init_zod = __esm({
   }
 });
 
+// src/hashWorker.ts
+var hashWorker_exports = {};
+__export(hashWorker_exports, {
+  _resetHashWorkerForTests: () => _resetHashWorkerForTests,
+  hashFileInProcess: () => hashFileInProcess,
+  hashFileOffThread: () => hashFileOffThread,
+  terminateHashWorker: () => terminateHashWorker
+});
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+import { pipeline } from "stream/promises";
+import { Worker } from "worker_threads";
+function failWorker(err) {
+  for (const p of pending.values()) p.reject(err);
+  pending.clear();
+  if (worker !== null) {
+    const w = worker;
+    worker = null;
+    void w.terminate().catch(() => {
+    });
+  }
+  crashCount++;
+  if (crashCount >= MAX_WORKER_CRASHES) workerUnusable = true;
+}
+function ensureWorker() {
+  if (workerUnusable) return null;
+  if (worker !== null) return worker;
+  try {
+    const w = new Worker(WORKER_SOURCE, { eval: true });
+    w.on("message", (msg) => {
+      const p = pending.get(msg.id);
+      if (p === void 0) return;
+      pending.delete(msg.id);
+      if (msg.error !== void 0) p.reject(new Error(msg.error));
+      else p.resolve({ sha: msg.sha ?? "", size: msg.size ?? 0 });
+    });
+    w.on("error", (err) => {
+      failWorker(err);
+    });
+    w.on("exit", (code) => {
+      if (code !== 0) failWorker(new Error(`hash worker exited with code ${code.toString()}`));
+    });
+    w.unref();
+    worker = w;
+    return w;
+  } catch {
+    workerUnusable = true;
+    return null;
+  }
+}
+async function hashFileOffThread(path) {
+  const w = ensureWorker();
+  if (w === null) return hashFileInProcess(path);
+  return new Promise((resolve11, reject2) => {
+    const id = nextId++;
+    pending.set(id, { resolve: resolve11, reject: reject2 });
+    try {
+      w.postMessage({ id, path });
+    } catch (err) {
+      pending.delete(id);
+      reject2(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+}
+async function hashFileInProcess(path) {
+  const hash2 = createHash("sha256");
+  let size = 0;
+  await pipeline(
+    createReadStream(path),
+    async function* (source) {
+      for await (const chunk of source) {
+        size += chunk.length;
+        hash2.update(chunk);
+        yield chunk;
+      }
+    },
+    async function(source) {
+      for await (const _ of source) {
+      }
+    }
+  );
+  return { sha: hash2.digest("hex"), size };
+}
+async function terminateHashWorker() {
+  const w = worker;
+  worker = null;
+  pending.clear();
+  if (w !== null) {
+    try {
+      await w.terminate();
+    } catch {
+    }
+  }
+}
+function _resetHashWorkerForTests() {
+  void terminateHashWorker();
+  workerUnusable = false;
+  crashCount = 0;
+  pending.clear();
+}
+var WORKER_SOURCE, MAX_WORKER_CRASHES, worker, workerUnusable, crashCount, nextId, pending;
+var init_hashWorker = __esm({
+  "src/hashWorker.ts"() {
+    "use strict";
+    WORKER_SOURCE = `
+const { parentPort } = require('worker_threads');
+const { createHash } = require('crypto');
+const { createReadStream } = require('fs');
+parentPort.on('message', (msg) => {
+  const hash = createHash('sha256');
+  let size = 0;
+  const stream = createReadStream(msg.path);
+  stream.on('data', (chunk) => { size += chunk.length; hash.update(chunk); });
+  stream.on('end', () => parentPort.postMessage({ id: msg.id, sha: hash.digest('hex'), size: size }));
+  stream.on('error', (err) => parentPort.postMessage({ id: msg.id, error: (err && err.message) ? err.message : String(err) }));
+});
+`;
+    MAX_WORKER_CRASHES = 3;
+    worker = null;
+    workerUnusable = false;
+    crashCount = 0;
+    nextId = 1;
+    pending = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/attachmentBackup.ts
 var attachmentBackup_exports = {};
 __export(attachmentBackup_exports, {
@@ -15214,10 +15340,8 @@ __export(attachmentBackup_exports, {
   runAttachmentGc: () => runAttachmentGc,
   writeManifestAtomically: () => writeManifestAtomically
 });
-import { createHash } from "crypto";
 import {
   copyFileSync,
-  createReadStream,
   existsSync,
   mkdirSync,
   promises as fsp,
@@ -15227,7 +15351,6 @@ import {
   statSync
 } from "fs";
 import { join } from "path";
-import { pipeline } from "stream/promises";
 import { gunzipSync } from "zlib";
 function manifestSiblingFilename(tarballFilename) {
   if (!tarballFilename.endsWith(".tar.gz")) {
@@ -15236,24 +15359,7 @@ function manifestSiblingFilename(tarballFilename) {
   return `${tarballFilename.slice(0, -".tar.gz".length)}.attachments.json`;
 }
 async function hashFile(path) {
-  const hash2 = createHash("sha256");
-  let size = 0;
-  await pipeline(
-    createReadStream(path),
-    async function* (source) {
-      for await (const chunk of source) {
-        size += chunk.length;
-        hash2.update(chunk);
-        yield chunk;
-      }
-    },
-    // Sink: just consume the bytes; pipeline needs a writable end.
-    async function(source) {
-      for await (const _ of source) {
-      }
-    }
-  );
-  return { sha: hash2.digest("hex"), size };
+  return hashFileOffThread(path);
 }
 function attachmentBlobsDir(backupRoot) {
   return join(backupRoot, "attachments");
@@ -15400,6 +15506,7 @@ async function runAttachmentGc(backupRoot) {
   const manifestPaths = collectManifestPaths(backupRoot);
   const liveShas = /* @__PURE__ */ new Set();
   let parseFailure = false;
+  let scanned = 0;
   for (const p of manifestPaths) {
     const m = readManifest(p);
     if (m === null) {
@@ -15408,23 +15515,27 @@ async function runAttachmentGc(backupRoot) {
       break;
     }
     for (const e of m.entries) liveShas.add(e.sha);
+    if (++scanned % 25 === 0) await yieldToEventLoop();
   }
   if (parseFailure) {
     return { deleted: 0, bytesReclaimed: 0, scannedManifests: manifestPaths.length, skippedDueToParseFailure: true };
   }
   let deleted = 0;
   let bytesReclaimed = 0;
-  for (const name of readdirSync(blobsDir)) {
+  const blobNames = await fsp.readdir(blobsDir);
+  let iterated = 0;
+  for (const name of blobNames) {
+    if (++iterated % 500 === 0) await yieldToEventLoop();
     if (name.endsWith(".tmp")) continue;
     if (liveShas.has(name)) continue;
     const p = join(blobsDir, name);
     let size = 0;
     try {
-      size = statSync(p).size;
+      size = (await fsp.stat(p)).size;
     } catch {
     }
     try {
-      rmSync(p, { force: true });
+      await fsp.rm(p, { force: true });
       deleted++;
       bytesReclaimed += size;
     } catch (err) {
@@ -15634,6 +15745,7 @@ var init_attachmentBackup = __esm({
   "src/attachmentBackup.ts"() {
     "use strict";
     init_zod();
+    init_hashWorker();
     ATTACHMENT_MANIFEST_VERSION = 1;
     JsonCosaveAttachmentRowSchema = external_exports.object({
       id: external_exports.number(),
@@ -15681,10 +15793,16 @@ __export(fsyncWrap_exports, {
   fsyncDbDir: () => fsyncDbDir,
   fsyncDbDirAsync: () => fsyncDbDirAsync,
   fsyncDir: () => fsyncDir,
-  fsyncDirAsync: () => fsyncDirAsync
+  fsyncDirAsync: () => fsyncDirAsync,
+  isUnsupportedFsyncError: () => isUnsupportedFsyncError
 });
 import { closeSync, existsSync as existsSync2, fsyncSync, openSync, promises as fsp2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { join as join2 } from "path";
+function isUnsupportedFsyncError(err, platform2 = process.platform) {
+  if (platform2 !== "win32") return false;
+  const code = err?.code;
+  return code !== void 0 && WIN32_UNFLUSHABLE_CODES.has(code);
+}
 function fsyncDir(path, fsyncFn = fsyncSync) {
   if (!existsSync2(path)) return { filesFlushed: 0, errors: 0 };
   const counters = { filesFlushed: 0, errors: 0 };
@@ -15719,8 +15837,10 @@ function walkAndFsync(dir, counters, fsyncFn) {
         fsyncFn(fd);
         counters.filesFlushed++;
       } catch (err) {
-        console.error(`[fsyncWrap] fsync ${p} failed:`, err);
-        counters.errors++;
+        if (!isUnsupportedFsyncError(err)) {
+          console.error(`[fsyncWrap] fsync ${p} failed:`, err);
+          counters.errors++;
+        }
       } finally {
         if (fd !== null) {
           try {
@@ -15769,8 +15889,10 @@ async function walkAndFsyncAsync(dir, counters, fsyncFn) {
         await fsyncFn(handle);
         counters.filesFlushed++;
       } catch (err) {
-        console.error(`[fsyncWrap] fsync ${p} failed:`, err);
-        counters.errors++;
+        if (!isUnsupportedFsyncError(err)) {
+          console.error(`[fsyncWrap] fsync ${p} failed:`, err);
+          counters.errors++;
+        }
       } finally {
         if (handle !== null) {
           try {
@@ -15785,10 +15907,11 @@ async function walkAndFsyncAsync(dir, counters, fsyncFn) {
 async function fsyncDbDirAsync(dataDir, fsyncFn = defaultAsyncFsyncFn) {
   return fsyncDirAsync(join2(dataDir, "db"), fsyncFn);
 }
-var defaultAsyncFsyncFn;
+var WIN32_UNFLUSHABLE_CODES, defaultAsyncFsyncFn;
 var init_fsyncWrap = __esm({
   "src/db/fsyncWrap.ts"() {
     "use strict";
+    WIN32_UNFLUSHABLE_CODES = /* @__PURE__ */ new Set(["EPERM", "EACCES", "ENOTSUP", "EINVAL"]);
     defaultAsyncFsyncFn = (handle) => handle.sync();
   }
 });
@@ -15938,10 +16061,14 @@ __export(freezeLogger_exports, {
   FREEZE_LOG_MAX_BYTES: () => FREEZE_LOG_MAX_BYTES,
   FREEZE_LOG_TARGET_BYTES_AFTER_TRUNCATE: () => FREEZE_LOG_TARGET_BYTES_AFTER_TRUNCATE,
   LONG_TASK_THRESHOLD_MS: () => LONG_TASK_THRESHOLD_MS,
+  WAKE_GAP_THRESHOLD_MS: () => WAKE_GAP_THRESHOLD_MS,
   _resetForTesting: () => _resetForTesting,
+  _simulateHeartbeatGapForTesting: () => _simulateHeartbeatGapForTesting,
   appendFreezeLog: () => appendFreezeLog,
+  getRecentEventLoopLagMs: () => getRecentEventLoopLagMs,
   instrumentAsync: () => instrumentAsync,
   instrumentSync: () => instrumentSync,
+  onServerWake: () => onServerWake,
   startServerEventLoopHeartbeat: () => startServerEventLoopHeartbeat,
   stopServerEventLoopHeartbeat: () => stopServerEventLoopHeartbeat
 });
@@ -16000,6 +16127,44 @@ async function rotateIfNeeded(path, pendingBytes) {
     console.warn("[hotsheet freeze.log] rotate writeFile failed:", err instanceof Error ? err.message : String(err));
   }
 }
+function onServerWake(listener) {
+  wakeListeners.add(listener);
+  return () => {
+    wakeListeners.delete(listener);
+  };
+}
+function handleHeartbeatGap(blockMs) {
+  if (blockMs >= WAKE_GAP_THRESHOLD_MS) {
+    lastEventLoopLagMs = 0;
+    if (heartbeatDataDir !== null) {
+      void appendFreezeLog(heartbeatDataDir, {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        source: "server-wake",
+        durationMs: Math.round(blockMs),
+        context: `resumed from suspend after ~${Math.round(blockMs / 1e3).toString()}s`
+      });
+    }
+    for (const listener of wakeListeners) {
+      try {
+        listener(blockMs);
+      } catch {
+      }
+    }
+    return;
+  }
+  lastEventLoopLagMs = blockMs > 0 ? blockMs : 0;
+  if (blockMs >= LONG_TASK_THRESHOLD_MS && heartbeatDataDir !== null) {
+    void appendFreezeLog(heartbeatDataDir, {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      source: "server-heartbeat",
+      durationMs: Math.round(blockMs),
+      context: "event-loop blocked"
+    });
+  }
+}
+function _simulateHeartbeatGapForTesting(blockMs) {
+  handleHeartbeatGap(blockMs);
+}
 function startServerEventLoopHeartbeat(dataDir) {
   if (heartbeatTimer !== null) return;
   heartbeatDataDir = dataDir;
@@ -16008,18 +16173,13 @@ function startServerEventLoopHeartbeat(dataDir) {
     const now = process.hrtime.bigint();
     const elapsedMs = Number(now - lastHeartbeatNs) / 1e6;
     lastHeartbeatNs = now;
-    const blockMs = elapsedMs - HEARTBEAT_INTERVAL_MS;
-    if (blockMs >= LONG_TASK_THRESHOLD_MS && heartbeatDataDir !== null) {
-      void appendFreezeLog(heartbeatDataDir, {
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        source: "server-heartbeat",
-        durationMs: Math.round(blockMs),
-        context: "event-loop blocked"
-      });
-    }
+    handleHeartbeatGap(elapsedMs - HEARTBEAT_INTERVAL_MS);
   }, HEARTBEAT_INTERVAL_MS);
   heartbeatTimer.unref();
 }
+function getRecentEventLoopLagMs() {
+  return lastEventLoopLagMs;
+}
 function stopServerEventLoopHeartbeat() {
   if (heartbeatTimer !== null) {
     clearInterval(heartbeatTimer);
@@ -16066,9 +16226,11 @@ function _resetForTesting() {
   }
   heartbeatDataDir = null;
   lastHeartbeatNs = 0n;
+  lastEventLoopLagMs = 0;
+  wakeListeners.clear();
   appendQueue.clear();
 }
-var FREEZE_LOG_FILENAME, LONG_TASK_THRESHOLD_MS, FREEZE_LOG_MAX_BYTES, FREEZE_LOG_TARGET_BYTES_AFTER_TRUNCATE, HEARTBEAT_INTERVAL_MS, appendQueue, heartbeatTimer, lastHeartbeatNs, heartbeatDataDir;
+var FREEZE_LOG_FILENAME, LONG_TASK_THRESHOLD_MS, FREEZE_LOG_MAX_BYTES, FREEZE_LOG_TARGET_BYTES_AFTER_TRUNCATE, HEARTBEAT_INTERVAL_MS, WAKE_GAP_THRESHOLD_MS, appendQueue, heartbeatTimer, lastHeartbeatNs, lastEventLoopLagMs, heartbeatDataDir, wakeListeners;
 var init_freezeLogger = __esm({
   "src/diagnostics/freezeLogger.ts"() {
     "use strict";
@@ -16077,10 +16239,205 @@ var init_freezeLogger = __esm({
     FREEZE_LOG_MAX_BYTES = 1048576;
     FREEZE_LOG_TARGET_BYTES_AFTER_TRUNCATE = 524288;
     HEARTBEAT_INTERVAL_MS = 50;
+    WAKE_GAP_THRESHOLD_MS = 1e4;
     appendQueue = /* @__PURE__ */ new Map();
     heartbeatTimer = null;
     lastHeartbeatNs = 0n;
+    lastEventLoopLagMs = 0;
     heartbeatDataDir = null;
+    wakeListeners = /* @__PURE__ */ new Set();
+  }
+});
+
+// src/scheduler/backgroundScheduler.ts
+var backgroundScheduler_exports = {};
+__export(backgroundScheduler_exports, {
+  PRIORITY: () => PRIORITY,
+  _resetDefaultSchedulerForTests: () => _resetDefaultSchedulerForTests,
+  createBackgroundScheduler: () => createBackgroundScheduler,
+  getBackgroundScheduler: () => getBackgroundScheduler
+});
+function createBackgroundScheduler(opts = {}) {
+  const concurrency = opts.concurrency ?? 2;
+  const lagProvider = opts.lagProvider ?? getRecentEventLoopLagMs;
+  const lagThresholdMs = opts.lagThresholdMs ?? 200;
+  const reDrainDelayMs = opts.reDrainDelayMs ?? 250;
+  const now = opts.now ?? (() => Date.now());
+  const wakeStaggerWindowMs = opts.wakeStaggerWindowMs ?? 15e3;
+  const wakeStaggerStepMs = opts.wakeStaggerStepMs ?? 250;
+  const onError = opts.onError ?? ((key, err) => {
+    console.warn("[hotsheet backgroundScheduler] job failed:", key, err instanceof Error ? err.message : String(err));
+  });
+  const pending2 = /* @__PURE__ */ new Map();
+  const running = /* @__PURE__ */ new Set();
+  const runningGroups = /* @__PURE__ */ new Set();
+  const awaiters = /* @__PURE__ */ new Map();
+  const runningAwaiters = /* @__PURE__ */ new Map();
+  let seq = 0;
+  const lastServedSeq = /* @__PURE__ */ new Map();
+  let reDrainTimer = null;
+  const idleWaiters = [];
+  let staggerUntil = 0;
+  let lastStartAt = Number.NEGATIVE_INFINITY;
+  let staggerTimer = null;
+  function projectKeyOf(job) {
+    return job.projectKey ?? job.key;
+  }
+  function settleIdleIfDone() {
+    if (running.size === 0 && pending2.size === 0 && idleWaiters.length > 0) {
+      const waiters = idleWaiters.splice(0, idleWaiters.length);
+      for (const w of waiters) w();
+    }
+  }
+  function pickNext(highLag) {
+    let best = null;
+    let lagDeferred = false;
+    for (const job of pending2.values()) {
+      if (running.has(job.key)) continue;
+      if (job.exclusiveGroup !== void 0 && runningGroups.has(job.exclusiveGroup)) continue;
+      if (highLag && job.deferUnderLag === true) {
+        lagDeferred = true;
+        continue;
+      }
+      if (best === null) {
+        best = job;
+        continue;
+      }
+      if (job.priority !== best.priority) {
+        if (job.priority < best.priority) best = job;
+        continue;
+      }
+      const a = lastServedSeq.get(projectKeyOf(job)) ?? -1;
+      const b = lastServedSeq.get(projectKeyOf(best)) ?? -1;
+      if (a < b) best = job;
+    }
+    return { job: best, lagDeferred };
+  }
+  function drain() {
+    const highLag = lagProvider() > lagThresholdMs;
+    const t = now();
+    const inStagger = t < staggerUntil;
+    const cap = inStagger ? 1 : concurrency;
+    let armReDrain = false;
+    while (running.size < cap) {
+      if (inStagger) {
+        const sinceLast = t - lastStartAt;
+        if (sinceLast < wakeStaggerStepMs) {
+          scheduleStaggerDrain(wakeStaggerStepMs - sinceLast);
+          break;
+        }
+      }
+      const { job, lagDeferred } = pickNext(highLag);
+      if (job === null) {
+        armReDrain = lagDeferred;
+        break;
+      }
+      pending2.delete(job.key);
+      running.add(job.key);
+      if (job.exclusiveGroup !== void 0) runningGroups.add(job.exclusiveGroup);
+      runningAwaiters.set(job.key, awaiters.get(job.key) ?? []);
+      awaiters.delete(job.key);
+      lastServedSeq.set(projectKeyOf(job), ++seq);
+      lastStartAt = t;
+      void runJob(job);
+    }
+    if (armReDrain) scheduleReDrain();
+    settleIdleIfDone();
+  }
+  async function runJob(job) {
+    try {
+      await job.run();
+    } catch (err) {
+      onError(job.key, err);
+    } finally {
+      running.delete(job.key);
+      if (job.exclusiveGroup !== void 0) runningGroups.delete(job.exclusiveGroup);
+      const settled = runningAwaiters.get(job.key);
+      runningAwaiters.delete(job.key);
+      if (settled !== void 0) for (const r of settled) r();
+      drain();
+    }
+  }
+  function scheduleReDrain() {
+    if (reDrainTimer !== null) return;
+    reDrainTimer = setTimeout(() => {
+      reDrainTimer = null;
+      drain();
+    }, reDrainDelayMs);
+    reDrainTimer.unref();
+  }
+  function scheduleStaggerDrain(delayMs) {
+    if (staggerTimer !== null) clearTimeout(staggerTimer);
+    staggerTimer = setTimeout(() => {
+      staggerTimer = null;
+      drain();
+    }, Math.max(0, delayMs));
+    staggerTimer.unref();
+  }
+  return {
+    submit(job) {
+      pending2.set(job.key, job);
+      const done = new Promise((resolve11) => {
+        const list = awaiters.get(job.key) ?? [];
+        list.push(resolve11);
+        awaiters.set(job.key, list);
+      });
+      drain();
+      return done;
+    },
+    runningCount: () => running.size,
+    pendingCount: () => pending2.size,
+    onIdle() {
+      if (running.size === 0 && pending2.size === 0) return Promise.resolve();
+      return new Promise((resolve11) => {
+        idleWaiters.push(resolve11);
+      });
+    },
+    noteWake() {
+      staggerUntil = now() + wakeStaggerWindowMs;
+      drain();
+    },
+    clear() {
+      pending2.clear();
+      if (reDrainTimer !== null) {
+        clearTimeout(reDrainTimer);
+        reDrainTimer = null;
+      }
+      if (staggerTimer !== null) {
+        clearTimeout(staggerTimer);
+        staggerTimer = null;
+      }
+      staggerUntil = 0;
+      const orphaned = [...awaiters.values()].flat();
+      awaiters.clear();
+      for (const r of orphaned) r();
+      settleIdleIfDone();
+    }
+  };
+}
+function getBackgroundScheduler() {
+  if (defaultScheduler === null) {
+    defaultScheduler = createBackgroundScheduler();
+  }
+  return defaultScheduler;
+}
+function _resetDefaultSchedulerForTests() {
+  defaultScheduler?.clear();
+  defaultScheduler = null;
+}
+var PRIORITY, defaultScheduler;
+var init_backgroundScheduler = __esm({
+  "src/scheduler/backgroundScheduler.ts"() {
+    "use strict";
+    init_freezeLogger();
+    PRIORITY = {
+      GIT_STATUS: 10,
+      MARKDOWN_SYNC: 20,
+      SNAPSHOT: 30,
+      BACKUP: 40,
+      GC: 50
+    };
+    defaultScheduler = null;
   }
 });
 
@@ -16137,7 +16494,7 @@ function initSnapshotScheduler(dataDir) {
   const state = getOrCreateState(dataDir);
   if (state.safetyTimer !== null) return;
   state.safetyTimer = setInterval(() => {
-    if (state.dirty && !state.inProgress) void writeSnapshotNow(dataDir);
+    if (state.dirty && !state.inProgress) void submitSnapshotJob(dataDir);
   }, numericSetting(dataDir, "db_snapshot_safety_interval_ms", DEFAULT_SAFETY_INTERVAL_MS));
   state.safetyTimer.unref();
 }
@@ -16150,9 +16507,20 @@ function scheduleSnapshot(dataDir) {
   if (state.debounceTimer) clearTimeout(state.debounceTimer);
   state.debounceTimer = setTimeout(() => {
     state.debounceTimer = null;
-    void writeSnapshotNow(dir);
+    void submitSnapshotJob(dir);
   }, numericSetting(dir, "db_snapshot_debounce_ms", DEFAULT_DEBOUNCE_MS));
 }
+function submitSnapshotJob(dataDir) {
+  return getBackgroundScheduler().submit({
+    key: `snapshot:${dataDir}`,
+    priority: PRIORITY.SNAPSHOT,
+    projectKey: dataDir,
+    deferUnderLag: false,
+    run: async () => {
+      await writeSnapshotNow(dataDir);
+    }
+  });
+}
 async function writeSnapshotNow(dataDir) {
   if (!isSnapshotProtectionEnabled(dataDir)) return null;
   if (!existsSync4(join5(dataDir, "db"))) return null;
@@ -16194,7 +16562,7 @@ async function snapshotAllForShutdown() {
   for (const dir of dirs) {
     if (!isSnapshotProtectionEnabled(dir)) continue;
     try {
-      await writeSnapshotNow(dir);
+      await submitSnapshotJob(dir);
     } catch (err) {
       console.error(`[snapshot] shutdown snapshot failed for ${dir}:`, err);
     }
@@ -16246,6 +16614,7 @@ var init_snapshot = __esm({
     "use strict";
     init_freezeLogger();
     init_file_settings();
+    init_backgroundScheduler();
     init_connection();
     DEFAULT_DEBOUNCE_MS = 2e3;
     DEFAULT_SAFETY_INTERVAL_MS = 12e4;
@@ -16361,13 +16730,40 @@ function clearRecoveryMarker(dataDir) {
   } catch {
   }
 }
+function pendingRecoveryPath(dataDir) {
+  return join7(dataDir, PENDING_RECOVERY_FILENAME);
+}
+function readPendingRecovery(dataDir) {
+  const path = pendingRecoveryPath(dataDir);
+  if (!existsSync6(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    const result = external_exports.object({ attempts: external_exports.number() }).loose().safeParse(parsed);
+    return { attempts: result.success ? result.data.attempts : 1 };
+  } catch {
+    return { attempts: 1 };
+  }
+}
+function writePendingRecovery(dataDir, attempts) {
+  try {
+    writeFileSync2(pendingRecoveryPath(dataDir), JSON.stringify({ attempts, requestedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+  } catch (writeErr) {
+    console.error("Could not write pending-recovery marker:", getErrorMessage(writeErr));
+  }
+}
+function clearPendingRecovery(dataDir) {
+  try {
+    rmSync2(pendingRecoveryPath(dataDir), { force: true });
+  } catch {
+  }
+}
 function runWithDataDir(dataDir, fn) {
   return requestDataDir.run(dataDir, fn);
 }
 function getDataDir() {
   const contextDataDir = requestDataDir.getStore();
   if (contextDataDir !== void 0) return contextDataDir;
-  if (defaultDbPath !== null) return defaultDbPath.replace(/\/db$/, "");
+  if (defaultDbPath !== null) return defaultDbPath.replace(/[\\/]db$/, "");
   throw new Error("Data directory not available. Call setDataDir() or use runWithDataDir().");
 }
 function setDataDir(dataDir) {
@@ -16439,6 +16835,8 @@ async function getDbForDir(dataDir) {
 async function getDbByPath(dbPath) {
   const existing = databases.get(dbPath);
   if (existing) return existing;
+  const recovered = await completeDeferredRecovery(dbPath);
+  if (recovered !== null) return recovered;
   let db;
   try {
     db = await openAndCacheDb(dbPath);
@@ -16461,8 +16859,16 @@ async function getDbByPath(dbPath) {
 }
 async function openAndCacheDb(dbPath, loadDataDir) {
   const db = createPglite(dbPath, loadDataDir !== void 0 ? { loadDataDir } : {});
-  await db.waitReady;
-  await initSchema(db);
+  try {
+    await db.waitReady;
+    await initSchema(db);
+  } catch (err) {
+    try {
+      await db.close();
+    } catch {
+    }
+    throw err;
+  }
   databases.set(dbPath, db);
   return db;
 }
@@ -16506,6 +16912,57 @@ async function tryRestoreFromSources(dbPath, dataDir) {
   }
   return null;
 }
+async function renameDirWithRetry(from, to) {
+  const maxAttempts = 5;
+  for (let attempt = 1; ; attempt++) {
+    try {
+      renameSync(from, to);
+      return;
+    } catch (renameErr) {
+      const code = renameErr.code;
+      const retryable = code === "EPERM" || code === "EBUSY" || code === "EACCES" || code === "ENOTEMPTY";
+      if (!retryable || attempt >= maxAttempts) throw renameErr;
+      await new Promise((resolve11) => setTimeout(resolve11, 100 * attempt));
+    }
+  }
+}
+async function completeDeferredRecovery(dbPath) {
+  const dataDir = dbPath.replace(/[\\/]db$/, "");
+  const pending2 = readPendingRecovery(dataDir);
+  if (pending2 === null) return null;
+  if (pending2.attempts > MAX_DEFERRED_RECOVERY_ATTEMPTS) {
+    console.error(`[db] deferred recovery gave up after ${String(pending2.attempts)} attempts; leaving the corrupt cluster for manual rescue.`);
+    clearPendingRecovery(dataDir);
+    return null;
+  }
+  if (!existsSync6(dbPath)) {
+    clearPendingRecovery(dataDir);
+    return null;
+  }
+  console.error("[db] completing deferred recovery \u2014 a prior launch could not move the corrupt database aside in-process (Windows handle lock)\u2026");
+  const corruptPath = `${dbPath}-corrupt-${Date.now()}`;
+  try {
+    await renameDirWithRetry(dbPath, corruptPath);
+  } catch (renameErr) {
+    writePendingRecovery(dataDir, pending2.attempts + 1);
+    console.error(`[db] deferred recovery could not move db/ yet: ${getErrorMessage(renameErr)}`);
+    return null;
+  }
+  const restored = await tryRestoreFromSources(dbPath, dataDir);
+  writeRecoveryMarker(dataDir, {
+    corruptPath,
+    recoveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    errorMessage: "Database was corrupt and could not be preserved in-process (Windows handle lock); recovered on the next restart.",
+    ...restored !== null ? { restoredFrom: restored.label, restoredTicketCount: restored.ticketCount } : {}
+  });
+  clearPendingRecovery(dataDir);
+  if (restored !== null) {
+    console.error(`[db] deferred recovery restored from ${restored.label} (${String(restored.ticketCount)} tickets).`);
+    return restored.db;
+  }
+  console.error("[db] deferred recovery: no snapshot/backup could be loaded; starting with a fresh empty database.");
+  return null;
+}
 async function recoverFromOpenFailure(dbPath, err, forceRecover) {
   const message = getErrorMessage(err);
   const stack = err instanceof Error ? err.stack : void 0;
@@ -16530,16 +16987,18 @@ async function recoverFromOpenFailure(dbPath, err, forceRecover) {
       }
     }
   }
+  const dataDir = dbPath.replace(/[\\/]db$/, "");
   const corruptPath = `${dbPath}-corrupt-${Date.now()}`;
   console.error(`Database appears to be corrupt. Preserving as ${corruptPath} ...`);
   try {
-    renameSync(dbPath, corruptPath);
+    await renameDirWithRetry(dbPath, corruptPath);
   } catch (renameErr) {
     const renameMessage = getErrorMessage(renameErr);
-    console.error(`Could not preserve corrupt database directory: ${renameMessage}. Aborting auto-recreate to avoid data loss.`);
+    const prev = readPendingRecovery(dataDir);
+    writePendingRecovery(dataDir, (prev?.attempts ?? 0) + 1);
+    console.error(`Could not preserve corrupt database directory in-process: ${renameMessage}. Wrote a pending-recovery marker \u2014 Hot Sheet will auto-recover from the latest snapshot on the next restart.`);
     throw err;
   }
-  const dataDir = dbPath.replace(/[\\/]db$/, "");
   const restored = await tryRestoreFromSources(dbPath, dataDir);
   if (restored !== null) {
     writeRecoveryMarker(dataDir, {
@@ -16782,6 +17241,22 @@ async function initSchema(db) {
     CREATE INDEX IF NOT EXISTS idx_otel_spans_session_ts ON otel_spans(session_id, start_ts);
     CREATE INDEX IF NOT EXISTS idx_otel_spans_prompt ON otel_spans(prompt_id);
     CREATE INDEX IF NOT EXISTS idx_otel_spans_trace ON otel_spans(trace_id);
+
+    -- HS-8730 (per-ticket cost, time-window correlation) \u2014 records when each
+    -- ticket was actively being worked (its status was 'started'), so the
+    -- per-ticket rollup can attribute api_request cost by timestamp instead of
+    -- only the channelUI prompt marker. Lives in the telemetry DB (this is the
+    -- default/primary project's DB per getTelemetryDb) so the rollup join with
+    -- otel_events is single-DB. Keyed by project_secret (matching otel_events).
+    CREATE TABLE IF NOT EXISTS ticket_work_intervals (
+      id SERIAL PRIMARY KEY,
+      project_secret TEXT NOT NULL,
+      ticket_number TEXT NOT NULL,
+      started_at TIMESTAMPTZ NOT NULL,
+      ended_at TIMESTAMPTZ
+    );
+    CREATE INDEX IF NOT EXISTS idx_twi_secret_ticket ON ticket_work_intervals(project_secret, ticket_number);
+    CREATE INDEX IF NOT EXISTS idx_twi_open ON ticket_work_intervals(project_secret, ticket_number, ended_at);
   `);
   await migrateNoteIds(db);
 }
@@ -16808,15 +17283,17 @@ async function migrateNoteIds(db) {
     }
   }
 }
-var SCHEMA_VERSION, RECOVERY_MARKER_FILENAME, databases, defaultDbPath, requestDataDir;
+var SCHEMA_VERSION, RECOVERY_MARKER_FILENAME, PENDING_RECOVERY_FILENAME, MAX_DEFERRED_RECOVERY_ATTEMPTS, databases, defaultDbPath, requestDataDir;
 var init_connection = __esm({
   "src/db/connection.ts"() {
     "use strict";
     init_zod();
     init_errorMessage();
     init_pglite();
-    SCHEMA_VERSION = 4;
+    SCHEMA_VERSION = 5;
     RECOVERY_MARKER_FILENAME = ".db-recovery-marker.json";
+    PENDING_RECOVERY_FILENAME = ".db-pending-recovery.json";
+    MAX_DEFERRED_RECOVERY_ATTEMPTS = 3;
     databases = /* @__PURE__ */ new Map();
     defaultDbPath = null;
     requestDataDir = new AsyncLocalStorage();
@@ -16908,20 +17385,27 @@ function getOrCreateState2(dataDir) {
   }
   return state;
 }
-async function withGlobalBackupLock(fn) {
-  while (activeBackup !== null) {
-    try {
-      await activeBackup;
-    } catch {
+function withGlobalBackupLock(fn) {
+  let settle;
+  let fail;
+  const out = new Promise((resolve11, reject2) => {
+    settle = resolve11;
+    fail = reject2;
+  });
+  void getBackgroundScheduler().submit({
+    key: `backup:${++backupLockSeq}`,
+    priority: PRIORITY.BACKUP,
+    exclusiveGroup: BACKUP_EXCLUSIVE_GROUP,
+    deferUnderLag: false,
+    run: async () => {
+      try {
+        settle(await fn());
+      } catch (e) {
+        fail(e);
+      }
     }
-  }
-  const p = (async () => fn())();
-  activeBackup = p;
-  try {
-    return await p;
-  } finally {
-    if (activeBackup === p) activeBackup = null;
-  }
+  });
+  return out;
 }
 function backupsDir(dataDir) {
   return getBackupDir(dataDir);
@@ -17185,12 +17669,18 @@ function initBackupScheduler(dataDir) {
     });
   }, 3e4);
   state.attachmentGcInterval = setInterval(() => {
-    void instrumentAsync(dataDir, "attachmentBackup.orphanGc:daily", () => runAttachmentGc(backupsDir(dataDir))).then((stats) => {
-      if (stats.deleted > 0) {
-        console.log(`[attachmentBackup] GC: reclaimed ${stats.deleted} blob(s), ${(stats.bytesReclaimed / 1024 / 1024).toFixed(2)} MB`);
-      }
-    }).catch((err) => {
-      console.error("[attachmentBackup] GC daily run failed:", err);
+    void getBackgroundScheduler().submit({
+      key: `attachment-gc:${dataDir}`,
+      priority: PRIORITY.GC,
+      projectKey: dataDir,
+      deferUnderLag: true,
+      run: () => instrumentAsync(dataDir, "attachmentBackup.orphanGc:daily", () => runAttachmentGc(backupsDir(dataDir))).then((stats) => {
+        if (stats.deleted > 0) {
+          console.log(`[attachmentBackup] GC: reclaimed ${stats.deleted} blob(s), ${(stats.bytesReclaimed / 1024 / 1024).toFixed(2)} MB`);
+        }
+      }).catch((err) => {
+        console.error("[attachmentBackup] GC daily run failed:", err);
+      })
     });
   }, 24 * 60 * 60 * 1e3);
 }
@@ -17209,7 +17699,7 @@ async function triggerMissedBackups(dataDir) {
     await createBackup(dataDir, tier);
   }
 }
-var TIERS, backupStates, activePreviews, activeBackup, VALID_TIERS;
+var TIERS, backupStates, activePreviews, backupLockSeq, BACKUP_EXCLUSIVE_GROUP, VALID_TIERS;
 var init_backup = __esm({
   "src/backup.ts"() {
     "use strict";
@@ -17220,6 +17710,7 @@ var init_backup = __esm({
     init_dbJsonExport();
     init_freezeLogger();
     init_file_settings();
+    init_backgroundScheduler();
     TIERS = {
       "5min": { intervalMs: 5 * 60 * 1e3, maxAge: 60 * 60 * 1e3, maxCount: 12 },
       "hourly": { intervalMs: 60 * 60 * 1e3, maxAge: 12 * 60 * 60 * 1e3, maxCount: 12 },
@@ -17227,7 +17718,8 @@ var init_backup = __esm({
     };
     backupStates = /* @__PURE__ */ new Map();
     activePreviews = /* @__PURE__ */ new Map();
-    activeBackup = null;
+    backupLockSeq = 0;
+    BACKUP_EXCLUSIVE_GROUP = "backup";
     VALID_TIERS = /* @__PURE__ */ new Set(["5min", "hourly", "daily"]);
   }
 });
@@ -17802,6 +18294,47 @@ var init_ticketNumber = __esm({
   }
 });
 
+// src/db/ticketWorkIntervals.ts
+async function recordTicketWorkTransition(secret, ticketNumber, status) {
+  if (secret === "" || ticketNumber === "") return;
+  try {
+    const db = await getTelemetryDb();
+    await db.query(
+      `UPDATE ticket_work_intervals SET ended_at = NOW()
+       WHERE project_secret = $1 AND ticket_number = $2 AND ended_at IS NULL`,
+      [secret, ticketNumber]
+    );
+    if (status === "started") {
+      await db.query(
+        `INSERT INTO ticket_work_intervals (project_secret, ticket_number, started_at)
+         VALUES ($1, $2, NOW())`,
+        [secret, ticketNumber]
+      );
+    }
+  } catch (err) {
+    console.warn("[ticketWorkIntervals] failed to record transition:", err instanceof Error ? err.message : String(err));
+  }
+}
+async function closeOpenTicketIntervalsForProject(secret) {
+  if (secret === "") return;
+  try {
+    const db = await getTelemetryDb();
+    await db.query(
+      `UPDATE ticket_work_intervals SET ended_at = NOW()
+       WHERE project_secret = $1 AND ended_at IS NULL`,
+      [secret]
+    );
+  } catch (err) {
+    console.warn("[ticketWorkIntervals] failed to close open intervals:", err instanceof Error ? err.message : String(err));
+  }
+}
+var init_ticketWorkIntervals = __esm({
+  "src/db/ticketWorkIntervals.ts"() {
+    "use strict";
+    init_connection();
+  }
+});
+
 // src/db/tickets.ts
 function escapeIlike(value) {
   return value.replace(/[%_\\]/g, "\\$&");
@@ -17934,7 +18467,17 @@ async function updateTicket(id, updates, options) {
     `UPDATE tickets SET ${sets.join(", ")} WHERE id = $${paramIdx} RETURNING *`,
     values
   );
-  return result.rows[0] ?? null;
+  const updated = result.rows[0] ?? null;
+  if (updates.status !== void 0) {
+    try {
+      const secret = readFileSettings(getDataDir()).secret;
+      if (secret !== void 0 && secret !== "") {
+        void recordTicketWorkTransition(secret, updated.ticket_number, updates.status);
+      }
+    } catch {
+    }
+  }
+  return updated;
 }
 async function deleteTicket(id) {
   await updateTicket(id, { status: "deleted" });
@@ -18273,9 +18816,11 @@ var QUERYABLE_FIELDS, PRIORITY_ORD, STATUS_ORD, PRIORITY_RANK, STATUS_RANK;
 var init_tickets = __esm({
   "src/db/tickets.ts"() {
     "use strict";
+    init_file_settings();
     init_ticketNumber();
     init_connection();
     init_notes();
+    init_ticketWorkIntervals();
     QUERYABLE_FIELDS = /* @__PURE__ */ new Set(["category", "priority", "status", "title", "details", "up_next", "tags"]);
     PRIORITY_ORD = `CASE priority WHEN 'highest' THEN 1 WHEN 'high' THEN 2 WHEN 'default' THEN 3 WHEN 'low' THEN 4 WHEN 'lowest' THEN 5 ELSE 3 END`;
     STATUS_ORD = `CASE status WHEN 'backlog' THEN 1 WHEN 'not_started' THEN 2 WHEN 'started' THEN 3 WHEN 'completed' THEN 4 WHEN 'verified' THEN 5 WHEN 'archive' THEN 6 ELSE 2 END`;
@@ -19380,7 +19925,14 @@ function scheduleWorklistSync(dir) {
   if (!state) return;
   if (state.worklistTimeout) clearTimeout(state.worklistTimeout);
   state.worklistTimeout = setTimeout(() => {
-    void runWithDataDir(state.dataDir, () => instrumentAsync(state.dataDir, "markdown.syncWorklist", () => syncWorklist(state)));
+    state.worklistTimeout = null;
+    void getBackgroundScheduler().submit({
+      key: `markdown-worklist:${state.dataDir}`,
+      priority: PRIORITY.MARKDOWN_SYNC,
+      projectKey: state.dataDir,
+      deferUnderLag: true,
+      run: () => runWithDataDir(state.dataDir, () => instrumentAsync(state.dataDir, "markdown.syncWorklist", () => syncWorklist(state)))
+    });
   }, WORKLIST_SYNC_DEBOUNCE_MS);
 }
 function scheduleOpenTicketsSync(dir) {
@@ -19388,7 +19940,14 @@ function scheduleOpenTicketsSync(dir) {
   if (!state) return;
   if (state.openTicketsTimeout) clearTimeout(state.openTicketsTimeout);
   state.openTicketsTimeout = setTimeout(() => {
-    void runWithDataDir(state.dataDir, () => instrumentAsync(state.dataDir, "markdown.syncOpenTickets", () => syncOpenTickets(state)));
+    state.openTicketsTimeout = null;
+    void getBackgroundScheduler().submit({
+      key: `markdown-opentickets:${state.dataDir}`,
+      priority: PRIORITY.MARKDOWN_SYNC,
+      projectKey: state.dataDir,
+      deferUnderLag: true,
+      run: () => runWithDataDir(state.dataDir, () => instrumentAsync(state.dataDir, "markdown.syncOpenTickets", () => syncOpenTickets(state)))
+    });
   }, OPEN_TICKETS_SYNC_DEBOUNCE_MS);
 }
 function scheduleAllSync(dir) {
@@ -19706,6 +20265,7 @@ var init_markdown = __esm({
     init_freezeLogger();
     init_file_settings();
     init_limits();
+    init_backgroundScheduler();
     init_schemas3();
     syncStates = /* @__PURE__ */ new Map();
     defaultDataDir2 = null;
@@ -20394,7 +20954,7 @@ function claudeAllowRulePattern(dataDir) {
   return `mcp__${getMcpServerKey(dataDir)}__*`;
 }
 function projectRoot(dataDir) {
-  return dataDir.replace(/\/\.hotsheet\/?$/, "");
+  return dataDir.replace(/[\\/]\.hotsheet[\\/]?$/, "");
 }
 function claudeDir(dataDir) {
   return join18(projectRoot(dataDir), ".claude");
@@ -20514,7 +21074,7 @@ function getChannelServerPath() {
   return { command: process.execPath, args: [distPath] };
 }
 function projectRoot2(dataDir) {
-  return dataDir.replace(/\/.hotsheet\/?$/, "");
+  return dataDir.replace(/[\\/]\.hotsheet[\\/]?$/, "");
 }
 function registerChannel(dataDir) {
   const root2 = projectRoot2(dataDir);
@@ -21262,6 +21822,25 @@ var init_sessionStore = __esm({
   }
 });
 
+// src/activeProjects.ts
+function markProjectActive(dataDir) {
+  lastActiveAt.set(dataDir, Date.now());
+}
+function isProjectActive(dataDir) {
+  if (lastActiveAt.size === 0) return true;
+  const at = lastActiveAt.get(dataDir);
+  if (at === void 0) return false;
+  return Date.now() - at < ACTIVE_TTL_MS;
+}
+var ACTIVE_TTL_MS, lastActiveAt;
+var init_activeProjects = __esm({
+  "src/activeProjects.ts"() {
+    "use strict";
+    ACTIVE_TTL_MS = 9e4;
+    lastActiveAt = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/gitignore.ts
 import { execFileSync as execFileSync3 } from "child_process";
 import { appendFileSync as appendFileSync3, existsSync as existsSync16, readFileSync as readFileSync13 } from "fs";
@@ -21317,56 +21896,72 @@ var init_gitignore = __esm({
 });
 
 // src/git/status.ts
-import { spawnSync } from "child_process";
+import { execFile as execFile3 } from "child_process";
 import { join as join23 } from "path";
+import { promisify as promisify2 } from "util";
+function bufToStr(v) {
+  if (typeof v === "string") return v;
+  if (v !== void 0) return v.toString();
+  return "";
+}
 function makeGitInvoker({ timeoutMs, includeStderr = false }) {
-  return (args, cwd) => {
-    const res = spawnSync("git", args, {
+  return async (args, cwd) => {
+    const opts = {
       cwd,
       encoding: "utf-8",
       timeout: timeoutMs,
+      maxBuffer: GIT_MAX_BUFFER,
       env: {
         ...process.env,
         GIT_TERMINAL_PROMPT: "0",
         GIT_OPTIONAL_LOCKS: "0"
       }
-    });
-    const stdout = typeof res.stdout === "string" ? res.stdout : "";
-    const stderr = typeof res.stderr === "string" ? res.stderr : "";
-    return { stdout: includeStderr ? stdout + stderr : stdout, status: res.status };
+    };
+    try {
+      const { stdout, stderr } = await execFileAsync2("git", args, opts);
+      const out = bufToStr(stdout);
+      const err = bufToStr(stderr);
+      return { stdout: includeStderr ? out + err : out, status: 0 };
+    } catch (e) {
+      const errObj = e;
+      const out = bufToStr(errObj.stdout);
+      const err = bufToStr(errObj.stderr);
+      const status = typeof errObj.code === "number" ? errObj.code : null;
+      return { stdout: includeStderr ? out + err : out, status };
+    }
   };
 }
-function getGitStatus(projectRoot3, invoker = defaultInvoker) {
+async function getGitStatus(projectRoot3, invoker = defaultInvoker) {
   if (!isGitRepo(projectRoot3)) return null;
-  return instrumentSync(join23(projectRoot3, ".hotsheet"), "git.getStatus", () => getGitStatusUnwrapped(projectRoot3, invoker));
+  return instrumentAsync(join23(projectRoot3, ".hotsheet"), "git.getStatus", () => getGitStatusUnwrapped(projectRoot3, invoker));
 }
-function getGitStatusUnwrapped(projectRoot3, invoker) {
+async function getGitStatusUnwrapped(projectRoot3, invoker) {
   const root2 = getGitRoot(projectRoot3) ?? projectRoot3;
-  const branchRes = invoker(["symbolic-ref", "--short", "HEAD"], root2);
+  const branchRes = await invoker(["symbolic-ref", "--short", "HEAD"], root2);
   let branch;
   let detached = false;
   if (branchRes.status === 0 && branchRes.stdout.trim() !== "") {
     branch = branchRes.stdout.trim();
   } else {
     detached = true;
-    const sha = invoker(["rev-parse", "--short", "HEAD"], root2);
+    const sha = await invoker(["rev-parse", "--short", "HEAD"], root2);
     branch = sha.status === 0 && sha.stdout.trim() !== "" ? sha.stdout.trim() : "(detached)";
   }
-  const porcelain = invoker(["status", "--porcelain=v1", "--no-renames"], root2);
+  const porcelain = await invoker(["status", "--porcelain=v1", "--no-renames"], root2);
   const counts = porcelain.status === 0 ? bucketPorcelain(porcelain.stdout) : { staged: 0, unstaged: 0, untracked: 0, conflicted: 0 };
   let upstream = null;
   let ahead = 0;
   let behind = 0;
   if (!detached) {
-    const upRes = invoker(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], root2);
+    const upRes = await invoker(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], root2);
     if (upRes.status === 0 && upRes.stdout.trim() !== "") {
       upstream = upRes.stdout.trim();
-      const aheadRes = invoker(["rev-list", "--count", "@{u}..HEAD"], root2);
+      const aheadRes = await invoker(["rev-list", "--count", "@{u}..HEAD"], root2);
       if (aheadRes.status === 0) {
         const n = Number.parseInt(aheadRes.stdout.trim(), 10);
         if (Number.isFinite(n)) ahead = n;
       }
-      const behindRes = invoker(["rev-list", "--count", "HEAD..@{u}"], root2);
+      const behindRes = await invoker(["rev-list", "--count", "HEAD..@{u}"], root2);
       if (behindRes.status === 0) {
         const n = Number.parseInt(behindRes.stdout.trim(), 10);
         if (Number.isFinite(n)) behind = n;
@@ -21389,16 +21984,16 @@ function getGitStatusUnwrapped(projectRoot3, invoker) {
 function getLastFetchedAt(projectRoot3) {
   return lastFetchedAt.get(projectRoot3) ?? null;
 }
-function runGitFetch(projectRoot3, invoker = makeGitInvoker({ timeoutMs: 3e4, includeStderr: true })) {
+async function runGitFetch(projectRoot3, invoker = makeGitInvoker({ timeoutMs: 3e4, includeStderr: true })) {
   if (!isGitRepo(projectRoot3)) {
     return { ok: false, lastFetchedAt: null, error: "Not a git repository" };
   }
   const root2 = getGitRoot(projectRoot3) ?? projectRoot3;
-  const upRes = invoker(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], root2);
+  const upRes = await invoker(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], root2);
   if (upRes.status !== 0 || upRes.stdout.trim() === "") {
     return { ok: false, lastFetchedAt: null, error: "No upstream branch \u2014 set one with `git push -u <remote> <branch>`." };
   }
-  const fetchRes = invoker(["fetch", "--quiet", "--no-write-fetch-head"], root2);
+  const fetchRes = await invoker(["fetch", "--quiet", "--no-write-fetch-head"], root2);
   if (fetchRes.status === 0) {
     const now = Date.now();
     lastFetchedAt.set(projectRoot3, now);
@@ -21425,11 +22020,11 @@ function bucketPorcelain(output) {
   }
   return out;
 }
-function getGitStatusFiles(projectRoot3, invoker = defaultInvoker) {
+async function getGitStatusFiles(projectRoot3, invoker = defaultInvoker) {
   if (!isGitRepo(projectRoot3)) return null;
-  return instrumentSync(join23(projectRoot3, ".hotsheet"), "git.getStatusFiles", () => {
+  return instrumentAsync(join23(projectRoot3, ".hotsheet"), "git.getStatusFiles", async () => {
     const root2 = getGitRoot(projectRoot3) ?? projectRoot3;
-    const res = invoker(["status", "--porcelain=v1", "--no-renames", "-z"], root2);
+    const res = await invoker(["status", "--porcelain=v1", "--no-renames", "-z"], root2);
     if (res.status !== 0) return null;
     return bucketPorcelainFiles(res.stdout);
   });
@@ -21476,13 +22071,15 @@ function pushCapped(arr, item, onTruncate) {
   }
   arr.push(item);
 }
-var SPAWN_TIMEOUT_MS, defaultInvoker, lastFetchedAt, FILES_PER_BUCKET_CAP;
+var execFileAsync2, SPAWN_TIMEOUT_MS, GIT_MAX_BUFFER, defaultInvoker, lastFetchedAt, FILES_PER_BUCKET_CAP;
 var init_status = __esm({
   "src/git/status.ts"() {
     "use strict";
     init_freezeLogger();
     init_gitignore();
+    execFileAsync2 = promisify2(execFile3);
     SPAWN_TIMEOUT_MS = 2e3;
+    GIT_MAX_BUFFER = 32 * 1024 * 1024;
     defaultInvoker = makeGitInvoker({ timeoutMs: SPAWN_TIMEOUT_MS });
     lastFetchedAt = /* @__PURE__ */ new Map();
     FILES_PER_BUCKET_CAP = 200;
@@ -21503,21 +22100,33 @@ __export(watcher_exports, {
 });
 import { existsSync as existsSync17, watch as fsWatch } from "fs";
 import { join as join24 } from "path";
-function getCachedGitStatus(projectRoot3) {
+async function getCachedGitStatus(projectRoot3) {
   const entry = cache.get(projectRoot3);
   const now = Date.now();
   if (entry !== void 0 && now - entry.resolvedAt < CACHE_TTL_MS) {
     return entry.status;
   }
-  const status = getGitStatus(projectRoot3);
-  cache.set(projectRoot3, { status, resolvedAt: now });
-  return status;
+  const pending2 = inFlight.get(projectRoot3);
+  if (pending2 !== void 0) return pending2;
+  const p = (async () => {
+    try {
+      const status = await getGitStatus(projectRoot3);
+      cache.set(projectRoot3, { status, resolvedAt: Date.now() });
+      return status;
+    } finally {
+      inFlight.delete(projectRoot3);
+    }
+  })();
+  inFlight.set(projectRoot3, p);
+  return p;
 }
 function _resetGitStatusCacheForTests() {
   cache.clear();
+  inFlight.clear();
 }
 function dropGitStatusCache(projectRoot3) {
   cache.delete(projectRoot3);
+  inFlight.delete(projectRoot3);
 }
 function subscribeToGitChanges(handler) {
   subscribers.add(handler);
@@ -21546,13 +22155,22 @@ function ensureGitWatcher(projectRoot3) {
       if (e2 === void 0) return;
       e2.debounce = null;
       cache.delete(projectRoot3);
+      inFlight.delete(projectRoot3);
       e2.version++;
+      if (!isProjectActive(join24(projectRoot3, ".hotsheet"))) return;
       for (const sub of subscribers) {
         try {
           sub(projectRoot3);
         } catch {
         }
       }
+      void getBackgroundScheduler().submit({
+        key: `git-refresh:${projectRoot3}`,
+        priority: PRIORITY.GIT_STATUS,
+        projectKey: projectRoot3,
+        deferUnderLag: true,
+        run: () => getCachedGitStatus(projectRoot3).then(() => void 0)
+      });
     }, WATCHER_DEBOUNCE_MS);
   };
   for (const file2 of filenames) {
@@ -21579,19 +22197,23 @@ function disposeGitWatcher(projectRoot3) {
     watchers.delete(projectRoot3);
   }
   cache.delete(projectRoot3);
+  inFlight.delete(projectRoot3);
 }
 function disposeAllGitWatchers() {
   for (const root2 of [...watchers.keys()]) disposeGitWatcher(root2);
   subscribers.clear();
 }
-var CACHE_TTL_MS, cache, WATCHER_DEBOUNCE_MS, watchers, subscribers;
+var CACHE_TTL_MS, cache, inFlight, WATCHER_DEBOUNCE_MS, watchers, subscribers;
 var init_watcher = __esm({
   "src/git/watcher.ts"() {
     "use strict";
+    init_activeProjects();
     init_gitignore();
+    init_backgroundScheduler();
     init_status();
     CACHE_TTL_MS = 500;
     cache = /* @__PURE__ */ new Map();
+    inFlight = /* @__PURE__ */ new Map();
     WATCHER_DEBOUNCE_MS = 250;
     watchers = /* @__PURE__ */ new Map();
     subscribers = /* @__PURE__ */ new Set();
@@ -23672,6 +24294,7 @@ async function runShutdownPipeline(reason) {
   await killShellCommands();
   await destroyTerminals();
   await disposeGitWatchers();
+  await terminateHashWorkerStep();
   await snapshotDatabases();
   await closeDatabases();
   stopFreezeHeartbeat();
@@ -23704,6 +24327,14 @@ async function disposeGitWatchers() {
     console.error("[lifecycle] disposeAllGitWatchers error:", err);
   }
 }
+async function terminateHashWorkerStep() {
+  try {
+    const { terminateHashWorker: terminateHashWorker2 } = await Promise.resolve().then(() => (init_hashWorker(), hashWorker_exports));
+    await terminateHashWorker2();
+  } catch (err) {
+    console.error("[lifecycle] terminateHashWorker error:", err);
+  }
+}
 async function closeHttpServer() {
   if (httpServer === null) return;
   await new Promise((resolve11) => {
@@ -23798,25 +24429,25 @@ var init_mime_types = __esm({
 // src/open-in-file-manager.ts
 import { dirname as dirname6 } from "path";
 async function openInFileManager(dirPath) {
-  const { execFile: execFile7 } = await import("child_process");
+  const { execFile: execFile8 } = await import("child_process");
   const platform2 = process.platform;
   if (platform2 === "darwin") {
-    execFile7("open", [dirPath]);
+    execFile8("open", [dirPath]);
   } else if (platform2 === "win32") {
-    execFile7("explorer", [dirPath]);
+    execFile8("explorer", [dirPath]);
   } else {
-    execFile7("xdg-open", [dirPath]);
+    execFile8("xdg-open", [dirPath]);
   }
 }
 async function revealInFileManager(filePath) {
-  const { execFile: execFile7 } = await import("child_process");
+  const { execFile: execFile8 } = await import("child_process");
   const platform2 = process.platform;
   if (platform2 === "darwin") {
-    execFile7("open", ["-R", filePath]);
+    execFile8("open", ["-R", filePath]);
   } else if (platform2 === "win32") {
-    execFile7("explorer", ["/select,", filePath]);
+    execFile8("explorer", ["/select,", filePath]);
   } else {
-    execFile7("xdg-open", [dirname6(filePath)]);
+    execFile8("xdg-open", [dirname6(filePath)]);
   }
 }
 var init_open_in_file_manager = __esm({
@@ -24114,14 +24745,14 @@ __export(keychain_exports, {
   keychainGet: () => keychainGet,
   keychainSet: () => keychainSet
 });
-import { execFile as execFile3 } from "child_process";
+import { execFile as execFile4 } from "child_process";
 import { platform } from "os";
 function makeService(pluginId) {
   return `${SERVICE_PREFIX}.${pluginId}`;
 }
 function exec(cmd, args) {
   return new Promise((resolve11) => {
-    execFile3(cmd, args, { timeout: 5e3 }, (error51, stdout) => {
+    execFile4(cmd, args, { timeout: 5e3 }, (error51, stdout) => {
       resolve11({ stdout: stdout.trim(), exitCode: error51 ? error51.status ?? 1 : 0 });
     });
   });
@@ -24173,7 +24804,7 @@ async function linuxGet(service, account) {
 }
 async function linuxSet(service, account, password) {
   return new Promise((resolve11) => {
-    const proc = execFile3("secret-tool", [
+    const proc = execFile4("secret-tool", [
       "store",
       "--label",
       `Hot Sheet: ${account}`,
@@ -25911,13 +26542,13 @@ var require_aspromise = __commonJS({
     "use strict";
     module.exports = asPromise;
     function asPromise(fn, ctx) {
-      var params = new Array(arguments.length - 1), offset = 0, index = 2, pending = true;
+      var params = new Array(arguments.length - 1), offset = 0, index = 2, pending2 = true;
       while (index < arguments.length)
         params[offset++] = arguments[index++];
       return new Promise(function executor(resolve11, reject2) {
         params[offset] = function callback(err) {
-          if (pending) {
-            pending = false;
+          if (pending2) {
+            pending2 = false;
             if (err)
               reject2(err);
             else {
@@ -25931,8 +26562,8 @@ var require_aspromise = __commonJS({
         try {
           fn.apply(ctx || null, params);
         } catch (err) {
-          if (pending) {
-            pending = false;
+          if (pending2) {
+            pending2 = false;
             reject2(err);
           }
         }
@@ -32719,7 +33350,7 @@ __export(processPriority_exports, {
   bumpProcessPriorityBestEffort: () => bumpProcessPriorityBestEffort,
   shouldBumpProcessPriority: () => shouldBumpProcessPriority
 });
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync } from "child_process";
 function shouldBumpProcessPriority(platform2) {
   return platform2 === "darwin";
 }
@@ -32731,7 +33362,7 @@ function bumpProcessPriorityBestEffort() {
   const args = buildTaskpolicyArgs(process.pid);
   let result;
   try {
-    result = spawnSync2("taskpolicy", args, { encoding: "utf8", timeout: 2e3 });
+    result = spawnSync("taskpolicy", args, { encoding: "utf8", timeout: 2e3 });
   } catch (err) {
     console.warn(`[priority] taskpolicy spawn failed: ${err instanceof Error ? err.message : String(err)}`);
     return false;
@@ -32758,7 +33389,7 @@ var init_processPriority = __esm({
 
 // src/cli.ts
 init_backup();
-import { execFile as execFile6 } from "child_process";
+import { execFile as execFile7 } from "child_process";
 import { existsSync as existsSync30, mkdirSync as mkdirSync18, realpathSync } from "fs";
 import { tmpdir as tmpdir3 } from "os";
 import { join as join36, resolve as resolve10 } from "path";
@@ -33197,18 +33828,18 @@ function isDemoMode() {
 import { execFileSync as execFileSync4 } from "child_process";
 var SHELL_PATH_TIMEOUT_MS = 2e3;
 function mergePaths(currentPath, shellPath) {
-  const sep = ":";
-  const existing = currentPath.split(sep).filter((s) => s !== "");
+  const sep2 = ":";
+  const existing = currentPath.split(sep2).filter((s) => s !== "");
   const existingSet = new Set(existing);
   const additions = [];
-  for (const dir of shellPath.split(sep)) {
+  for (const dir of shellPath.split(sep2)) {
     const trimmed = dir.trim();
     if (trimmed === "" || existingSet.has(trimmed)) continue;
     existingSet.add(trimmed);
     additions.push(trimmed);
   }
   if (additions.length === 0) return currentPath;
-  return [...additions, ...existing].join(sep);
+  return [...additions, ...existing].join(sep2);
 }
 function readLoginShellPath(execOverride) {
   const shell = process.env.SHELL;
@@ -33262,7 +33893,7 @@ init_lifecycle2();
 init_mime_types();
 init_projects();
 import { serve } from "@hono/node-server";
-import { execFile as execFile5 } from "child_process";
+import { execFile as execFile6 } from "child_process";
 import { existsSync as existsSync28, readFileSync as readFileSync22 } from "fs";
 import { Hono as Hono19 } from "hono";
 import { basename as basename5, dirname as dirname8, join as join34 } from "path";
@@ -33280,7 +33911,7 @@ init_helpers();
 init_notify();
 import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync14, rmSync as rmSync7, writeFileSync as writeFileSync13 } from "fs";
 import { Hono as Hono2 } from "hono";
-import { basename as basename3, extname, join as join26, resolve as resolve7 } from "path";
+import { basename as basename3, extname, join as join26, resolve as resolve7, sep } from "path";
 var attachmentRoutes = new Hono2();
 attachmentRoutes.post("/tickets/:id/attachments", async (c) => {
   const id = parseIntParam(c, "id");
@@ -33367,7 +33998,7 @@ attachmentRoutes.get("/attachments/file/*", (c) => {
   const dataDir = c.get("dataDir");
   const attachDir = resolve7(join26(dataDir, "attachments"));
   const fullPath = resolve7(join26(attachDir, filePath));
-  if (!fullPath.startsWith(attachDir + "/") && fullPath !== attachDir) {
+  if (!fullPath.startsWith(attachDir + sep) && fullPath !== attachDir) {
     return c.json({ error: "Invalid path" }, 403);
   }
   if (!existsSync19(fullPath)) {
@@ -33460,6 +34091,7 @@ function listAliveEntries(dataDir, isPidAlive3 = defaultIsPidAlive) {
 init_claude_hooks();
 init_commandLog();
 init_settings();
+init_ticketWorkIntervals();
 init_freezeLogger();
 init_file_settings();
 init_global_config();
@@ -33731,7 +34363,10 @@ channelRoutes.post("/channel/permission/dismiss", async (c) => {
 });
 channelRoutes.post("/channel/done", (_c) => {
   const secret = _c.get("projectSecret");
-  if (secret) channelDoneFlags.set(secret, true);
+  if (secret) {
+    channelDoneFlags.set(secret, true);
+    void closeOpenTicketIntervalsForProject(secret);
+  }
   addLogEntry("done", "incoming", "Claude finished", "").catch(() => {
   });
   notifyChange();
@@ -33829,6 +34464,7 @@ commandLogRoutes.get("/command-log/count", async (c) => {
 });
 
 // src/routes/dashboard.ts
+init_activeProjects();
 init_queries();
 init_stats();
 init_gitignore();
@@ -33844,6 +34480,7 @@ import { homedir as homedir6, tmpdir } from "os";
 import { join as join29, relative as relative2, resolve as resolve8 } from "path";
 var dashboardRoutes = new Hono5();
 dashboardRoutes.get("/poll", async (c) => {
+  markProjectActive(c.get("dataDir"));
   const clientVersion = Math.max(0, parseInt(c.req.query("version") ?? "0", 10) || 0);
   const changeVersion2 = getChangeVersion();
   if (changeVersion2 > clientVersion) {
@@ -34911,12 +35548,12 @@ import { Hono as Hono13 } from "hono";
 // src/db/repair.ts
 init_backup();
 init_pglite();
-import { execFile as execFile4 } from "child_process";
+import { execFile as execFile5 } from "child_process";
 import { cpSync as cpSync2, existsSync as existsSync26, mkdirSync as mkdirSync16, readFileSync as readFileSync21, rmSync as rmSync10, writeFileSync as writeFileSync18 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join32 } from "path";
-import { promisify as promisify2 } from "util";
-var execFileP = promisify2(execFile4);
+import { promisify as promisify3 } from "util";
+var execFileP = promisify3(execFile5);
 async function findWorkingBackup(dataDir) {
   const backups = listBackups(dataDir);
   for (const backup of backups) {
@@ -35107,6 +35744,7 @@ dbRoutes.post("/repair/run-pg-resetwal", async (c) => {
 });
 
 // src/routes/git.ts
+init_activeProjects();
 import { Hono as Hono14 } from "hono";
 import { join as join33 } from "path";
 
@@ -35168,18 +35806,19 @@ init_watcher();
 init_gitignore();
 init_open_in_file_manager();
 var gitRoutes = new Hono14();
-gitRoutes.get("/git/status", (c) => {
+gitRoutes.get("/git/status", async (c) => {
   const dataDir = c.get("dataDir");
+  markProjectActive(dataDir);
   const projectRoot3 = projectRootFromDataDir(dataDir);
   const settings = readFileSettings(dataDir);
   if (settings.git_tracking_enabled === false) {
     return c.json(null);
   }
   ensureGitWatcher(projectRoot3);
-  const status = getCachedGitStatus(projectRoot3);
+  const status = await getCachedGitStatus(projectRoot3);
   if (status === null) return c.json(null);
   if (c.req.query("files") === "true") {
-    const files = getGitStatusFiles(projectRoot3);
+    const files = await getGitStatusFiles(projectRoot3);
     return c.json({ ...status, files });
   }
   return c.json(status);
@@ -35187,14 +35826,14 @@ gitRoutes.get("/git/status", (c) => {
 function projectRootFromDataDir(dataDir) {
   return dataDir.replace(/[\\/]\.hotsheet\/?$/, "");
 }
-gitRoutes.post("/git/fetch", (c) => {
+gitRoutes.post("/git/fetch", async (c) => {
   const dataDir = c.get("dataDir");
   const projectRoot3 = projectRootFromDataDir(dataDir);
   const settings = readFileSettings(dataDir);
   if (settings.git_tracking_enabled === false) {
     return c.json({ ok: false, lastFetchedAt: null, error: "git tracking disabled in settings" });
   }
-  const result = runGitFetch(projectRoot3);
+  const result = await runGitFetch(projectRoot3);
   if (result.ok) dropGitStatusCache(projectRoot3);
   return c.json(result);
 });
@@ -38143,54 +38782,62 @@ async function getPromptTimeline(promptId) {
     spans
   };
 }
-async function getPerTicketRollup(ticketNumber) {
+async function getPerTicketRollup(ticketNumber, secret) {
   const db = await getTelemetryDb();
   const marker = `hotsheet:ticket=${ticketNumber}`;
-  const tagged = await db.query(
-    `SELECT DISTINCT prompt_id FROM otel_events
-     WHERE ${eventNameMatchSql("event_name", "user_prompt")}
-       AND prompt_id IS NOT NULL
-       AND body_json::text LIKE $1`,
-    [`%${marker}%`]
-  );
-  if (tagged.rows.length === 0) {
-    return { ticketNumber, promptCount: 0, totalCost: 0, totalTokens: 0, totalDurationSeconds: 0 };
-  }
-  const promptIds = tagged.rows.map((r) => r.prompt_id);
-  const sumsResult = await db.query(
-    `SELECT
-        SUM(COALESCE(
-          (attributes_json->>'cost')::numeric,
-          (attributes_json->>'cost_usd')::numeric,
-          0
-        )) AS total_cost,
-        SUM(COALESCE(
-          (attributes_json->>'tokens')::numeric,
-          (attributes_json->>'total_tokens')::numeric,
-          (attributes_json->>'input_tokens')::numeric + (attributes_json->>'output_tokens')::numeric,
-          0
-        )) AS total_tokens
-     FROM otel_events
-     WHERE ${eventNameMatchSql("event_name", "api_request")}
-       AND prompt_id = ANY($1::text[])`,
-    [promptIds]
-  );
-  const durationsResult = await db.query(
-    `SELECT SUM(EXTRACT(EPOCH FROM (max_ts - min_ts))) AS total_seconds
-     FROM (
-       SELECT MIN(ts) AS min_ts, MAX(ts) AS max_ts
-       FROM otel_events
-       WHERE prompt_id = ANY($1::text[])
-       GROUP BY prompt_id
-     ) AS per_prompt`,
-    [promptIds]
+  const secretParam = secret !== void 0 && secret !== "" ? secret : null;
+  const result = await db.query(
+    `WITH marker_prompts AS (
+       SELECT DISTINCT prompt_id FROM otel_events
+       WHERE ${eventNameMatchSql("event_name", "user_prompt")}
+         AND prompt_id IS NOT NULL
+         AND body_json::text LIKE $1
+     ),
+     matched AS (
+       SELECT
+         e.prompt_id,
+         e.ts,
+         COALESCE(
+           (e.attributes_json->>'cost')::numeric,
+           (e.attributes_json->>'cost_usd')::numeric,
+           0
+         ) AS cost,
+         COALESCE(
+           (e.attributes_json->>'tokens')::numeric,
+           (e.attributes_json->>'total_tokens')::numeric,
+           (e.attributes_json->>'input_tokens')::numeric + (e.attributes_json->>'output_tokens')::numeric,
+           0
+         ) AS tokens
+       FROM otel_events e
+       WHERE ${eventNameMatchSql("e.event_name", "api_request")}
+         AND (
+           e.prompt_id IN (SELECT prompt_id FROM marker_prompts)
+           OR (
+             $2::text IS NOT NULL AND e.project_secret = $2 AND EXISTS (
+               SELECT 1 FROM ticket_work_intervals i
+               WHERE i.project_secret = $2 AND i.ticket_number = $3
+                 AND e.ts >= i.started_at AND e.ts <= COALESCE(i.ended_at, NOW())
+             )
+           )
+         )
+     )
+     SELECT
+       (SELECT COUNT(DISTINCT prompt_id) FROM matched) AS prompt_count,
+       (SELECT COALESCE(SUM(cost), 0) FROM matched) AS total_cost,
+       (SELECT COALESCE(SUM(tokens), 0) FROM matched) AS total_tokens,
+       (SELECT COALESCE(SUM(dur), 0) FROM (
+          SELECT EXTRACT(EPOCH FROM (MAX(ts) - MIN(ts))) AS dur
+          FROM matched WHERE prompt_id IS NOT NULL GROUP BY prompt_id
+        ) per_prompt) AS total_seconds`,
+    [`%${marker}%`, secretParam, ticketNumber]
   );
+  const row = result.rows[0];
   return {
     ticketNumber,
-    promptCount: promptIds.length,
-    totalCost: Number(sumsResult.rows[0]?.total_cost ?? 0),
-    totalTokens: Number(sumsResult.rows[0]?.total_tokens ?? 0),
-    totalDurationSeconds: Number(durationsResult.rows[0]?.total_seconds ?? 0)
+    promptCount: Number(row.prompt_count ?? 0),
+    totalCost: Number(row.total_cost ?? 0),
+    totalTokens: Number(row.total_tokens ?? 0),
+    totalDurationSeconds: Number(row.total_seconds ?? 0)
   };
 }
 async function getDashboardPayload(window2, timezone = "UTC", allowedSecrets = null, now = /* @__PURE__ */ new Date()) {
@@ -38272,7 +38919,8 @@ telemetryRoutes.get("/telemetry/prompt/:id", async (c) => {
 });
 telemetryRoutes.get("/telemetry/ticket/:number", async (c) => {
   const ticketNumber = c.req.param("number");
-  const rollup = await getPerTicketRollup(ticketNumber);
+  const secret = c.get("projectSecret");
+  const rollup = await getPerTicketRollup(ticketNumber, secret);
   return c.json(rollup);
 });
 telemetryRoutes.get("/telemetry/enabled-anywhere", (c) => {
@@ -38614,7 +39262,7 @@ async function startServer(port, dataDir, options) {
 `);
   if (options?.noOpen !== true) {
     const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-    execFile5(openCmd, [url2]);
+    execFile6(openCmd, [url2]);
   }
   return actualPort;
 }
@@ -38792,8 +39440,12 @@ async function startAndConfigure(port, dataDir, strictPort) {
   const secret = ensureSecret(dataDir, actualPort);
   const { bumpProcessPriorityBestEffort: bumpProcessPriorityBestEffort2 } = await Promise.resolve().then(() => (init_processPriority(), processPriority_exports));
   bumpProcessPriorityBestEffort2();
-  const { startServerEventLoopHeartbeat: startServerEventLoopHeartbeat2 } = await Promise.resolve().then(() => (init_freezeLogger(), freezeLogger_exports));
+  const { startServerEventLoopHeartbeat: startServerEventLoopHeartbeat2, onServerWake: onServerWake2 } = await Promise.resolve().then(() => (init_freezeLogger(), freezeLogger_exports));
   startServerEventLoopHeartbeat2(dataDir);
+  const { getBackgroundScheduler: getBackgroundScheduler2 } = await Promise.resolve().then(() => (init_backgroundScheduler(), backgroundScheduler_exports));
+  onServerWake2(() => {
+    getBackgroundScheduler2().noteWake();
+  });
   initMarkdownSync(dataDir, actualPort);
   scheduleAllSync(dataDir);
   const { runWithDataDir: runWith } = await Promise.resolve().then(() => (init_connection(), connection_exports));
@@ -38842,7 +39494,7 @@ async function postStartup(dataDir, actualPort, demo, noOpen) {
   if (!noOpen) {
     const url2 = `http://localhost:${actualPort}`;
     const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-    execFile6(openCmd, [url2]);
+    execFile7(openCmd, [url2]);
   }
 }
 async function restorePreviousProjects(dataDir, actualPort) {