agent-lookout 0.2.1 → 0.2.3

package/dist/cli/{startCommand-ZV2NQ6YG.js → startCommand-H6O35VYR.js}

@@ -1,9 +1,12 @@
 import {
   sortSessions
-} from "./chunk-XJM5RZNV.js";
+} from "./chunk-54ODUY75.js";
 import {
+  EVENT_KINDS,
+  EVENT_SEVERITIES,
   MAX_NAME_LENGTH,
   MAX_NOTICE_TEXT_LENGTH,
+  SESSION_STATUSES,
   agentName,
   changeNotice,
   clean,
@@ -21,7 +24,7 @@ import {
   waitingPhrase,
   waitingText,
   withoutWaitingText
-} from "./chunk-PQ3B5TN6.js";
+} from "./chunk-GOX5UB5L.js";
 
 // src/collector/hosts/server.ts
 import { createServer } from "node:http";
@@ -158,6 +161,7 @@ function sessionChanges(memory, snapshot) {
 }
 
 // src/core/api.ts
+var CLEAR_HISTORY_ACTION = "clear-history";
 var TERMINAL_JUMP_TIMEOUT_MS = 6e4;
 var JUMP_INTERVAL_MS = 1e3;
 var ACTION_HEADER = "X-Agent-Lookout-Action";
@@ -212,12 +216,12 @@ function waitBegan(statusSince, seenAt) {
 
 // src/collector/outbound/outboundChannel.ts
 function createOutboundChannel(options) {
-  const { afterMs, waitMessage, overMessage, failure: failure2 } = options;
+  const { afterMs, asking, waitMessage, overMessage, failure: failure2 } = options;
   const now = options.now ?? Date.now;
   const wanted = new Set(options.events);
   let memory = EMPTY_CHANGE_MEMORY;
   const over = [];
-  const open3 = /* @__PURE__ */ new Map();
+  const open4 = /* @__PURE__ */ new Map();
   const done = /* @__PURE__ */ new Map();
   let sentAt = [];
   let last = null;
@@ -238,16 +242,21 @@ function createOutboundChannel(options) {
         const at = now();
         const result = sessionChanges(memory, snapshot);
         memory = result.memory;
-        for (const id of result.stopped) open3.delete(id);
+        for (const id of result.stopped) open4.delete(id);
         for (const { event, session } of result.changes) {
           if (!wanted.has(event)) continue;
           if (event !== "needs-you") {
-            over.push({ event, session, agent: agentName(session, snapshot.sources), seenAt: at });
+            over.push({
+              event,
+              session: withoutWaitingText(session),
+              agent: agentName(session, snapshot.sources),
+              seenAt: at
+            });
             continue;
           }
           const since = session.statusSince;
           if (since !== null && done.get(session.id) === since) continue;
-          open3.set(session.id, waitBegan(since, at));
+          open4.set(session.id, waitBegan(since, at));
         }
         sentAt = sendsInLastHour(sentAt, at);
         while (over.length > 0 && limitLiftsAt(sentAt, at) === null) {
@@ -255,19 +264,26 @@ function createOutboundChannel(options) {
           sentAt.push(at);
           send2(overMessage({ ...facts, now: at }));
         }
-        for (const [id, begunAt] of open3) {
+        for (const [id, begunAt] of open4) {
           const session = snapshot.sessions.find(
             (candidate) => candidate.id === id && candidate.status === "needs-you"
           );
           if (!session || sendTiming(begunAt, afterMs, sentAt, at) !== "send") continue;
-          open3.delete(id);
+          open4.delete(id);
           sentAt.push(at);
           send2(
-            waitMessage({ session, agent: agentName(session, snapshot.sources), begunAt, now: at })
+            waitMessage({
+              session: withoutWaitingText(session),
+              agent: agentName(session, snapshot.sources),
+              // Read now, from this poll's snapshot, and only when it is to go.
+              asking: asking ? waitingText(session.waitingText) ?? null : null,
+              begunAt,
+              now: at
+            })
           );
         }
         for (const session of snapshot.sessions) {
-          if (session.status === "needs-you" && session.statusSince !== null && !open3.has(session.id)) {
+          if (session.status === "needs-you" && session.statusSince !== null && !open4.has(session.id)) {
             done.set(session.id, session.statusSince);
           }
         }
@@ -310,6 +326,13 @@ function readEvents(name, value) {
   }
   return events;
 }
+function readAsking(name, value) {
+  if (value === void 0) return false;
+  const said = value.toLowerCase();
+  if (said === "on") return true;
+  if (said === "off") return false;
+  throw new SettingProblem(`${name} must be on or off.`);
+}
 
 // src/collector/email/emailSettings.ts
 var EMAIL_TO_ENV = "AGENT_LOOKOUT_EMAIL_TO";
@@ -317,6 +340,7 @@ var SMTP_URL_ENV = "AGENT_LOOKOUT_SMTP_URL";
 var EMAIL_FROM_ENV = "AGENT_LOOKOUT_EMAIL_FROM";
 var EMAIL_AFTER_ENV = "AGENT_LOOKOUT_EMAIL_AFTER";
 var EMAIL_EVENTS_ENV = "AGENT_LOOKOUT_EMAIL_EVENTS";
+var EMAIL_ASKING_ENV = "AGENT_LOOKOUT_EMAIL_ASKING";
 var ADDRESS = /^[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?)+$/;
 var MAX_ADDRESS_LENGTH = 254;
 var HOST_NAME = /^[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*$/;
@@ -375,6 +399,7 @@ function readEmailSetup(env) {
   const from = valueOf(env, EMAIL_FROM_ENV);
   const after = valueOf(env, EMAIL_AFTER_ENV);
   const events = valueOf(env, EMAIL_EVENTS_ENV);
+  const asking = valueOf(env, EMAIL_ASKING_ENV);
   if (to === void 0) return { on: false, problem: null };
   if (url === void 0) return { on: false, problem: `${SMTP_URL_ENV} is not set.` };
   try {
@@ -385,6 +410,7 @@ function readEmailSetup(env) {
         from: from === void 0 ? to : readAddress(EMAIL_FROM_ENV, from),
         events: readEvents(EMAIL_EVENTS_ENV, events),
         afterMs: readAfter(EMAIL_AFTER_ENV, after),
+        asking: readAsking(EMAIL_ASKING_ENV, asking),
         server: readServer(url)
       }
     };
@@ -402,8 +428,10 @@ function maskAddress(address) {
 }
 
 // src/collector/email/emailMessage.ts
-function emailOf(happened, when, session, agentName2) {
+function emailOf(happened, when, session, agentName2, asking = null) {
   const lines = [`${happened}.`, "", when, ""];
+  const said = waitingText(asking);
+  if (said) lines.push(`Asking: ${said}`);
   const folder = session.project ? oneLine(session.project) : "";
   if (folder) lines.push(`Folder: ${folder}`);
   const app = surfaceLabel(session.surface);
@@ -423,7 +451,8 @@ function waitEmail(facts) {
     `${oneLine(sessionTitle(session))} ${waitingPhrase(session)}`,
     `It has waited ${durationInWords(now - begunAt)}, since ${clockAt(begunAt, now)}.`,
     session,
-    facts.agent
+    facts.agent,
+    facts.asking
   );
 }
 function overEmail(facts) {
@@ -443,6 +472,7 @@ function emailOffStatus(problem) {
     to: null,
     events: null,
     afterMs: null,
+    asking: null,
     problem,
     last: null,
     limitedUntil: null
@@ -453,6 +483,7 @@ function createEmailNotifications(options) {
   const channel = createOutboundChannel({
     events: settings.events,
     afterMs: settings.afterMs,
+    asking: settings.asking,
     waitMessage: waitEmail,
     overMessage: overEmail,
     send: (content) => sender.send(content),
@@ -467,6 +498,7 @@ function createEmailNotifications(options) {
         to: maskAddress(settings.to),
         events: [...settings.events],
         afterMs: settings.afterMs,
+        asking: settings.asking,
         problem: null,
         last: channel.last(),
         limitedUntil: channel.limitedUntil()
@@ -476,6 +508,207 @@ function createEmailNotifications(options) {
   };
 }
 
+// src/collector/history/historyFormat.ts
+var HISTORY_FORMAT_VERSION = 1;
+var MAX_LINE_LENGTH = 8 * 1024;
+var MAX_FIELD_LENGTH = 1024;
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var FILE_NAME = /^v([1-9]\d{0,3})-(\d{4})-(\d{2})-(\d{2})(?:-([1-9]\d{0,3}))?\.jsonl$/;
+function dayOf(at) {
+  return new Date(at).toISOString().slice(0, 10);
+}
+function historyFileName(day, part = 1) {
+  const suffix = part > 1 ? `-${part}` : "";
+  return `v${HISTORY_FORMAT_VERSION}-${day}${suffix}.jsonl`;
+}
+function readHistoryFileName(name) {
+  const match = FILE_NAME.exec(name);
+  if (!match) return null;
+  const [, version, year, month, date, part] = match;
+  const day = `${year}-${month}-${date}`;
+  const dayStart = Date.parse(`${day}T00:00:00.000Z`);
+  if (!Number.isFinite(dayStart) || dayOf(dayStart) !== day) return null;
+  return { name, version: Number(version), day, dayStart, part: part ? Number(part) : 1 };
+}
+function byFileOrder(a, b) {
+  return a.dayStart - b.dayStart || a.part - b.part;
+}
+function dayEnd(file) {
+  return file.dayStart + DAY_MS;
+}
+function recordAt(record) {
+  if (record.kind === "point") return record.point.at;
+  if (record.kind === "event") return record.event.at;
+  return record.at;
+}
+function encodeRecord(record) {
+  return `${JSON.stringify(recordValue(record))}
+`;
+}
+function recordValue(record) {
+  switch (record.kind) {
+    case "start":
+      return { start: record.at };
+    case "cleared":
+      return { cleared: record.at };
+    case "point": {
+      const { at, needsYou, working, idle, total } = record.point;
+      return { point: [at, needsYou, working, idle, total] };
+    }
+    case "event":
+      return { event: eventFields(record.event) };
+  }
+}
+function eventFields(event) {
+  const { id, at, sessionId, sessionName: sessionName2, kind, from, to, severity } = event;
+  return {
+    id,
+    at,
+    sessionId,
+    sessionName: sessionName2,
+    kind,
+    ...from !== void 0 && { from },
+    ...to !== void 0 && { to },
+    severity
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function moment(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+function count(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function field(value) {
+  return typeof value === "string" && value !== "" && value.length <= MAX_FIELD_LENGTH ? value : null;
+}
+function oneOf(list, value) {
+  return list.find((item) => item === value) ?? null;
+}
+function readPoint(value) {
+  if (!Array.isArray(value) || value.length !== 5) return null;
+  const at = moment(value[0]);
+  const [needsYou, working, idle, total] = value.slice(1).map(count);
+  if (at === null || needsYou == null || working == null || idle == null || total == null) {
+    return null;
+  }
+  return { at, needsYou, working, idle, total };
+}
+function readEvent(value) {
+  if (!isRecord(value)) return null;
+  const id = field(value.id);
+  const at = moment(value.at);
+  const sessionId = field(value.sessionId);
+  const sessionName2 = field(value.sessionName);
+  const kind = oneOf(EVENT_KINDS, value.kind);
+  const severity = oneOf(EVENT_SEVERITIES, value.severity);
+  if (!id || at === null || !sessionId || !sessionName2 || !kind || !severity) return null;
+  const from = oneOf(SESSION_STATUSES, value.from);
+  const to = oneOf(SESSION_STATUSES, value.to);
+  if (value.from !== void 0 && !from || value.to !== void 0 && !to) return null;
+  return {
+    id,
+    at,
+    sessionId,
+    sessionName: sessionName2,
+    kind,
+    ...from && { from },
+    ...to && { to },
+    severity
+  };
+}
+function parseRecord(line) {
+  if (line === "" || line.length > MAX_LINE_LENGTH) return null;
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isRecord(value)) return null;
+  if ("point" in value) {
+    const point = readPoint(value.point);
+    return point && { kind: "point", point };
+  }
+  if ("event" in value) {
+    const event = readEvent(value.event);
+    return event && { kind: "event", event };
+  }
+  if ("start" in value) {
+    const at = moment(value.start);
+    return at === null ? null : { kind: "start", at };
+  }
+  if ("cleared" in value) {
+    const at = moment(value.cleared);
+    return at === null ? null : { kind: "cleared", at };
+  }
+  return null;
+}
+function restartsAmong(starts, times) {
+  const ordered = [...times].sort((a, b) => a - b);
+  const restarts = [];
+  let next = 0;
+  let lastBefore = null;
+  for (const at of [...new Set(starts)].sort((a, b) => a - b)) {
+    while (next < ordered.length && ordered[next] < at) {
+      lastBefore = ordered[next];
+      next += 1;
+    }
+    if (lastBefore !== null) restarts.push({ at, lastBefore });
+  }
+  return restarts;
+}
+function parseHistoryText(text4) {
+  const records = [];
+  let skipped = 0;
+  for (const line of text4.split("\n")) {
+    if (line.trim() === "") continue;
+    const record = parseRecord(line.trim());
+    if (record) records.push(record);
+    else skipped += 1;
+  }
+  return { records, skipped };
+}
+
+// src/collector/history/historyLimits.ts
+var HISTORY_MAX_BYTES = 20 * 1024 * 1024;
+var HISTORY_MAX_FILE_BYTES = 2 * 1024 * 1024;
+var HISTORY_MAX_AGE_MS = 8 * 24 * 60 * 60 * 1e3;
+function memoryOnlyStatus() {
+  return {
+    where: "memory",
+    folder: null,
+    bytes: null,
+    maxBytes: HISTORY_MAX_BYTES,
+    maxAgeMs: HISTORY_MAX_AGE_MS,
+    canClear: false,
+    problem: null
+  };
+}
+function filesToDelete(files, writingTo, incoming, limits) {
+  const ordered = [...files].sort(byFileOrder);
+  const doomed = [];
+  let total = 0;
+  const left = [];
+  for (const file of ordered) {
+    if (file.name !== writingTo && dayEnd(file) + limits.maxAgeMs < limits.now) {
+      doomed.push(file.name);
+    } else {
+      left.push(file);
+      total += file.size;
+    }
+  }
+  for (const file of left) {
+    if (total + incoming <= limits.maxBytes) break;
+    if (file.name === writingTo) continue;
+    doomed.push(file.name);
+    total -= file.size;
+  }
+  return doomed;
+}
+
 // src/collector/historyStore.ts
 var HISTORY_CAPACITY = 10800;
 function createHistoryStore(capacity = HISTORY_CAPACITY) {
@@ -492,6 +725,9 @@ function createHistoryStore(capacity = HISTORY_CAPACITY) {
       while (start > 0 && points[start - 1].at >= from) start -= 1;
       return points.slice(start);
     },
+    clear() {
+      points = [];
+    },
     get size() {
       return points.length;
     }
@@ -609,6 +845,7 @@ function createPoller(options) {
   let inFlight = null;
   let timer = null;
   const memory = /* @__PURE__ */ new Map();
+  const resumed = /* @__PURE__ */ new Map();
   const overdue = /* @__PURE__ */ new Map();
   const settled = /* @__PURE__ */ new Map();
   function stillWaiting(adapter, since) {
@@ -625,11 +862,11 @@ function createPoller(options) {
     };
   }
   function ask(adapter) {
-    const open3 = overdue.get(adapter);
-    if (open3) {
-      if (open3.late === void 0) return Promise.resolve(stillWaiting(adapter, open3.since));
+    const open4 = overdue.get(adapter);
+    if (open4) {
+      if (open4.late === void 0) return Promise.resolve(stillWaiting(adapter, open4.since));
       overdue.delete(adapter);
-      return Promise.resolve(open3.late);
+      return Promise.resolve(open4.late);
     }
     const since = now();
     return new Promise((resolve) => {
@@ -683,9 +920,12 @@ function createPoller(options) {
       if (state !== "ok" && state !== "not-set-up") return;
       const id = adapters[index].id;
       let remembered = memory.get(id);
+      let lastSeen;
       if (!remembered) {
         remembered = { baselines: /* @__PURE__ */ new Map(), reported: /* @__PURE__ */ new Map() };
         memory.set(id, remembered);
+        lastSeen = resumed.get(id);
+        resumed.delete(id);
       }
       const { baselines, reported } = remembered;
       const basis = result.basis ?? "";
@@ -693,6 +933,14 @@ function createPoller(options) {
       if (previous) {
         changes.push(...withoutRepeats(diffSessions(previous, result.sessions, at), reported));
       } else {
+        if (lastSeen) {
+          const known = new Set(lastSeen.map((session) => session.id));
+          const before = lastSeen.filter(
+            (session) => session.status !== null
+          );
+          const after = result.sessions.filter((session) => known.has(session.id));
+          changes.push(...diffSessions(before, after, at));
+        }
         for (const session of result.sessions) {
           if (!reported.has(session.id)) reported.set(session.id, session.status);
         }
@@ -746,6 +994,24 @@ function createPoller(options) {
       timer = null;
     },
     pollOnce,
+    resume(kept) {
+      const newest2 = /* @__PURE__ */ new Map();
+      for (const event of kept) {
+        const held = newest2.get(event.sessionId);
+        if (!held || event.at >= held.at) newest2.set(event.sessionId, event);
+      }
+      resumed.clear();
+      for (const event of newest2.values()) {
+        const status = event.kind === "ended" ? null : event.to ?? null;
+        if (event.kind !== "ended" && status === null) continue;
+        const colon = event.sessionId.indexOf(":");
+        if (colon <= 0) continue;
+        const source = event.sessionId.slice(0, colon);
+        const list = resumed.get(source) ?? [];
+        list.push({ id: event.sessionId, name: event.sessionName, status });
+        resumed.set(source, list);
+      }
+    },
     getSnapshot() {
       if (latest) return latest;
       const at = now();
@@ -786,10 +1052,13 @@ function lineOf(happened, facts) {
 }
 function waitPost(facts) {
   const { begunAt, now } = facts;
+  const asking = waitingText(facts.asking);
   const session = sessionOf(facts.session, facts.agent);
   const waitedMs = Math.max(0, now - begunAt);
+  const happened = `${session.name} ${waitingPhrase(facts.session)}`;
   return {
-    text: lineOf(`${session.name} ${waitingPhrase(facts.session)}`, [
+    // In `text` it is made safe for Slack with the rest.
+    text: lineOf(asking ? `${happened}: ${asking}` : happened, [
       formatDuration(waitedMs),
       session.folder,
       session.app,
@@ -797,6 +1066,8 @@ function waitPost(facts) {
     ]),
     event: "needs-you",
     reason: facts.session.waitingReason ?? "other",
+    // Left out, not null, when it does not go, so a post without it is the post it always was.
+    ...asking ? { asking } : {},
     session,
     at: new Date(begunAt).toISOString(),
     waitedSeconds: Math.floor(waitedMs / 1e3)
@@ -823,6 +1094,7 @@ function webhookOffStatus(problem) {
     host: null,
     events: null,
     afterMs: null,
+    asking: null,
     problem,
     last: null,
     limitedUntil: null
@@ -833,6 +1105,7 @@ function createWebhookNotifications(options) {
   const channel = createOutboundChannel({
     events: settings.events,
     afterMs: settings.afterMs,
+    asking: settings.asking,
     waitMessage: waitPost,
     overMessage: overPost,
     send: (post) => sender.send(post),
@@ -848,6 +1121,7 @@ function createWebhookNotifications(options) {
         host: settings.url.hostname,
         events: [...settings.events],
         afterMs: settings.afterMs,
+        asking: settings.asking,
         problem: null,
         last: channel.last(),
         limitedUntil: channel.limitedUntil()
@@ -859,6 +1133,7 @@ function createWebhookNotifications(options) {
 
 // src/collector/handler.ts
 var JUMP_PATH = "/api/jump";
+var CLEAR_HISTORY_PATH = "/api/history/clear";
 var MAX_HISTORY_WINDOW_MS = HISTORY_CAPACITY * POLL_INTERVAL_MS;
 var LOOPBACK_HOST = /^(localhost|127\.0\.0\.1|\[::1\])(:\d{1,5})?$/i;
 var LOOPBACK_ORIGIN = /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d{1,5})?$/i;
@@ -886,6 +1161,66 @@ function refusalFor(req) {
   }
   return null;
 }
+function header(req, name) {
+  const value = req.headers[name.toLowerCase()];
+  return typeof value === "string" ? value : void 0;
+}
+function refusal(status, error, headers = {}) {
+  return {
+    status,
+    body: { error },
+    headers: { Connection: "close", ...headers }
+  };
+}
+function actionRefusalFor(req, action, maxBodyBytes) {
+  if (req.method !== "POST") {
+    return refusal(405, "This address only answers POST requests.", { Allow: "POST" });
+  }
+  const origin = header(req, "origin");
+  if (origin === void 0 || !isLoopbackOrigin(origin)) {
+    return refusal(403, "This address only acts for the dashboard page served from this machine.");
+  }
+  const site = req.headers["sec-fetch-site"];
+  if (site !== void 0 && site !== "same-origin") {
+    return refusal(403, "This address only acts for the dashboard page served from this machine.");
+  }
+  if (header(req, ACTION_HEADER) !== action) {
+    return refusal(
+      403,
+      `A request to this address must carry the header ${ACTION_HEADER}: ${action}.`
+    );
+  }
+  const contentType = header(req, "content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+  if (contentType !== "application/json") {
+    return refusal(415, "The body must be JSON, sent as application/json.");
+  }
+  const length = header(req, "content-length");
+  if (length !== void 0 && (!/^\d+$/.test(length) || Number(length) > maxBodyBytes)) {
+    return refusal(413, `The body must be no more than ${maxBodyBytes} bytes.`);
+  }
+  return null;
+}
+function readRequestBody(req, limit) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let received = 0;
+    let done = false;
+    const finish = (body) => {
+      if (done) return;
+      done = true;
+      resolve(body);
+    };
+    req.on("data", (chunk) => {
+      if (done) return;
+      received += chunk.byteLength;
+      if (received > limit) finish({ ok: false, tooLarge: true });
+      else chunks.push(chunk);
+    });
+    req.on("end", () => finish({ ok: true, text: Buffer.concat(chunks).toString("utf8") }));
+    req.on("error", () => finish({ ok: false, tooLarge: false }));
+    req.on("close", () => finish({ ok: false, tooLarge: false }));
+  });
+}
 function send(res, status, body, headers = {}) {
   for (const name of res.getHeaderNames()) {
     if (name.toLowerCase().startsWith("access-control-")) res.removeHeader(name);
@@ -921,10 +1256,13 @@ function numberParam(value) {
 function createApiHandler(options) {
   const { version, poller, events, history, notifications, email, webhook, jump } = options;
   const now = options.now ?? Date.now;
+  const actions = /* @__PURE__ */ new Map();
+  if (jump) actions.set(JUMP_PATH, jump);
+  if (options.clearHistory) actions.set(CLEAR_HISTORY_PATH, options.clearHistory);
   function route(req, res) {
-    const refusal = refusalFor(req);
-    if (refusal) {
-      fail(res, 403, refusal);
+    const refusal2 = refusalFor(req);
+    if (refusal2) {
+      fail(res, 403, refusal2);
       return;
     }
     let url;
@@ -933,8 +1271,9 @@ function createApiHandler(options) {
     } catch {
       url = null;
     }
-    if (jump && url?.pathname === JUMP_PATH) {
-      jump(req).then((answer) => send(res, answer.status, answer.body, answer.headers)).catch(() => {
+    const action = url === null ? void 0 : actions.get(url.pathname);
+    if (action) {
+      action(req).then((answer2) => send(res, answer2.status, answer2.body, answer2.headers)).catch(() => {
         if (res.headersSent) res.end();
         else fail(res, 500, "The collector ran into an unexpected problem.");
       }).catch(() => {
@@ -988,24 +1327,49 @@ function createApiHandler(options) {
           return;
         }
         const windowMs = Math.min(requested ?? DEFAULT_HISTORY_WINDOW_MS, MAX_HISTORY_WINDOW_MS);
+        const held = options.historyKept?.();
+        const since = held?.since ?? { at: poller.startedAt, by: "started" };
         send(res, 200, {
           points: history.list(windowMs, now()),
-          startedAt: poller.startedAt
+          startedAt: poller.startedAt,
+          since,
+          kept: held?.kept ?? memoryOnlyStatus(),
+          // A restart before where the history now begins was cleared, or let go.
+          restarts: (held?.restarts ?? []).filter((restart) => restart.at > since.at)
         });
         return;
       }
+      case "/api/waits": {
+        if (options.waits) {
+          send(res, 200, options.waits());
+          return;
+        }
+        fail(res, 404, "There is nothing at that address.");
+        return;
+      }
       default: {
         fail(res, 404, "There is nothing at that address.");
       }
     }
   }
-  return (req, res) => {
+  function answer(req, res) {
     try {
       route(req, res);
     } catch {
       if (res.headersSent) res.end();
       else fail(res, 500, "The collector ran into an unexpected problem.");
     }
+  }
+  return (req, res) => {
+    const reading = options.ready?.() ?? null;
+    if (reading === null) {
+      answer(req, res);
+      return;
+    }
+    void reading.then(
+      () => answer(req, res),
+      () => answer(req, res)
+    );
   };
 }
 
@@ -1223,7 +1587,229 @@ function urlFor(address) {
 
 // src/collector/hosts/standalone.ts
 import { existsSync } from "node:fs";
-import path14 from "node:path";
+import path16 from "node:path";
+
+// src/core/waits/measured.ts
+var POLL_GAP_MS = 8e3;
+function pollRuns(times, starts, gapMs = POLL_GAP_MS) {
+  const ordered = [...times].sort((a, b) => a - b);
+  const breaks = [...starts].sort((a, b) => a - b);
+  const runs = [];
+  let next = 0;
+  for (const at of ordered) {
+    const run = runs[runs.length - 1];
+    let restarted = false;
+    while (next < breaks.length && breaks[next] <= at) {
+      if (run && breaks[next] > run.to) restarted = true;
+      next += 1;
+    }
+    if (run && !restarted && at - run.to <= gapMs) run.to = Math.max(run.to, at);
+    else runs.push({ from: at, to: at });
+  }
+  return runs;
+}
+function addPoll(runs, at, fresh = false, gapMs = POLL_GAP_MS) {
+  const run = runs[runs.length - 1];
+  if (run && !fresh && at >= run.to && at - run.to <= gapMs) {
+    run.to = at;
+  } else if (!run || fresh || at > run.to) {
+    runs.push({ from: at, to: at });
+  }
+}
+function joined(spans) {
+  const ordered = spans.filter((span) => span.to >= span.from).sort((a, b) => a.from - b.from);
+  const out = [];
+  for (const span of ordered) {
+    const last = out[out.length - 1];
+    if (last && span.from <= last.to) last.to = Math.max(last.to, span.to);
+    else out.push({ ...span });
+  }
+  return out;
+}
+function coveredWithin(spans, from, to) {
+  if (to <= from) return 0;
+  let low = 0;
+  let high = spans.length;
+  while (low < high) {
+    const middle = low + high >> 1;
+    if (spans[middle].to <= from) low = middle + 1;
+    else high = middle;
+  }
+  let sum = 0;
+  for (let index = low; index < spans.length; index += 1) {
+    const span = spans[index];
+    if (span.from >= to) break;
+    sum += Math.min(span.to, to) - Math.max(span.from, from);
+  }
+  return sum;
+}
+
+// src/core/waits/waitTotals.ts
+var MAX_WAIT_SESSIONS = 10;
+var WAIT_DAYS = 7;
+function isWaitEvent(event) {
+  return event.to === "needs-you" || event.from === "needs-you";
+}
+function unendedWaits(events) {
+  const newest2 = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (!isWaitEvent(event)) continue;
+    const held = newest2.get(event.sessionId);
+    if (!held || event.at >= held.at) newest2.set(event.sessionId, event);
+  }
+  return [...newest2.values()].filter((event) => event.kind !== "ended" && event.to === "needs-you");
+}
+function midnightOf(at) {
+  const date = new Date(at);
+  date.setHours(0, 0, 0, 0);
+  return date.getTime();
+}
+function midnightAfter(midnight, days) {
+  const date = new Date(midnight);
+  date.setDate(date.getDate() + days);
+  date.setHours(0, 0, 0, 0);
+  return date.getTime();
+}
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+function localDay(at) {
+  const date = new Date(at);
+  return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
+}
+function latestAtOrBefore(starts, at, fallback) {
+  let found = fallback;
+  for (const start of starts) {
+    if (start > at) break;
+    found = Math.max(found, start);
+  }
+  return found;
+}
+function waitsOf(input) {
+  const { now, since } = input;
+  const starts = [...input.runStarts].sort((a, b) => a - b);
+  const runStart = (at) => latestAtOrBefore(starts, at, since);
+  const waitingNow = new Map(input.waitingNow.map((session) => [session.id, session.name]));
+  const thisRun = runStart(now);
+  const bySession = /* @__PURE__ */ new Map();
+  for (const event of input.events) {
+    if (!isWaitEvent(event) || event.at > now) continue;
+    const own = bySession.get(event.sessionId);
+    if (own) own.push(event);
+    else bySession.set(event.sessionId, [event]);
+  }
+  const waits = [];
+  const names = /* @__PURE__ */ new Map();
+  const unended = /* @__PURE__ */ new Set();
+  for (const [sessionId, own] of bySession) {
+    own.sort((a, b) => a.at - b.at);
+    let began = null;
+    let previous = null;
+    for (const event of own) {
+      if (began === null && event.from === "needs-you") {
+        began = Math.max(runStart(event.at), previous ?? -Infinity);
+      }
+      const waitsAfter = event.kind !== "ended" && event.to === "needs-you";
+      if (began !== null && !waitsAfter) {
+        waits.push({ sessionId, from: began, to: event.at, open: false });
+        began = null;
+      } else if (began === null && waitsAfter) {
+        began = event.at;
+      }
+      previous = event.at;
+      names.set(sessionId, event.sessionName);
+    }
+    if (began !== null) {
+      const open4 = waitingNow.has(sessionId);
+      waits.push({ sessionId, from: began, to: open4 || began >= thisRun ? now : thisRun, open: open4 });
+      unended.add(sessionId);
+    }
+  }
+  for (const [sessionId, name] of input.names ?? []) names.set(sessionId, name);
+  for (const [sessionId, name] of waitingNow) {
+    names.set(sessionId, name);
+    if (unended.has(sessionId)) continue;
+    const own = bySession.get(sessionId);
+    const last = own?.[own.length - 1]?.at ?? -Infinity;
+    waits.push({ sessionId, from: Math.max(thisRun, last), to: now, open: true });
+  }
+  const kept = waits.map((wait) => ({ ...wait, from: Math.max(wait.from, since) })).filter((wait) => wait.to > wait.from);
+  kept.sort((a, b) => a.from - b.from);
+  return { waits: kept, names };
+}
+function totalIn(waits, measured, from, to) {
+  let waitedMs = 0;
+  let openMs = 0;
+  let count2 = 0;
+  const bySession = /* @__PURE__ */ new Map();
+  for (const wait of waits) {
+    if (wait.from >= to) break;
+    if (wait.to <= from) continue;
+    const ms = coveredWithin(measured, Math.max(wait.from, from), Math.min(wait.to, to));
+    if (ms <= 0) continue;
+    waitedMs += ms;
+    count2 += 1;
+    if (wait.open) openMs += ms;
+    const own = bySession.get(wait.sessionId) ?? { ms: 0, waits: 0, open: false };
+    own.ms += ms;
+    own.waits += 1;
+    own.open ||= wait.open;
+    bySession.set(wait.sessionId, own);
+  }
+  return {
+    total: { waitedMs, openMs, waits: count2, measuredMs: coveredWithin(measured, from, to) },
+    bySession
+  };
+}
+function periodOf(waits, measured, names, from, to) {
+  const { total, bySession } = totalIn(waits, measured, from, to);
+  const days = [];
+  for (let start = from; start < to; ) {
+    const end = Math.min(midnightAfter(midnightOf(start), 1), to);
+    days.push({
+      day: localDay(start),
+      from: start,
+      to: end,
+      ...totalIn(waits, measured, start, end).total
+    });
+    start = end;
+  }
+  if (days.length === 0) {
+    days.push({ day: localDay(from), from, to, waitedMs: 0, openMs: 0, waits: 0, measuredMs: 0 });
+  }
+  const sessions = [...bySession].map(([sessionId, own]) => ({
+    sessionId,
+    name: names.get(sessionId) ?? sessionId,
+    waitedMs: own.ms,
+    waits: own.waits,
+    open: own.open
+  })).sort((a, b) => b.waitedMs - a.waitedMs || a.name.localeCompare(b.name));
+  return {
+    from,
+    to,
+    ...total,
+    days,
+    sessions: sessions.slice(0, MAX_WAIT_SESSIONS),
+    sessionCount: sessions.length
+  };
+}
+function waitTotals(input) {
+  const { now, since } = input;
+  const gapMs = input.gapMs ?? POLL_GAP_MS;
+  const spans = joined(input.measured);
+  const newest2 = spans[spans.length - 1];
+  if (newest2 && newest2.to < now && now - newest2.to <= gapMs && !input.runStarts.some((start) => start > newest2.to && start <= now)) {
+    newest2.to = now;
+  }
+  const measured = spans.map((span) => ({ from: Math.max(span.from, since), to: Math.min(span.to, now) })).filter((span) => span.to > span.from);
+  const { waits, names } = waitsOf(input);
+  const today = midnightOf(now);
+  const weekStart = midnightAfter(today, -(WAIT_DAYS - 1));
+  return {
+    today: periodOf(waits, measured, names, today, now),
+    sevenDays: periodOf(waits, measured, names, weekStart, now)
+  };
+}
 
 // src/collector/adapters/claude-code/index.ts
 import os from "node:os";
@@ -1893,7 +2479,7 @@ function build(fields, origin, context) {
   const project = projectOf(fields.cwd);
   const surface = mapClaudeCodeSurface(fields.entrypoint);
   const mapped = mapClaudeCodeStatus(fields, origin);
-  const open3 = claudeCodeOpenLink(surface, fields.sessionId);
+  const open4 = claudeCodeOpenLink(surface, fields.sessionId);
   const startedAt = plausibleTime(fields.startedAt, context.now);
   let statusSince = plausibleTime(fields.statusUpdatedAt, context.now);
   if (statusSince !== null && startedAt !== null && statusSince < startedAt - WRITE_ORDER_SLACK_MS) {
@@ -1910,7 +2496,7 @@ function build(fields, origin, context) {
     ...mapped,
     startedAt,
     statusSince,
-    links: open3 ? { open: open3 } : {},
+    links: open4 ? { open: open4 } : {},
     stale: isStale({ status: mapped.status, statusSince }, context.now)
   };
   if (fields.pid !== void 0) {
@@ -2022,7 +2608,7 @@ function isMissing(error) {
 }
 
 // src/collector/adapters/claude-code/transcript/lastAsk.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonEmpty(value) {
@@ -2030,8 +2616,8 @@ function nonEmpty(value) {
 }
 function blocksOf(line) {
   const message = line.message;
-  if (!isRecord(message) || !Array.isArray(message.content)) return [];
-  return message.content.filter(isRecord);
+  if (!isRecord2(message) || !Array.isArray(message.content)) return [];
+  return message.content.filter(isRecord2);
 }
 function linesOf(tail, fromStart) {
   const pieces = tail.split("\n");
@@ -2041,7 +2627,7 @@ function linesOf(tail, fromStart) {
     if (piece.trim() === "") continue;
     try {
       const value = JSON.parse(piece);
-      if (isRecord(value)) lines.push(value);
+      if (isRecord2(value)) lines.push(value);
     } catch {
     }
   }
@@ -2049,7 +2635,7 @@ function linesOf(tail, fromStart) {
 }
 function isPrompt(line) {
   if (line.isMeta === true) return false;
-  const message = isRecord(line.message) ? line.message : null;
+  const message = isRecord2(line.message) ? line.message : null;
   if (message === null) return false;
   if (typeof message.content === "string") return message.content.trim() !== "";
   return blocksOf(line).some((block) => block.type === "text");
@@ -2060,11 +2646,11 @@ function pendingToolUse(lines) {
   let movedOn = false;
   for (const line of lines) {
     if (line.isSidechain === true) continue;
-    const message = isRecord(line.message) ? line.message : null;
+    const message = isRecord2(line.message) ? line.message : null;
     if (line.type === "assistant") {
       const messageId = nonEmpty(message?.id);
-      const newest2 = uses.at(-1);
-      if (newest2 !== void 0 && (messageId === null || messageId !== newest2.messageId)) {
+      const newest3 = uses.at(-1);
+      if (newest3 !== void 0 && (messageId === null || messageId !== newest3.messageId)) {
         movedOn = true;
       }
       for (const block of blocksOf(line)) {
@@ -2072,7 +2658,7 @@ function pendingToolUse(lines) {
         const id = nonEmpty(block.id);
         const name = nonEmpty(block.name);
         if (id === null || name === null) continue;
-        uses.push({ id, name, input: isRecord(block.input) ? block.input : {}, messageId });
+        uses.push({ id, name, input: isRecord2(block.input) ? block.input : {}, messageId });
         movedOn = false;
       }
     } else if (line.type === "user") {
@@ -2083,10 +2669,10 @@ function pendingToolUse(lines) {
       if (uses.length > 0 && isPrompt(line)) movedOn = true;
     }
   }
-  const newest = uses.at(-1);
-  if (newest === void 0 || movedOn) return null;
-  if (newest.messageId === null) return answered.has(newest.id) ? null : newest;
-  return uses.find((use) => use.messageId === newest.messageId && !answered.has(use.id)) ?? null;
+  const newest2 = uses.at(-1);
+  if (newest2 === void 0 || movedOn) return null;
+  if (newest2.messageId === null) return answered.has(newest2.id) ? null : newest2;
+  return uses.find((use) => use.messageId === newest2.messageId && !answered.has(use.id)) ?? null;
 }
 function firstLine(command) {
   return command.split(/\r?\n/).find((line) => line.trim() !== "") ?? null;
@@ -2113,7 +2699,7 @@ function describeToolUse(name, input, cwd) {
   if (name === "AskUserQuestion") {
     const questions = Array.isArray(input.questions) ? input.questions : [];
     const first = questions[0];
-    const question = isRecord(first) ? nonEmpty(first.question) : null;
+    const question = isRecord2(first) ? nonEmpty(first.question) : null;
     if (question === null) return null;
     return questions.length > 1 ? `${question} (+${questions.length - 1} more)` : question;
   }
@@ -2189,12 +2775,12 @@ function sameStamp(a, b) {
   return a.size === b.size && a.mtimeMs === b.mtimeMs && a.ino === b.ino;
 }
 async function readTranscriptTail(file, io, known, maxBytes = TRANSCRIPT_TAIL_BYTES) {
-  const open3 = await io.openRegular(file);
+  const open4 = await io.openRegular(file);
   try {
-    const stamp = stampOf(open3.info);
+    const stamp = stampOf(open4.info);
     if (known !== null && sameStamp(known, stamp)) return { unchanged: true, stamp };
     const start = Math.max(0, stamp.size - maxBytes);
-    const bytes2 = await open3.read(start, stamp.size - start);
+    const bytes2 = await open4.read(start, stamp.size - start);
     return {
       unchanged: false,
       stamp,
@@ -2202,7 +2788,7 @@ async function readTranscriptTail(file, io, known, maxBytes = TRANSCRIPT_TAIL_BY
       fromStart: start === 0
     };
   } finally {
-    await open3.close();
+    await open4.close();
   }
 }
 
@@ -2582,19 +3168,19 @@ var TURN_UNDER_WAY = /* @__PURE__ */ new Set(["task_started", "turn_started"]);
 var TURN_OVER = /* @__PURE__ */ new Set(["task_complete", "turn_complete", "turn_aborted"]);
 function mapCodexStatus(fields) {
   const { lastTurn, live } = fields;
-  let open3;
+  let open4;
   if (lastTurn === null) {
-    open3 = "idle";
+    open4 = "idle";
   } else if (typeof lastTurn !== "string") {
     return "unknown";
   } else if (TURN_UNDER_WAY.has(lastTurn)) {
-    open3 = "working";
+    open4 = "working";
   } else if (TURN_OVER.has(lastTurn)) {
-    open3 = "idle";
+    open4 = "idle";
   } else {
     return "unknown";
   }
-  return live === false ? "finished" : open3;
+  return live === false ? "finished" : open4;
 }
 var WRITER_LOCKS_SINCE = [0, 155, 0];
 var VERSION = /^(\d{1,6})\.(\d{1,6})\.(\d{1,6})(-[0-9A-Za-z.-]{1,64})?(?:\+[0-9A-Za-z.-]{1,64})?$/;
@@ -2618,7 +3204,7 @@ var IMPORTED_TURN_ID = /^external-import-turn-\d{1,9}$/;
 function isImportedCodexTurn(turnId) {
   return typeof turnId === "string" && IMPORTED_TURN_ID.test(turnId);
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var CODEX_DESKTOP_ORIGINATOR = "Codex Desktop";
@@ -2626,7 +3212,7 @@ function mapCodexSurface(source, originator) {
   if (originator === CODEX_DESKTOP_ORIGINATOR) return "desktop";
   if (source === "cli" || source === "exec") return "terminal";
   if (source === "vscode") return "vscode";
-  if (isRecord2(source) && source.custom === "chatgpt") return "desktop";
+  if (isRecord3(source) && source.custom === "chatgpt") return "desktop";
   return "unknown";
 }
 var NOT_A_SESSION_SOURCE = /* @__PURE__ */ new Set(["subagent", "internal", "mcp"]);
@@ -2637,7 +3223,7 @@ function isCodexSessionSource(source, meta = {}) {
     return false;
   }
   if (typeof source === "string") return !NOT_A_SESSION_SOURCE.has(source);
-  if (isRecord2(source)) return !Object.keys(source).some((kind) => NOT_A_SESSION_SOURCE.has(kind));
+  if (isRecord3(source)) return !Object.keys(source).some((kind) => NOT_A_SESSION_SOURCE.has(kind));
   return true;
 }
 
@@ -2656,7 +3242,7 @@ function parseCodexTime(value) {
 var LINE_TIME = /^\{"timestamp":"([^"]{1,64})"/;
 var TURN_HINT = /"type":"(?:task|turn)_/;
 var TURN_TYPE = /^(?:task|turn)_/;
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function text3(value) {
@@ -2667,7 +3253,7 @@ function label(value) {
 }
 function compactSource(value) {
   if (typeof value === "string") return text3(value);
-  if (!isRecord3(value)) return void 0;
+  if (!isRecord4(value)) return void 0;
   return Object.fromEntries(
     Object.entries(value).map(([kind, detail]) => [
       kind,
@@ -2678,7 +3264,7 @@ function compactSource(value) {
 function parse(line) {
   try {
     const value = JSON.parse(line);
-    return isRecord3(value) ? value : null;
+    return isRecord4(value) ? value : null;
   } catch {
     return null;
   }
@@ -2686,7 +3272,7 @@ function parse(line) {
 function readMetaLine(line) {
   if (!line.includes('"session_meta"')) return null;
   const value = parse(line);
-  if (!value || value.type !== "session_meta" || !isRecord3(value.payload)) return null;
+  if (!value || value.type !== "session_meta" || !isRecord4(value.payload)) return null;
   const payload = value.payload;
   const meta = {
     id: text3(payload.id),
@@ -2706,7 +3292,7 @@ function readMetaLine(line) {
 function readTurnLine(line) {
   if (!line.includes('"event_msg"') || !TURN_HINT.test(line)) return null;
   const value = parse(line);
-  if (!value || value.type !== "event_msg" || !isRecord3(value.payload)) return null;
+  if (!value || value.type !== "event_msg" || !isRecord4(value.payload)) return null;
   const turn = value.payload.type;
   if (typeof turn !== "string" || !TURN_TYPE.test(turn)) return null;
   return {
@@ -2988,7 +3574,7 @@ function createRolloutFinder(options) {
 // src/collector/adapters/codex/sessionIndex.ts
 var SESSION_INDEX_FILE = "session_index.jsonl";
 var SESSION_INDEX_LIMIT_BYTES = 4 * 1024 * 1024;
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseSessionIndex(content) {
@@ -3001,7 +3587,7 @@ function parseSessionIndex(content) {
     } catch {
       continue;
     }
-    if (!isRecord4(value)) continue;
+    if (!isRecord5(value)) continue;
     const { id, thread_name: name } = value;
     if (typeof id !== "string" || id === "" || typeof name !== "string") continue;
     const trimmed = name.trim();
@@ -3107,12 +3693,12 @@ async function readWriterLocks(dir, io) {
   } catch (error) {
     return { supported: false, missing: isMissing(error) };
   }
-  const open3 = /* @__PURE__ */ new Set();
+  const open4 = /* @__PURE__ */ new Set();
   for (const name of names) {
     const threadId = threadIdOfLock(name);
-    if (threadId !== null) open3.add(threadId);
+    if (threadId !== null) open4.add(threadId);
   }
-  return { supported: true, open: open3 };
+  return { supported: true, open: open4 };
 }
 
 // src/collector/adapters/codex/index.ts
@@ -3276,7 +3862,7 @@ function createCodexAdapter(options = {}) {
     const chosen = /* @__PURE__ */ new Map();
     const subagentWrites = /* @__PURE__ */ new Map();
     for (const ref of [...candidates.values()].sort((a, b) => a.path < b.path ? -1 : 1)) {
-      const open3 = locked(ref.threadId);
+      const open4 = locked(ref.threadId);
       let info;
       try {
         info = await io.lstat(ref.path);
@@ -3284,7 +3870,7 @@ function createCodexAdapter(options = {}) {
         tracked.delete(ref.path);
         continue;
       }
-      if (info.kind !== "file" || !open3 && info.mtimeMs < cutoff) {
+      if (info.kind !== "file" || !open4 && info.mtimeMs < cutoff) {
         tracked.delete(ref.path);
         continue;
       }
@@ -3307,7 +3893,7 @@ function createCodexAdapter(options = {}) {
       }
       if (state.lastTurnImported) continue;
       const at = lastActivity(state, checkedAt);
-      if (!open3 && (at === null || !isWithinRetention(at, checkedAt))) {
+      if (!open4 && (at === null || !isWithinRetention(at, checkedAt))) {
         tracked.delete(ref.path);
         continue;
       }
@@ -3496,8 +4082,8 @@ var STATUS_FILE_CAPABILITIES = {
   jump: { level: "no", reason: "Nothing in a status file is used to reach a session." },
   "quiet-for": { level: "partly", reason: "If the agent writes its file again as it works." }
 };
-function counted(count, one, many) {
-  return `${count} ${count === 1 ? one : many}`;
+function counted(count2, one, many) {
+  return `${count2} ${count2 === 1 ? one : many}`;
 }
 function createStatusFileAdapter(options = {}) {
   const env = options.env ?? process.env;
@@ -3540,9 +4126,9 @@ function createStatusFileAdapter(options = {}) {
     return { health, sessions: [] };
   }
   async function readOne(file) {
-    let open3;
+    let open4;
     try {
-      open3 = await io.openRegular(file);
+      open4 = await io.openRegular(file);
     } catch (error) {
       if (isMissing(error)) return { kind: "gone" };
       const code = error?.code;
@@ -3551,15 +4137,15 @@ function createStatusFileAdapter(options = {}) {
     }
     const tooLarge = { kind: "refused", why: "is over 16 KB" };
     try {
-      if (open3.info.size > MAX_FILE_BYTES) return tooLarge;
-      const bytes2 = await open3.read(0, MAX_FILE_BYTES + 1);
+      if (open4.info.size > MAX_FILE_BYTES) return tooLarge;
+      const bytes2 = await open4.read(0, MAX_FILE_BYTES + 1);
       if (bytes2.byteLength > MAX_FILE_BYTES) return tooLarge;
       const parsed = parseStatusFile(decoder2.decode(bytes2));
-      return parsed ? { kind: "read", file: parsed, mtimeMs: open3.info.mtimeMs } : { kind: "invalid" };
+      return parsed ? { kind: "read", file: parsed, mtimeMs: open4.info.mtimeMs } : { kind: "invalid" };
     } catch {
       return { kind: "refused", why: "could not be read" };
     } finally {
-      await open3.close().catch(() => {
+      await open4.close().catch(() => {
       });
     }
   }
@@ -3832,6 +4418,9 @@ function createEventStore(capacity = EVENT_CAPACITY) {
       }
       return newestFirst;
     },
+    clear() {
+      events = [];
+    },
     get size() {
       return events.length;
     }
@@ -3900,21 +4489,21 @@ var MAX_LEVELS = 24;
 var READ_WAIT_MS = 1e3;
 var decoder = new TextDecoder("utf-8", { fatal: true });
 async function readSmall(io, file) {
-  let open3;
+  let open4;
   try {
-    open3 = await io.openRegular(file);
+    open4 = await io.openRegular(file);
   } catch (error) {
     return isMissing(error) ? void 0 : null;
   }
   try {
-    if (open3.info.size > MAX_GIT_FILE_BYTES) return null;
-    const bytes2 = await open3.read(0, MAX_GIT_FILE_BYTES + 1);
+    if (open4.info.size > MAX_GIT_FILE_BYTES) return null;
+    const bytes2 = await open4.read(0, MAX_GIT_FILE_BYTES + 1);
     if (bytes2.byteLength > MAX_GIT_FILE_BYTES) return null;
     return decoder.decode(bytes2);
   } catch {
     return null;
   } finally {
-    await open3.close().catch(() => {
+    await open4.close().catch(() => {
     });
   }
 }
@@ -4016,52 +4605,916 @@ function createBranchFinder(options = {}) {
   };
 }
 
-// src/collector/terminal/terminalTabs.ts
+// src/collector/history/clearRoute.ts
+var MAX_CLEAR_BODY_BYTES = 64;
+function isEmptyObject(body) {
+  let value;
+  try {
+    value = JSON.parse(body);
+  } catch {
+    return false;
+  }
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+var failed = (status, reason, error) => ({
+  status,
+  body: { error, reason }
+});
+function createClearHistoryRoute(options) {
+  const { keeper, forget } = options;
+  return async function answerClear(req) {
+    const refused = actionRefusalFor(req, CLEAR_HISTORY_ACTION, MAX_CLEAR_BODY_BYTES);
+    if (refused) {
+      req.resume();
+      return refused;
+    }
+    const body = await readRequestBody(req, MAX_CLEAR_BODY_BYTES);
+    if (!body.ok) {
+      req.resume();
+      return body.tooLarge ? refusal(413, `The body must be no more than ${MAX_CLEAR_BODY_BYTES} bytes.`) : refusal(400, "The body could not be read.");
+    }
+    if (!isEmptyObject(body.text)) {
+      return refusal(400, "The body must be an empty JSON object: {}.");
+    }
+    if (keeper === null) {
+      return failed(
+        409,
+        "memory-only",
+        "History is kept in memory only, with AGENT_LOOKOUT_HISTORY=off, so there are no files to clear."
+      );
+    }
+    const outcome = await keeper.clear(forget);
+    if (outcome.ok) {
+      return {
+        status: 200,
+        body: { ok: true, clearedAt: outcome.at }
+      };
+    }
+    return failed(outcome.reason === "not-writing" ? 409 : 500, outcome.reason, outcome.error);
+  };
+}
+
+// src/collector/history/historyKeeper.ts
 import path13 from "node:path";
-var TERMINAL_PATH = "/System/Applications/Utilities/Terminal.app/Contents/MacOS/Terminal";
-var ITERM_PATH = "/Applications/iTerm.app/Contents/MacOS/iTerm2";
-var ITERM_SERVER_FOLDER = "Library/Application Support/iTerm2";
-var ITERM_SERVER_NAME = /^iTermServer-[0-9A-Za-z._-]{1,40}$/;
-var TTY_NAME = /^ttys\d{1,4}$/;
-var TTY_PATH = /^\/dev\/ttys\d{1,4}$/;
-function isTtyPath(value) {
-  return typeof value === "string" && TTY_PATH.test(value);
+
+// src/collector/history/historyFiles.ts
+import {
+  closeSync,
+  constants as constants4,
+  fstatSync,
+  lstatSync,
+  openSync,
+  readSync,
+  unlinkSync,
+  writeSync
+} from "node:fs";
+import { lstat as lstat2, lutimes, mkdir, open as open3, readdir as readdir3, unlink } from "node:fs/promises";
+function infoOf2(info) {
+  return { kind: info.isFile() ? "file" : "other", size: info.size, mtimeMs: info.mtimeMs };
+}
+var FILE_MODE = 384;
+var FOLDER_MODE = 448;
+var NO_FOLLOW = (constants4.O_NOFOLLOW ?? 0) | (constants4.O_NONBLOCK ?? 0);
+var READ = constants4.O_RDONLY | NO_FOLLOW;
+var APPEND = constants4.O_WRONLY | constants4.O_APPEND | constants4.O_CREAT | NO_FOLLOW;
+var CREATE = constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | NO_FOLLOW;
+function notOrdinary() {
+  return new Error("Not an ordinary file.");
+}
+function isMissing2(error) {
+  return error?.code === "ENOENT";
+}
+async function readRegular(file, maxBytes) {
+  const handle = await open3(file, READ);
+  try {
+    const info = await handle.stat();
+    if (!info.isFile()) throw notOrdinary();
+    if (info.size > maxBytes) throw new Error("Too large to be a history file.");
+    const buffer = Buffer.alloc(info.size);
+    let filled = 0;
+    while (filled < buffer.byteLength) {
+      const { bytesRead } = await handle.read(buffer, filled, buffer.byteLength - filled, filled);
+      if (bytesRead === 0) break;
+      filled += bytesRead;
+    }
+    return buffer.toString("utf8", 0, filled);
+  } finally {
+    await handle.close();
+  }
 }
-function ttyPathOf(name) {
-  return TTY_NAME.test(name) ? `/dev/${name}` : null;
+function readRegularNow(file, maxBytes) {
+  const fd = openSync(file, READ);
+  try {
+    const info = fstatSync(fd);
+    if (!info.isFile()) throw notOrdinary();
+    if (info.size > maxBytes) throw new Error("Too large to be a history file.");
+    const buffer = Buffer.alloc(info.size);
+    let filled = 0;
+    while (filled < buffer.byteLength) {
+      const read = readSync(fd, buffer, filled, buffer.byteLength - filled, filled);
+      if (read === 0) break;
+      filled += read;
+    }
+    return buffer.toString("utf8", 0, filled);
+  } finally {
+    closeSync(fd);
+  }
 }
-function appOfProgram(program, homeDir) {
-  if (program === TERMINAL_PATH) return "Terminal";
-  if (program === ITERM_PATH) return "iTerm2";
-  const inServerFolder = path13.dirname(program) === path13.join(homeDir, ITERM_SERVER_FOLDER);
-  return inServerFolder && ITERM_SERVER_NAME.test(path13.basename(program)) ? "iTerm2" : null;
+function writeNow(file, flags, text4) {
+  const fd = openSync(file, flags, FILE_MODE);
+  try {
+    if (!fstatSync(fd).isFile()) throw notOrdinary();
+    writeSync(fd, text4);
+  } finally {
+    closeSync(fd);
+  }
 }
-function tabOfProcess(pid, table, homeDir) {
-  const own = table.get(pid);
-  const tty = own ? ttyPathOf(own.tty) : null;
-  if (!own || tty === null) return void 0;
-  const passed = /* @__PURE__ */ new Set([pid]);
-  let current = own.ppid;
-  while (current > 1 && !passed.has(current)) {
-    const parent = table.get(current);
-    if (!parent) return void 0;
-    const app = appOfProgram(parent.path, homeDir);
-    if (app) return { app, tty };
-    if (parent.tty !== own.tty) return void 0;
-    passed.add(current);
-    current = parent.ppid;
+async function writeTo(file, flags, text4) {
+  const handle = await open3(file, flags, FILE_MODE);
+  try {
+    if (!(await handle.stat()).isFile()) throw notOrdinary();
+    await handle.writeFile(text4, "utf8");
+  } finally {
+    await handle.close();
   }
-  return void 0;
 }
+var nodeHistoryFs = {
+  async makeFolder(dir) {
+    await mkdir(dir, { recursive: true, mode: FOLDER_MODE });
+  },
+  list: (dir) => readdir3(dir),
+  lstat: async (file) => infoOf2(await lstat2(file)),
+  lstatNow: (file) => infoOf2(lstatSync(file)),
+  readRegular,
+  readRegularNow,
+  append: (file, text4) => writeTo(file, APPEND, text4),
+  appendNow: (file, text4) => writeNow(file, APPEND, text4),
+  create: (file, text4) => writeTo(file, CREATE, text4),
+  createNow: (file, text4) => writeNow(file, CREATE, text4),
+  async touch(file, at) {
+    const when = new Date(at);
+    await lutimes(file, when, when);
+  },
+  async remove(file) {
+    try {
+      await unlink(file);
+    } catch (error) {
+      if (!isMissing2(error)) throw error;
+    }
+  },
+  removeNow(file) {
+    try {
+      unlinkSync(file);
+    } catch (error) {
+      if (!isMissing2(error)) throw error;
+    }
+  }
+};
 
-// src/collector/terminal/focusTab.ts
-var FOUND = "found";
-var MISSING = "missing";
-var TERMINAL_SCRIPT = [
-  "on run argv",
-  "set wanted to item 1 of argv",
-  `if not (application id "com.apple.Terminal" is running) then return "${MISSING}"`,
-  'tell application id "com.apple.Terminal"',
+// src/collector/history/writerLock.ts
+import { randomBytes } from "node:crypto";
+var LOCK_FILE = "writer.lock";
+var LOCK_STALE_MS = 3e4;
+var MAX_LOCK_BYTES = 256;
+var MAX_MARK_LENGTH = 64;
+function mark(value) {
+  return typeof value === "string" && value !== "" && value.length <= MAX_MARK_LENGTH ? value : null;
+}
+function holderIn(text4) {
+  try {
+    const value = JSON.parse(text4);
+    if (typeof value !== "object" || value === null) return null;
+    const fields = value;
+    const pid = validPid(fields.pid);
+    if (pid === void 0) return null;
+    return { pid, token: mark(fields.token), sources: mark(fields.sources) };
+  } catch {
+    return null;
+  }
+}
+function createWriterLock(options) {
+  const { fs, file } = options;
+  const pid = options.pid ?? process.pid;
+  const now = options.now ?? Date.now;
+  const isAlive = options.isAlive ?? isProcessAlive;
+  const staleAfterMs = options.staleAfterMs ?? LOCK_STALE_MS;
+  const token = options.token ?? randomBytes(8).toString("hex");
+  const sources = options.sources ?? null;
+  const content = `${JSON.stringify({ pid, token, ...sources !== null && { sources } })}
+`;
+  let held = false;
+  let heldByOtherSources = false;
+  const isOwn = (holder2) => holder2?.pid === pid && holder2.token === token;
+  function verdict(info, holder2) {
+    heldByOtherSources = false;
+    if (info.kind !== "file") return "leave";
+    const fresh = now() - info.mtimeMs < staleAfterMs;
+    if (!fresh || isOwn(holder2)) return "take-over";
+    if (holder2 === null) return "leave";
+    if (holder2.pid === pid || isAlive(holder2.pid)) {
+      heldByOtherSources = sources !== null && holder2.sources !== null && holder2.sources !== sources;
+      return "leave";
+    }
+    return "take-over";
+  }
+  async function make() {
+    try {
+      await fs.create(file, content);
+      held = true;
+      heldByOtherSources = false;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function makeNow() {
+    try {
+      fs.createNow(file, content);
+      held = true;
+      heldByOtherSources = false;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async function holder() {
+    try {
+      return holderIn(await fs.readRegular(file, MAX_LOCK_BYTES));
+    } catch {
+      return null;
+    }
+  }
+  function holderNow() {
+    try {
+      return holderIn(fs.readRegularNow(file, MAX_LOCK_BYTES));
+    } catch {
+      return null;
+    }
+  }
+  return {
+    async take() {
+      if (await make()) return true;
+      let info;
+      try {
+        info = await fs.lstat(file);
+      } catch {
+        return make();
+      }
+      if (verdict(info, await holder()) === "leave") return false;
+      try {
+        await fs.remove(file);
+      } catch {
+        return false;
+      }
+      return make();
+    },
+    takeNow() {
+      if (makeNow()) return true;
+      let info;
+      try {
+        info = fs.lstatNow(file);
+      } catch {
+        return makeNow();
+      }
+      if (verdict(info, holderNow()) === "leave") return false;
+      try {
+        fs.removeNow(file);
+      } catch {
+        return false;
+      }
+      return makeNow();
+    },
+    async keep() {
+      if (!held) return false;
+      if (!isOwn(await holder())) {
+        held = false;
+        return false;
+      }
+      try {
+        await fs.touch(file, now());
+      } catch {
+      }
+      return true;
+    },
+    stillHeldNow() {
+      if (!held) return false;
+      if (isOwn(holderNow())) return true;
+      held = false;
+      return false;
+    },
+    releaseNow() {
+      if (!held) return;
+      held = false;
+      if (!isOwn(holderNow())) return;
+      try {
+        fs.removeNow(file);
+      } catch {
+      }
+    },
+    get held() {
+      return held;
+    },
+    get heldByOtherSources() {
+      return heldByOtherSources;
+    }
+  };
+}
+
+// src/collector/history/historyKeeper.ts
+var FLUSH_INTERVAL_MS = 5e3;
+var RESTORE_DEADLINE_MS = 1e4;
+var MAX_QUEUED_LINES = 5e4;
+var MAX_PART = 9999;
+var FUTURE_SLACK_MS = 6e4;
+var MAX_RESTARTS = 500;
+var BEGINNING = {
+  start: "started",
+  cleared: "cleared",
+  point: "trimmed",
+  event: "trimmed"
+};
+function byteLength(text4) {
+  return Buffer.byteLength(text4, "utf8");
+}
+function isNotOrdinary(error) {
+  const code = error?.code;
+  return code === "ELOOP" || code === "EISDIR" || code === "EMLINK" || code === "ENXIO" || code === "EOPNOTSUPP" || error instanceof Error && error.message === "Not an ordinary file.";
+}
+function newest(list, limit) {
+  return list.length > limit ? list.slice(list.length - Math.max(0, limit)) : list;
+}
+function createHistoryKeeper(options) {
+  const { dir, folder } = options;
+  const fs = options.fs ?? nodeHistoryFs;
+  const now = options.now ?? Date.now;
+  const flushIntervalMs = options.flushIntervalMs ?? FLUSH_INTERVAL_MS;
+  const restoreDeadlineMs = options.restoreDeadlineMs ?? RESTORE_DEADLINE_MS;
+  const maxBytes = options.maxBytes ?? HISTORY_MAX_BYTES;
+  const maxFileBytes = options.maxFileBytes ?? HISTORY_MAX_FILE_BYTES;
+  const readLimit = Math.floor(maxFileBytes * 1.05);
+  const maxAgeMs = options.maxAgeMs ?? HISTORY_MAX_AGE_MS;
+  const warn = options.warn ?? (() => {
+  });
+  const lock = createWriterLock({
+    fs,
+    file: path13.join(dir, LOCK_FILE),
+    pid: options.pid,
+    now,
+    isAlive: options.isAlive,
+    sources: options.sources ?? null
+  });
+  const files = /* @__PURE__ */ new Map();
+  const blocked = /* @__PURE__ */ new Set();
+  const touched = /* @__PURE__ */ new Set();
+  let queue = [];
+  let startedAt = null;
+  let target = null;
+  let restored = false;
+  let unusable = null;
+  let failing = null;
+  let clearedAt = null;
+  let writer = null;
+  let running = false;
+  let timer = null;
+  let chain = Promise.resolve();
+  function serially(work) {
+    const next = chain.then(work, work);
+    chain = next.catch(() => {
+    });
+    return next;
+  }
+  const full = (name) => path13.join(dir, name);
+  function hold(record) {
+    if (unusable !== null || !running) return;
+    const line = encodeRecord(record);
+    if (line.length > MAX_LINE_LENGTH || byteLength(line) > maxFileBytes) return;
+    queue.push(line);
+    if (queue.length > MAX_QUEUED_LINES) queue = queue.slice(queue.length - MAX_QUEUED_LINES);
+  }
+  function recordsIn(text4, at) {
+    return parseHistoryText(text4).records.filter(
+      (record) => recordAt(record) <= at + FUTURE_SLACK_MS
+    );
+  }
+  async function readAll(limits) {
+    try {
+      await fs.makeFolder(dir);
+    } catch {
+      return `Agent Lookout could not make its history folder, ${folder}, so this run keeps history in memory only.`;
+    }
+    let names;
+    try {
+      names = await fs.list(dir);
+    } catch {
+      return `Agent Lookout could not read its history folder, ${folder}, so this run keeps history in memory only.`;
+    }
+    const ours = names.map(readHistoryFileName).filter((file) => file?.version === HISTORY_FORMAT_VERSION).sort(byFileOrder);
+    const found = /* @__PURE__ */ new Map();
+    const notFiles = /* @__PURE__ */ new Set();
+    const events = /* @__PURE__ */ new Map();
+    const points = [];
+    const starts = [];
+    const times = [];
+    let lastAt = null;
+    const at = now();
+    for (const file of ours) {
+      let info;
+      try {
+        info = await fs.lstat(full(file.name));
+      } catch {
+        continue;
+      }
+      if (info.kind !== "file") {
+        notFiles.add(file.name);
+        continue;
+      }
+      const known = { ...file, size: info.size, first: null };
+      found.set(file.name, known);
+      if (dayEnd(file) + maxAgeMs < at || info.size > readLimit) continue;
+      let text4;
+      try {
+        text4 = await fs.readRegular(full(file.name), readLimit);
+      } catch {
+        continue;
+      }
+      const records = recordsIn(text4, at);
+      const first = records[0];
+      if (first) known.first = { at: recordAt(first), kind: first.kind };
+      for (const record of records) {
+        const recorded = recordAt(record);
+        times.push(recorded);
+        if (lastAt === null || recorded > lastAt) lastAt = recorded;
+        if (record.kind === "event") events.set(record.event.id, record.event);
+        else if (record.kind === "point") points.push(record.point);
+        else if (record.kind === "start") starts.push(record.at);
+      }
+    }
+    const allEvents = [...events.values()].sort((a, b) => a.at - b.at);
+    points.sort((a, b) => a.at - b.at);
+    const allPoints = points.filter((point, index) => point.at !== points[index - 1]?.at);
+    return {
+      history: {
+        events: newest(allEvents, limits.events),
+        points: newest(allPoints, limits.points),
+        restarts: newest(restartsAmong(starts, times), MAX_RESTARTS),
+        lastAt,
+        whole: {
+          waitEvents: allEvents.filter(isWaitEvent),
+          measured: pollRuns(
+            allPoints.map((point) => point.at),
+            starts
+          )
+        }
+      },
+      found,
+      notFiles
+    };
+  }
+  async function firstRecordOf(name, size) {
+    if (size === 0 || size > readLimit) return null;
+    try {
+      const first = recordsIn(await fs.readRegular(full(name), readLimit), now())[0];
+      return first ? { at: recordAt(first), kind: first.kind } : null;
+    } catch {
+      return null;
+    }
+  }
+  async function rescan() {
+    let names;
+    try {
+      names = await fs.list(dir);
+    } catch {
+      return;
+    }
+    const there = /* @__PURE__ */ new Set();
+    for (const name of names) {
+      const file = readHistoryFileName(name);
+      if (file?.version !== HISTORY_FORMAT_VERSION) continue;
+      let info;
+      try {
+        info = await fs.lstat(full(name));
+      } catch {
+        continue;
+      }
+      if (info.kind !== "file") {
+        blocked.add(name);
+        continue;
+      }
+      there.add(name);
+      blocked.delete(name);
+      const known = files.get(name);
+      if (known?.size === info.size) continue;
+      const fresh = known === void 0 || known.first === null || info.size < known.size;
+      const first = fresh ? await firstRecordOf(name, info.size) : known.first;
+      files.set(name, { ...file, size: info.size, first });
+    }
+    for (const name of [...files.keys()]) {
+      if (!there.has(name)) files.delete(name);
+    }
+  }
+  function aimAtNewest() {
+    const day = dayOf(now());
+    let part = 0;
+    for (const file of files.values()) {
+      if (file.day === day && file.part > part) part = file.part;
+    }
+    target = part > 0 ? { day, part } : null;
+  }
+  async function prune(writingTo, incoming) {
+    const doomed = filesToDelete([...files.values()], writingTo, incoming, {
+      now: now(),
+      maxBytes,
+      maxAgeMs
+    });
+    for (const name of doomed) {
+      try {
+        await fs.remove(full(name));
+      } catch {
+      }
+      files.delete(name);
+    }
+  }
+  function* chunks(lines) {
+    const day = dayOf(now());
+    let part = target?.day === day ? target.part : 1;
+    let index = 0;
+    while (index < lines.length && part <= MAX_PART) {
+      const name = historyFileName(day, part);
+      const known = files.get(name);
+      const size = known?.size ?? 0;
+      const lead = size > 0 && !touched.has(name) ? "\n" : "";
+      const room = maxFileBytes - size - lead.length;
+      const firstBytes = byteLength(lines[index]);
+      if (blocked.has(name) || firstBytes > room) {
+        part += 1;
+        continue;
+      }
+      let text4 = lead;
+      let bytes2 = lead.length;
+      let end = index;
+      while (end < lines.length) {
+        const lineBytes = byteLength(lines[end]);
+        if (bytes2 - lead.length + lineBytes > room) break;
+        text4 += lines[end];
+        bytes2 += lineBytes;
+        end += 1;
+      }
+      const outcome = yield { name, text: text4 };
+      if (outcome === "blocked") {
+        blocked.add(name);
+        part += 1;
+        continue;
+      }
+      const record = parseRecord(lines[index].trim());
+      const parsed = readHistoryFileName(name);
+      files.set(name, {
+        ...parsed,
+        size: size + bytes2,
+        first: known?.first ?? (record && { at: recordAt(record), kind: record.kind })
+      });
+      touched.add(name);
+      target = { day, part };
+      index = end;
+    }
+  }
+  function wrote() {
+    failing = null;
+  }
+  function writeFailed() {
+    touched.clear();
+    if (failing === null) {
+      failing = `Agent Lookout could not write to its history folder, ${folder}, so new history is kept in memory until it can.`;
+      warn(failing);
+    }
+  }
+  async function writeLines(lines) {
+    if (lines.length === 0) return true;
+    const steps = chunks(lines);
+    let step = steps.next("written");
+    while (!step.done) {
+      const { name, text: text4 } = step.value;
+      await prune(name, byteLength(text4));
+      try {
+        await fs.append(full(name), text4);
+      } catch (error) {
+        if (isNotOrdinary(error)) {
+          step = steps.next("blocked");
+          continue;
+        }
+        writeFailed();
+        return false;
+      }
+      step = steps.next("written");
+    }
+    wrote();
+    return true;
+  }
+  function writeLinesNow(lines) {
+    if (lines.length === 0) return;
+    const steps = chunks(lines);
+    let step = steps.next("written");
+    while (!step.done) {
+      const { name, text: text4 } = step.value;
+      try {
+        fs.appendNow(full(name), text4);
+      } catch (error) {
+        if (isNotOrdinary(error)) {
+          step = steps.next("blocked");
+          continue;
+        }
+        return;
+      }
+      step = steps.next("written");
+    }
+  }
+  function takeQueued() {
+    const lines = startedAt === null ? queue : [encodeRecord({ kind: "start", at: startedAt }), ...queue];
+    queue = [];
+    startedAt = null;
+    return lines;
+  }
+  let pruned = false;
+  let beating = null;
+  function beat() {
+    beating ??= writeBeat().finally(() => {
+      beating = null;
+    });
+    return beating;
+  }
+  function writeBeat() {
+    return serially(async () => {
+      if (!running || unusable !== null) return;
+      const kept = lock.held && await lock.keep();
+      const holds = kept || running && await lock.take();
+      if (!running) {
+        lock.releaseNow();
+        return;
+      }
+      if (!holds) {
+        writer = false;
+        queue = [];
+        startedAt = null;
+        await rescan();
+        return;
+      }
+      if (!kept) {
+        await rescan();
+        touched.clear();
+        aimAtNewest();
+        pruned = false;
+      }
+      writer = true;
+      if (!pruned) {
+        pruned = true;
+        await prune(null, 0);
+      }
+      await writeLines(takeQueued());
+    }).catch(() => {
+    });
+  }
+  return {
+    async restore(limits) {
+      const none = {
+        events: [],
+        points: [],
+        restarts: [],
+        lastAt: null,
+        whole: { waitEvents: [], measured: [] }
+      };
+      if (restored) return none;
+      restored = true;
+      let deadline;
+      const late = new Promise((resolve) => {
+        deadline = setTimeout(() => resolve("late"), restoreDeadlineMs);
+        deadline.unref?.();
+      });
+      const reading = serially(() => readAll(limits)).catch(
+        () => `Agent Lookout could not read its history folder, ${folder}, so this run keeps history in memory only.`
+      );
+      const outcome = await Promise.race([reading, late]);
+      clearTimeout(deadline);
+      if (outcome === "late") {
+        unusable = `Agent Lookout could not read its history folder, ${folder}, in time, so this run keeps history in memory only.`;
+        warn(unusable);
+        return none;
+      }
+      if (typeof outcome === "string") {
+        unusable = outcome;
+        warn(unusable);
+        return none;
+      }
+      for (const [name, file] of outcome.found) files.set(name, file);
+      for (const name of outcome.notFiles) blocked.add(name);
+      aimAtNewest();
+      return outcome.history;
+    },
+    start() {
+      if (running) return;
+      running = true;
+      if (unusable !== null) return;
+      writer = lock.takeNow();
+      pruned = false;
+      startedAt = writer ? now() : null;
+      void beat();
+      timer = setInterval(() => void beat(), flushIntervalMs);
+      timer.unref?.();
+    },
+    addEvents(events) {
+      for (const event of events) hold({ kind: "event", event });
+    },
+    addPoint(point) {
+      hold({ kind: "point", point });
+    },
+    async flush() {
+      if (beating) await beating;
+      await beat();
+    },
+    stop() {
+      if (!running) return;
+      running = false;
+      if (timer) clearInterval(timer);
+      timer = null;
+      if (writer === true && unusable === null && lock.stillHeldNow()) {
+        writeLinesNow(takeQueued());
+      }
+      queue = [];
+      startedAt = null;
+      writer = null;
+      lock.releaseNow();
+    },
+    clear(forget) {
+      return serially(async () => {
+        if (unusable !== null || writer !== true || !lock.held) {
+          return {
+            ok: false,
+            reason: "not-writing",
+            error: "Another copy of Agent Lookout keeps the history, or it cannot be written here."
+          };
+        }
+        let names;
+        try {
+          names = await fs.list(dir);
+        } catch {
+          return { ok: false, reason: "failed", error: "The history folder could not be read." };
+        }
+        let left = 0;
+        for (const name of names) {
+          if (readHistoryFileName(name)?.version !== HISTORY_FORMAT_VERSION) continue;
+          try {
+            const info = await fs.lstat(full(name));
+            if (info.kind !== "file") continue;
+            await fs.remove(full(name));
+            files.delete(name);
+          } catch {
+            left += 1;
+          }
+        }
+        const listed = new Set(names);
+        for (const name of [...files.keys()]) {
+          if (!listed.has(name)) files.delete(name);
+        }
+        touched.clear();
+        aimAtNewest();
+        if (left > 0) {
+          return {
+            ok: false,
+            reason: "failed",
+            error: `${left === 1 ? "One history file" : `${left} history files`} could not be deleted.`
+          };
+        }
+        const at = now();
+        queue = [];
+        startedAt = null;
+        clearedAt = at;
+        forget();
+        await writeLines([encodeRecord({ kind: "cleared", at })]);
+        return { ok: true, at };
+      });
+    },
+    since() {
+      const oldest = [...files.values()].sort(byFileOrder).find((file) => file.first !== null);
+      if (!oldest?.first) return clearedAt === null ? null : { at: clearedAt, by: "cleared" };
+      return { at: oldest.first.at, by: BEGINNING[oldest.first.kind] };
+    },
+    status() {
+      let bytes2 = 0;
+      for (const file of files.values()) bytes2 += file.size;
+      let problem = unusable ?? failing;
+      if (problem === null && writer === false) {
+        problem = lock.heldByOtherSources ? "Another copy of Agent Lookout on this computer is writing the history, and it reads sessions from other folders than this one. This one keeps what it sees in memory, and takes over when that one stops." : "Another copy of Agent Lookout on this computer is writing the history. This one keeps what it sees in memory, and takes over when that one stops.";
+      }
+      return {
+        where: "disk",
+        folder,
+        bytes: bytes2,
+        maxBytes,
+        maxAgeMs,
+        canClear: unusable === null && writer === true && lock.held,
+        problem
+      };
+    }
+  };
+}
+function keptEventStore(store, keeper) {
+  return {
+    add(events) {
+      store.add(events);
+      keeper.addEvents(events);
+    },
+    list: (options) => store.list(options),
+    clear: () => store.clear(),
+    get size() {
+      return store.size;
+    }
+  };
+}
+function keptHistoryStore(store, keeper) {
+  return {
+    add(point) {
+      store.add(point);
+      keeper.addPoint(point);
+    },
+    list: (windowMs, at) => store.list(windowMs, at),
+    clear: () => store.clear(),
+    get size() {
+      return store.size;
+    }
+  };
+}
+
+// src/collector/history/historySettings.ts
+import { createHash as createHash3 } from "node:crypto";
+import os5 from "node:os";
+import path14 from "node:path";
+var HISTORY_ENV = "AGENT_LOOKOUT_HISTORY";
+var HISTORY_DIR_ENV = "AGENT_LOOKOUT_HISTORY_DIR";
+function readHistorySetup(env, homeDir = os5.homedir()) {
+  if (env[HISTORY_ENV]?.trim().toLowerCase() === "off") return { on: false };
+  const override = env[HISTORY_DIR_ENV]?.trim() || void 0;
+  const dir = path14.resolve(override ?? path14.join(homeDir, ".agent-lookout", "history"));
+  return {
+    on: true,
+    dir,
+    folder: tildify(dir, homeDir),
+    sources: sourcesFingerprint(env, homeDir)
+  };
+}
+function sourcesFingerprint(env, homeDir = os5.homedir()) {
+  const set = (name) => env[name]?.trim() || void 0;
+  const folders = [
+    path14.resolve(set(CLAUDE_HOME_ENV) ?? path14.join(homeDir, ".claude")),
+    path14.resolve(set(CODEX_HOME_ENV) ?? set(CODEX_OWN_HOME_ENV) ?? path14.join(homeDir, ".codex")),
+    path14.resolve(set(STATUS_DIR_ENV) ?? path14.join(homeDir, ".agent-lookout", "sessions"))
+  ];
+  return createHash3("sha256").update(JSON.stringify(folders)).digest("hex").slice(0, 32);
+}
+
+// src/collector/terminal/terminalTabs.ts
+import path15 from "node:path";
+var TERMINAL_PATH = "/System/Applications/Utilities/Terminal.app/Contents/MacOS/Terminal";
+var ITERM_PATH = "/Applications/iTerm.app/Contents/MacOS/iTerm2";
+var ITERM_SERVER_FOLDER = "Library/Application Support/iTerm2";
+var ITERM_SERVER_NAME = /^iTermServer-[0-9A-Za-z._-]{1,40}$/;
+var TTY_NAME = /^ttys\d{1,4}$/;
+var TTY_PATH = /^\/dev\/ttys\d{1,4}$/;
+function isTtyPath(value) {
+  return typeof value === "string" && TTY_PATH.test(value);
+}
+function ttyPathOf(name) {
+  return TTY_NAME.test(name) ? `/dev/${name}` : null;
+}
+function appOfProgram(program, homeDir) {
+  if (program === TERMINAL_PATH) return "Terminal";
+  if (program === ITERM_PATH) return "iTerm2";
+  const inServerFolder = path15.dirname(program) === path15.join(homeDir, ITERM_SERVER_FOLDER);
+  return inServerFolder && ITERM_SERVER_NAME.test(path15.basename(program)) ? "iTerm2" : null;
+}
+function tabOfProcess(pid, table, homeDir) {
+  const own = table.get(pid);
+  const tty = own ? ttyPathOf(own.tty) : null;
+  if (!own || tty === null) return void 0;
+  const passed = /* @__PURE__ */ new Set([pid]);
+  let current = own.ppid;
+  while (current > 1 && !passed.has(current)) {
+    const parent = table.get(current);
+    if (!parent) return void 0;
+    const app = appOfProgram(parent.path, homeDir);
+    if (app) return { app, tty };
+    if (parent.tty !== own.tty) return void 0;
+    passed.add(current);
+    current = parent.ppid;
+  }
+  return void 0;
+}
+
+// src/collector/terminal/focusTab.ts
+var FOUND = "found";
+var MISSING = "missing";
+var TERMINAL_SCRIPT = [
+  "on run argv",
+  "set wanted to item 1 of argv",
+  `if not (application id "com.apple.Terminal" is running) then return "${MISSING}"`,
+  'tell application id "com.apple.Terminal"',
   "repeat with w in windows",
   "repeat with t in tabs of w",
   "if tty of t is wanted then",
@@ -4237,49 +5690,11 @@ function foundFor(session, panes, tabs) {
   }
   return void 0;
 }
-var refuse = (status, error, headers = {}) => ({
-  status,
-  body: { error },
-  // A refused request's body may not have been read, so its connection is not used again.
-  headers: { Connection: "close", ...headers }
-});
-var failed = (status, reason, error, headers = {}) => ({
+var failed2 = (status, reason, error, headers = {}) => ({
   status,
   body: { error, reason },
   headers
 });
-function header(req, name) {
-  const value = req.headers[name.toLowerCase()];
-  return typeof value === "string" ? value : void 0;
-}
-function actionRefusalFor(req, action, maxBodyBytes) {
-  if (req.method !== "POST") {
-    return refuse(405, "This address only answers POST requests.", { Allow: "POST" });
-  }
-  const origin = header(req, "origin");
-  if (origin === void 0 || !isLoopbackOrigin(origin)) {
-    return refuse(403, "This address only acts for the dashboard page served from this machine.");
-  }
-  const site = req.headers["sec-fetch-site"];
-  if (site !== void 0 && site !== "same-origin") {
-    return refuse(403, "This address only acts for the dashboard page served from this machine.");
-  }
-  if (header(req, ACTION_HEADER) !== action) {
-    return refuse(
-      403,
-      `A request to this address must carry the header ${ACTION_HEADER}: ${action}.`
-    );
-  }
-  const contentType = header(req, "content-type")?.split(";", 1)[0]?.trim().toLowerCase();
-  if (contentType !== "application/json") {
-    return refuse(415, "The body must be JSON, sent as application/json.");
-  }
-  const length = header(req, "content-length");
-  if (length !== void 0 && (!/^\d+$/.test(length) || Number(length) > maxBodyBytes)) {
-    return refuse(413, `The body must be no more than ${maxBodyBytes} bytes.`);
-  }
-  return null;
-}
 function jumpRefusalFor(req) {
   return actionRefusalFor(req, ACTION, MAX_JUMP_BODY_BYTES);
 }
@@ -4297,27 +5712,6 @@ function sessionIdIn(body) {
   if (typeof sessionId !== "string" || sessionId === "") return null;
   return sessionId.length <= MAX_SESSION_ID_LENGTH ? sessionId : null;
 }
-function readBody(req, limit) {
-  return new Promise((resolve) => {
-    const chunks = [];
-    let received = 0;
-    let done = false;
-    const finish = (body) => {
-      if (done) return;
-      done = true;
-      resolve(body);
-    };
-    req.on("data", (chunk) => {
-      if (done) return;
-      received += chunk.byteLength;
-      if (received > limit) finish({ ok: false, tooLarge: true });
-      else chunks.push(chunk);
-    });
-    req.on("end", () => finish({ ok: true, text: Buffer.concat(chunks).toString("utf8") }));
-    req.on("error", () => finish({ ok: false, tooLarge: false }));
-    req.on("close", () => finish({ ok: false, tooLarge: false }));
-  });
-}
 function createJumpRoute(options) {
   const { poller, panes, run, tabs, osascript } = options;
   const now = options.now ?? Date.now;
@@ -4333,41 +5727,41 @@ function createJumpRoute(options) {
     }
     if (outcome.reason === "tab-gone") {
       tabs.forget(pid);
-      return failed(409, "tab-gone", "That tab has closed.");
+      return failed2(409, "tab-gone", "That tab has closed.");
     }
     if (outcome.reason === "not-allowed") {
-      return failed(
+      return failed2(
         403,
         "not-allowed",
         `macOS has not allowed Agent Lookout to control ${tab.app}. Allow it in System Settings, Privacy & Security, Automation.`
       );
     }
-    return failed(500, "failed", `${tab.app} could not be asked to bring the tab forward.`);
+    return failed2(500, "failed", `${tab.app} could not be asked to bring the tab forward.`);
   }
   return async function answerJump(req) {
-    const refusal = jumpRefusalFor(req);
-    if (refusal) {
+    const refused = jumpRefusalFor(req);
+    if (refused) {
       req.resume();
-      return refusal;
+      return refused;
     }
-    const body = await readBody(req, MAX_JUMP_BODY_BYTES);
+    const body = await readRequestBody(req, MAX_JUMP_BODY_BYTES);
     if (!body.ok) {
       req.resume();
-      return body.tooLarge ? refuse(413, `The body must be no more than ${MAX_JUMP_BODY_BYTES} bytes.`) : refuse(400, "The body could not be read.");
+      return body.tooLarge ? refusal(413, `The body must be no more than ${MAX_JUMP_BODY_BYTES} bytes.`) : refusal(400, "The body could not be read.");
     }
     const sessionId = sessionIdIn(body.text);
     if (sessionId === null) {
-      return refuse(400, 'The body must name one session and nothing else: {"sessionId": "..."}.');
+      return refusal(400, 'The body must name one session and nothing else: {"sessionId": "..."}.');
     }
     const session = poller.getSnapshot().sessions.find((candidate) => candidate.id === sessionId);
     const found = foundFor(session, panes, tabs);
     if (!found) {
-      return failed(404, "no-pane", "No tmux pane or terminal tab is known for that session.");
+      return failed2(404, "no-pane", "No tmux pane or terminal tab is known for that session.");
     }
     const at = now();
     const tooSoon = lastAt !== null && at >= lastAt && at - lastAt < JUMP_INTERVAL_MS;
     if (underWay || tooSoon) {
-      return failed(429, "too-soon", "One jump is made a second. Try again in a moment.", {
+      return failed2(429, "too-soon", "One jump is made a second. Try again in a moment.", {
         "Retry-After": "1"
       });
     }
@@ -4388,10 +5782,10 @@ function createJumpRoute(options) {
         };
       }
       if (outcome.reason === "failed") {
-        return failed(500, "failed", "tmux could not be asked to select the pane.");
+        return failed2(500, "failed", "tmux could not be asked to select the pane.");
       }
       panes.lookAgain();
-      return outcome.reason === "pane-gone" ? failed(409, "pane-gone", "That pane has closed.") : failed(409, "tmux-stopped", "tmux is not running.");
+      return outcome.reason === "pane-gone" ? failed2(409, "pane-gone", "That pane has closed.") : failed2(409, "tmux-stopped", "tmux is not running.");
     } finally {
       underWay = false;
     }
@@ -4580,11 +5974,11 @@ function createOsascriptRunner(options) {
 }
 
 // src/collector/terminal/tabFinder.ts
-import os5 from "node:os";
+import os6 from "node:os";
 var TAB_LOOK_SOONEST_MS = 5e3;
 function createTabFinder(options) {
   const off = terminalJumpOff(options.env);
-  const homeDir = options.homeDir ?? os5.homedir();
+  const homeDir = options.homeDir ?? os6.homedir();
   const readProcesses = options.readProcesses ?? readProcessTableWithPs;
   const now = options.now ?? Date.now;
   const soonestMs = options.soonestMs ?? TAB_LOOK_SOONEST_MS;
@@ -4746,6 +6140,89 @@ function createTmuxRunner(options) {
   };
 }
 
+// src/collector/waits/waitLedger.ts
+var LEDGER_KEPT_MS = 9 * 24 * 60 * 60 * 1e3;
+var MAX_EVENTS = 1e5;
+var MAX_SPANS = 5e4;
+function createWaitLedger() {
+  let events = [];
+  let spans = [];
+  let fresh = true;
+  function prune(at) {
+    const cutoff = at - LEDGER_KEPT_MS;
+    let firstEvent = 0;
+    while (firstEvent < events.length && events[firstEvent].at < cutoff) {
+      firstEvent += 1;
+    }
+    firstEvent = Math.max(firstEvent, events.length - MAX_EVENTS);
+    if (firstEvent > 0) events = events.slice(firstEvent);
+    let firstSpan = 0;
+    while (firstSpan < spans.length && spans[firstSpan].to < cutoff) firstSpan += 1;
+    firstSpan = Math.max(firstSpan, spans.length - MAX_SPANS);
+    if (firstSpan > 0) spans = spans.slice(firstSpan);
+  }
+  return {
+    restore(seed) {
+      events = seed.waitEvents.filter(isWaitEvent).concat(events);
+      spans = seed.measured.map((span) => ({ ...span })).concat(spans);
+    },
+    beginRun() {
+      fresh = true;
+    },
+    addEvents(added) {
+      for (const event of added) if (isWaitEvent(event)) events.push(event);
+    },
+    addPoint(point) {
+      addPoll(spans, point.at, fresh);
+      fresh = false;
+      prune(point.at);
+    },
+    clear() {
+      events = [];
+      spans = [];
+      fresh = true;
+    },
+    answer({ now, snapshot, since, runStarts, where }) {
+      const totals = waitTotals({
+        events,
+        measured: spans,
+        runStarts,
+        waitingNow: snapshot.sessions.filter((session) => session.status === "needs-you").map((session) => ({ id: session.id, name: session.name })),
+        names: new Map(snapshot.sessions.map((session) => [session.id, session.name])),
+        since: since.at,
+        now
+      });
+      return { at: now, ...totals, since, where };
+    }
+  };
+}
+function ledgerEventStore(store, ledger) {
+  return {
+    add(added) {
+      store.add(added);
+      ledger.addEvents(added);
+    },
+    list: (options) => store.list(options),
+    clear: () => store.clear(),
+    get size() {
+      return store.size;
+    }
+  };
+}
+function ledgerHistoryStore(store, ledger) {
+  return {
+    add(point) {
+      store.add(point);
+      ledger.addPoint(point);
+    },
+    list: (windowMs, at) => store.list(windowMs, at),
+    clear: () => store.clear(),
+    get size() {
+      return store.size;
+    }
+  };
+}
+
 // src/collector/webhook/webhookSender.ts
 var WEBHOOK_TIMEOUT_MS = 1e4;
 function postHeaders(body, version) {
@@ -4845,6 +6322,7 @@ function createHttpSender(settings, options) {
 var WEBHOOK_URL_ENV = "AGENT_LOOKOUT_WEBHOOK_URL";
 var WEBHOOK_EVENTS_ENV = "AGENT_LOOKOUT_WEBHOOK_EVENTS";
 var WEBHOOK_AFTER_ENV = "AGENT_LOOKOUT_WEBHOOK_AFTER";
+var WEBHOOK_ASKING_ENV = "AGENT_LOOKOUT_WEBHOOK_ASKING";
 var MAX_URL_LENGTH = 2048;
 var URL_UNREADABLE2 = `${WEBHOOK_URL_ENV} could not be read. Copy the whole address, beginning https://.`;
 function readUrl(value) {
@@ -4881,7 +6359,8 @@ function readWebhookSetup(env) {
       settings: {
         url: readUrl(url),
         events: readEvents(WEBHOOK_EVENTS_ENV, valueOf(env, WEBHOOK_EVENTS_ENV)),
-        afterMs: readAfter(WEBHOOK_AFTER_ENV, valueOf(env, WEBHOOK_AFTER_ENV))
+        afterMs: readAfter(WEBHOOK_AFTER_ENV, valueOf(env, WEBHOOK_AFTER_ENV)),
+        asking: readAsking(WEBHOOK_ASKING_ENV, valueOf(env, WEBHOOK_ASKING_ENV))
       }
     };
   } catch (error) {
@@ -4898,8 +6377,28 @@ function createCollector(options) {
   const now = options.now ?? Date.now;
   const env = options.env ?? process.env;
   const intervalMs = options.intervalMs ?? POLL_INTERVAL_MS;
-  const events = createEventStore();
-  const history = createHistoryStore();
+  const warn = options.warn ?? console.error;
+  const memoryEvents = createEventStore();
+  const memoryHistory = createHistoryStore();
+  const historySetup = readHistorySetup(env);
+  const keeper = historySetup.on ? createHistoryKeeper({
+    dir: historySetup.dir,
+    folder: historySetup.folder,
+    fs: options.historyFs,
+    flushIntervalMs: options.historyFlushMs,
+    sources: historySetup.sources,
+    now,
+    warn
+  }) : null;
+  const ledger = createWaitLedger();
+  const events = ledgerEventStore(
+    keeper ? keptEventStore(memoryEvents, keeper) : memoryEvents,
+    ledger
+  );
+  const history = ledgerHistoryStore(
+    keeper ? keptHistoryStore(memoryHistory, keeper) : memoryHistory,
+    ledger
+  );
   const tmux = options.tmux ?? createTmuxRunner({ env });
   const { readProcesses } = options;
   const panes = createPaneFinder({
@@ -4909,7 +6408,6 @@ function createCollector(options) {
   });
   const tabs = createTabFinder({ env, readProcesses: options.readProcesses, now });
   const osascript = options.osascript ?? createOsascriptRunner({ env });
-  const warn = options.warn ?? console.error;
   const platform = options.platform ?? process.platform;
   const notifications = createServerNotifications({
     notifier: options.notifier ?? createSystemNotifier({ platform }),
@@ -4981,15 +6479,84 @@ function createCollector(options) {
     email: () => email?.status() ?? emailOff,
     webhook: () => webhook?.status() ?? webhookOff,
     jump: createJumpRoute({ poller, panes, run: tmux, tabs, osascript, now }),
+    clearHistory: createClearHistoryRoute({
+      keeper,
+      forget: () => {
+        memoryEvents.clear();
+        memoryHistory.clear();
+        ledger.clear();
+        restarts = [];
+        lastKept = null;
+      }
+    }),
+    historyKept: () => ({
+      since: keeper?.since() ?? null,
+      kept: keeper?.status() ?? memoryOnlyStatus(),
+      restarts: restartsHeld()
+    }),
+    waits: () => {
+      const since = keeper?.since() ?? { at: poller.startedAt, by: "started" };
+      return ledger.answer({
+        now: now(),
+        snapshot: poller.getSnapshot(),
+        since,
+        runStarts: [since.at, ...restartsHeld().map((restart) => restart.at), poller.startedAt],
+        where: keeper ? "disk" : "memory"
+      });
+    },
+    ready: () => restoring,
     now
   });
+  let running = false;
+  let restored = keeper === null;
+  let restoring = null;
+  let restarts = [];
+  let lastKept = null;
+  function restartsHeld() {
+    const startedAt = poller.startedAt;
+    if (lastKept === null || lastKept >= startedAt) return restarts;
+    return [...restarts, { at: startedAt, lastBefore: lastKept }];
+  }
+  function begin() {
+    ledger.beginRun();
+    keeper?.start();
+    poller.start();
+  }
   return {
-    start: () => poller.start(),
-    stop: () => poller.stop(),
+    start() {
+      if (running) return;
+      running = true;
+      if (restored || keeper === null) {
+        begin();
+        return;
+      }
+      restoring = keeper.restore({ events: EVENT_CAPACITY, points: HISTORY_CAPACITY }).then((kept) => {
+        restored = true;
+        memoryEvents.add(kept.events);
+        for (const point of kept.points) memoryHistory.add(point);
+        restarts = kept.restarts;
+        lastKept = kept.lastAt;
+        ledger.restore(kept.whole);
+        poller.resume([...unendedWaits(kept.whole.waitEvents), ...kept.events]);
+        if (running) begin();
+      }).catch(() => {
+        restored = true;
+        if (running) begin();
+      }).finally(() => {
+        restoring = null;
+      });
+    },
+    whenStarted: () => restoring ?? Promise.resolve(),
+    stop() {
+      running = false;
+      poller.stop();
+      keeper?.stop();
+    },
     handler,
     poller,
     email,
-    webhook
+    webhook,
+    history: keeper
   };
 }
 
@@ -5010,7 +6577,7 @@ async function runStandalone(options) {
   } catch (error) {
     return stopWith(error.message);
   }
-  if (!existsSync(path14.join(distDir, "index.html"))) {
+  if (!existsSync(path16.join(distDir, "index.html"))) {
     return stopWith(
       "The dashboard has not been built yet. Run `npm run build`, then start it again."
     );