agent-lookout 0.2.4 → 0.2.5

package/dist/cli/{startCommand-KNXMVM2U.js → startCommand-J3QS26SZ.js}

@@ -1,13 +1,20 @@
 import {
   sortSessions
-} from "./chunk-KNOLJ3IC.js";
+} from "./chunk-Q73JDXXW.js";
 import {
+  ANSWER_DECISIONS,
+  CAPABILITIES,
   EVENT_ACTORS,
   EVENT_KINDS,
   EVENT_SEVERITIES,
+  MAX_MACHINE_NAME_LENGTH,
   MAX_NAME_LENGTH,
   MAX_NOTICE_TEXT_LENGTH,
   SESSION_STATUSES,
+  SOURCE_STATES,
+  SOURCE_STATE_LABEL,
+  SURFACES,
+  WAITING_REASONS,
   agentName,
   changeNotice,
   checksStateOf,
@@ -15,22 +22,28 @@ import {
   clockAt,
   cut,
   durationInWords,
+  durationParts,
   formatDuration,
   isGitHubRepository,
+  isMachineName,
   isPullRequestNumber,
+  isRemoteSource,
   isStatusEvent,
   loopbackAddress,
+  noticeTitle,
   oneLine,
   overPhrase,
+  partsInWords,
   pullRequestUrl,
   readAppVersion,
+  remoteSourceId,
   sessionName,
   sessionTitle,
   surfaceLabel,
   waitingPhrase,
   waitingText,
   withoutWaitingText
-} from "./chunk-63XPRBHW.js";
+} from "./chunk-OT3EGOTY.js";
 
 // src/collector/hosts/server.ts
 import { createServer } from "node:http";
@@ -106,15 +119,15 @@ function toldAlready(event, known) {
 function sessionChanges(memory, snapshot) {
   const waits = waitChanges(memory.waits, snapshot);
   const startedWaiting = new Set(waits.started);
-  const answers = /* @__PURE__ */ new Map();
+  const answers2 = /* @__PURE__ */ new Map();
   for (const source of snapshot.sources) {
     if (source.state === "ok" || source.state === "not-set-up") {
-      answers.set(source.id, { basis: source.basis ?? "", sessions: /* @__PURE__ */ new Map() });
+      answers2.set(source.id, { basis: source.basis ?? "", sessions: /* @__PURE__ */ new Map() });
     }
   }
   const found = [];
   for (const session of snapshot.sessions) {
-    const answer = answers.get(session.source);
+    const answer = answers2.get(session.source);
     if (!answer || answer.sessions.has(session.id)) continue;
     answer.sessions.set(session.id, withoutWaitingText(session));
     if (startedWaiting.has(session)) {
@@ -126,7 +139,7 @@ function sessionChanges(memory, snapshot) {
       found.push({ event: session.status, session });
     }
   }
-  for (const [source, { basis, sessions }] of answers) {
+  for (const [source, { basis, sessions }] of answers2) {
     for (const [id, before] of memory.seen.get(source)?.get(basis) ?? []) {
       if (!sessions.has(id) && !isOverStatus(before.status)) {
         found.push({ event: "ended", session: before });
@@ -134,7 +147,7 @@ function sessionChanges(memory, snapshot) {
     }
   }
   const overNow = /* @__PURE__ */ new Map();
-  for (const [source, { sessions }] of answers) {
+  for (const [source, { sessions }] of answers2) {
     const over2 = new Map(memory.over.get(source));
     for (const [id, session] of sessions) {
       if (!isOverStatus(session.status)) over2.delete(id);
@@ -150,7 +163,7 @@ function sessionChanges(memory, snapshot) {
   });
   const seen = new Map(memory.seen);
   const over = new Map(memory.over);
-  for (const [source, { basis, sessions }] of answers) {
+  for (const [source, { basis, sessions }] of answers2) {
     const ways = new Map(memory.seen.get(source));
     ways.set(basis, sessions);
     seen.set(source, ways);
@@ -175,6 +188,10 @@ var CLEAN_UP_ACTION = "clean-up";
 var STOP_WAIT_MS = 1e4;
 var STOP_INTERVAL_MS = 1e3;
 var MAX_CLEAN_UP_SESSIONS = 20;
+var ANSWER_ACTION = "answer";
+var SETTINGS_PATH = "/api/settings";
+var TIME_RULES_PATH = "/api/settings/time-rules";
+var TIME_RULES_ACTION = "time-rules";
 var ACTION_HEADER = "X-Agent-Lookout-Action";
 var MAX_EVENTS_PER_RESPONSE = 200;
 var NOTIFICATIONS_HEADER = "X-Agent-Lookout-Notifications";
@@ -207,15 +224,298 @@ function historyPointFor(sessions, at) {
   return { at, needsYou, working, idle, total: sessions.length };
 }
 
+// src/core/time-rules/quietHold.ts
+function createQuietHold() {
+  let since = null;
+  let waits = [];
+  let over = [];
+  const openWaitOf = (sessionId) => waits.find((wait) => wait.session.id === sessionId && wait.endedAt === null);
+  const lastWaitOf = (sessionId) => {
+    for (let index = waits.length - 1; index >= 0; index -= 1) {
+      const wait = waits[index];
+      if (wait.session.id === sessionId) return wait;
+    }
+    return void 0;
+  };
+  return {
+    holding: () => since !== null,
+    begin(at) {
+      since ??= at;
+    },
+    holdWait(session, begunAt) {
+      const last = lastWaitOf(session.id);
+      if (last?.begunAt === begunAt) {
+        last.endedAt = null;
+        return;
+      }
+      if (last && last.endedAt === null) last.endedAt = begunAt;
+      waits.push({ session: withoutWaitingText(session), begunAt, endedAt: null });
+    },
+    holdOver(event, session, at) {
+      over.push({ event, session: withoutWaitingText(session), at });
+    },
+    waitEnded(sessionId, at) {
+      const held = openWaitOf(sessionId);
+      if (held) held.endedAt = at;
+    },
+    holdsWait: (sessionId) => openWaitOf(sessionId) !== void 0,
+    end(snapshot, at, leaveOutAnswered) {
+      const listed = new Map(snapshot.sessions.map((session) => [session.id, session]));
+      const stillOpen = /* @__PURE__ */ new Map();
+      for (const wait of waits) {
+        const now = listed.get(wait.session.id);
+        if (now?.status !== "needs-you") continue;
+        if (wait.endedAt === null || now.statusSince === wait.begunAt) {
+          stillOpen.set(wait.session.id, wait);
+        }
+      }
+      const open4 = [];
+      for (const [id, wait] of stillOpen) {
+        open4.push({ session: listed.get(id), begunAt: wait.begunAt });
+      }
+      const answered = /* @__PURE__ */ new Map();
+      const lastBegun = /* @__PURE__ */ new Map();
+      for (const wait of waits) {
+        if (stillOpen.get(wait.session.id)?.begunAt === wait.begunAt) continue;
+        if (leaveOutAnswered) continue;
+        const waitedMs = Math.max(0, (wait.endedAt ?? at) - wait.begunAt);
+        lastBegun.set(wait.session.id, wait.begunAt);
+        const item = answered.get(wait.session.id);
+        if (item) {
+          item.waitedMs += waitedMs;
+          item.times += 1;
+        } else {
+          answered.set(wait.session.id, {
+            event: "needs-you",
+            session: wait.session,
+            at: wait.begunAt,
+            waitedMs,
+            times: 1
+          });
+        }
+      }
+      const rest = [];
+      for (const item of over) {
+        const waited = answered.get(item.session.id);
+        const begun = lastBegun.get(item.session.id);
+        if (waited && waited.then === void 0 && begun !== void 0 && item.at >= begun) {
+          waited.then = { event: item.event, at: item.at };
+        } else {
+          rest.push(item);
+        }
+      }
+      const items = [...answered.values(), ...rest].sort((a, b) => a.at - b.at);
+      const from = since ?? at;
+      since = null;
+      waits = [];
+      over = [];
+      return { summary: items.length > 0 ? { from, to: at, items } : null, open: open4 };
+    }
+  };
+}
+
+// src/core/sessions/staleness.ts
+var STALE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
+function isStale(session, now, thresholdMs = STALE_THRESHOLD_MS) {
+  if (session.status !== "idle") return false;
+  if (session.statusSince === null) return false;
+  return now - session.statusSince >= thresholdMs;
+}
+var HOUR_MS = 60 * 60 * 1e3;
+var DAY_MS = 24 * HOUR_MS;
+
+// src/core/time-rules/timeRules.ts
+var WEEKDAYS = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+var TIME_RULE_NAMES = ["longWait", "idle", "quietHours"];
+var LONG_WAIT_MINUTES = { min: 1, max: 1440, default: 10 };
+var IDLE_HOURS = { min: 1, max: 720, default: 48 };
+var DEFAULT_TIME_RULES = {
+  longWait: { on: false, minutes: LONG_WAIT_MINUTES.default },
+  idle: { on: false, hours: IDLE_HOURS.default },
+  quietHours: {
+    on: false,
+    from: "22:00",
+    to: "08:00",
+    days: [...WEEKDAYS],
+    leaveOutAnswered: false
+  }
+};
+var HOUR_MS2 = 36e5;
+var CLOCK = /^([01]\d|2[0-3]):([0-5]\d)$/;
+function clockMinutes(clock) {
+  const match = CLOCK.exec(clock);
+  if (!match) return null;
+  return Number(match[1]) * 60 + Number(match[2]);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function holds(value, keys, exact2) {
+  if (!keys.every((key) => key in value)) return false;
+  return !exact2 || Object.keys(value).length === keys.length;
+}
+function wholeNumberIn(value, range) {
+  return Number.isSafeInteger(value) && value >= range.min && value <= range.max;
+}
+function readLongWait(value, exact2) {
+  if (!isRecord(value) || !holds(value, ["on", "minutes"], exact2)) return null;
+  const { on, minutes } = value;
+  if (typeof on !== "boolean" || !wholeNumberIn(minutes, LONG_WAIT_MINUTES)) return null;
+  return { on, minutes };
+}
+function readIdle(value, exact2) {
+  if (!isRecord(value) || !holds(value, ["on", "hours"], exact2)) return null;
+  const { on, hours } = value;
+  if (typeof on !== "boolean" || !wholeNumberIn(hours, IDLE_HOURS)) return null;
+  return { on, hours };
+}
+function readDays(value) {
+  if (!Array.isArray(value)) return null;
+  if (!value.every((day) => WEEKDAYS.includes(day))) return null;
+  if (new Set(value).size !== value.length) return null;
+  return WEEKDAYS.filter((day) => value.includes(day));
+}
+function readQuietHours(value, exact2) {
+  const keys = ["on", "from", "to", "days", "leaveOutAnswered"];
+  if (!isRecord(value) || !holds(value, keys, exact2)) return null;
+  const { on, from, to, leaveOutAnswered } = value;
+  if (typeof on !== "boolean" || typeof leaveOutAnswered !== "boolean") return null;
+  if (typeof from !== "string" || typeof to !== "string") return null;
+  const begins = clockMinutes(from);
+  const ends = clockMinutes(to);
+  if (begins === null || ends === null || begins === ends) return null;
+  const days = readDays(value.days);
+  if (days === null) return null;
+  return { on, from, to, days, leaveOutAnswered };
+}
+var READERS = {
+  longWait: readLongWait,
+  idle: readIdle,
+  quietHours: readQuietHours
+};
+var SHAPES = {
+  longWait: `longWait must be {"on", "minutes"}, with minutes a whole number from ${LONG_WAIT_MINUTES.min} to ${LONG_WAIT_MINUTES.max}.`,
+  idle: `idle must be {"on", "hours"}, with hours a whole number from ${IDLE_HOURS.min} to ${IDLE_HOURS.max}.`,
+  quietHours: 'quietHours must be {"on", "from", "to", "days", "leaveOutAnswered"}, with from and to two different times written as 22:00 is, and days any of mon, tue, wed, thu, fri, sat and sun, each once.'
+};
+function readTimeRules(value) {
+  const rules = {
+    longWait: { ...DEFAULT_TIME_RULES.longWait },
+    idle: { ...DEFAULT_TIME_RULES.idle },
+    quietHours: { ...DEFAULT_TIME_RULES.quietHours, days: [...WEEKDAYS] }
+  };
+  const unread = [];
+  if (!isRecord(value)) return { rules, unread: value === void 0 ? [] : [...TIME_RULE_NAMES] };
+  for (const name of TIME_RULE_NAMES) {
+    if (value[name] === void 0) continue;
+    const read = READERS[name](value[name], false);
+    if (read === null) unread.push(name);
+    else Object.assign(rules, { [name]: read });
+  }
+  return { rules, unread };
+}
+function timeRulesIn(value) {
+  if (!isRecord(value) || !holds(value, TIME_RULE_NAMES, true)) {
+    return {
+      ok: false,
+      problem: "The body must be the three time rules, longWait, idle and quietHours, and nothing else."
+    };
+  }
+  const rules = {};
+  for (const name of TIME_RULE_NAMES) {
+    const read = READERS[name](value[name], true);
+    if (read === null) return { ok: false, problem: SHAPES[name] };
+    Object.assign(rules, { [name]: read });
+  }
+  return { ok: true, rules };
+}
+function staleAfterMs(rules) {
+  return rules?.idle.on ? rules.idle.hours * HOUR_MS2 : STALE_THRESHOLD_MS;
+}
+function rulesOf(snapshot) {
+  return snapshot.timeRules ?? DEFAULT_TIME_RULES;
+}
+
+// src/core/time-rules/quietHours.ts
+var DAY_OF_WEEK = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+function isQuietAt(rule, at) {
+  if (!rule.on) return false;
+  const from = clockMinutes(rule.from);
+  const to = clockMinutes(rule.to);
+  if (from === null || to === null || from === to) return false;
+  const date = new Date(at);
+  const minute = date.getHours() * 60 + date.getMinutes();
+  const today = DAY_OF_WEEK[date.getDay()];
+  if (from < to) return minute >= from && minute < to && rule.days.includes(today);
+  if (minute >= from) return rule.days.includes(today);
+  if (minute < to) {
+    const yesterday = DAY_OF_WEEK[(date.getDay() + 6) % 7];
+    return rule.days.includes(yesterday);
+  }
+  return false;
+}
+function quietOf(snapshot) {
+  return snapshot.quiet ?? isQuietAt(rulesOf(snapshot).quietHours, snapshot.generatedAt);
+}
+
+// src/core/time-rules/reminders.ts
+function readable(snapshot) {
+  return new Set(
+    snapshot.sources.filter((source) => source.state === "ok" || source.state === "not-set-up").map((source) => source.id)
+  );
+}
+function createReminderWatch() {
+  const watched = /* @__PURE__ */ new Map();
+  return {
+    observe(snapshot, stopped, at) {
+      for (const id of stopped) watched.delete(id);
+      const sources = readable(snapshot);
+      for (const session of snapshot.sessions) {
+        if (session.status !== "needs-you" || !sources.has(session.source)) continue;
+        const since = session.statusSince !== null && session.statusSince <= at ? session.statusSince : null;
+        const known = watched.get(session.id);
+        if (known && (since === null || since === known.begunAt)) continue;
+        watched.set(session.id, {
+          begunAt: since ?? at,
+          firstSeenAfterMs: since === null ? 0 : at - since,
+          reminded: /* @__PURE__ */ new Set()
+        });
+      }
+    },
+    due(snapshot, at, thresholdMs, eligible = () => true) {
+      const found = [];
+      for (const session of snapshot.sessions) {
+        if (session.status !== "needs-you") continue;
+        const wait = watched.get(session.id);
+        if (!wait || wait.reminded.has(thresholdMs) || !eligible(session.id)) continue;
+        const waitedMs = at - wait.begunAt;
+        if (waitedMs < thresholdMs || wait.firstSeenAfterMs >= thresholdMs) continue;
+        found.push({ session, begunAt: wait.begunAt, waitedMs });
+      }
+      return found;
+    },
+    reminded(sessionId, thresholdMs) {
+      watched.get(sessionId)?.reminded.add(thresholdMs);
+    },
+    toldLate(sessionId, at, thresholdMs) {
+      const wait = watched.get(sessionId);
+      if (wait && at - wait.begunAt >= thresholdMs) wait.reminded.add(thresholdMs);
+    },
+    clear() {
+      watched.clear();
+    }
+  };
+}
+
 // src/collector/outbound/outboundTiming.ts
-var HOUR_MS = 36e5;
+var HOUR_MS3 = 36e5;
 function sendsInLastHour(sentAt, now) {
-  return sentAt.filter((at) => now - at < HOUR_MS).sort((a, b) => a - b);
+  return sentAt.filter((at) => now - at < HOUR_MS3).sort((a, b) => a - b);
 }
 function limitLiftsAt(sentAt, now) {
   const recent = sendsInLastHour(sentAt, now);
   if (recent.length < SENDS_PER_HOUR) return null;
-  return recent[recent.length - SENDS_PER_HOUR] + HOUR_MS;
+  return recent[recent.length - SENDS_PER_HOUR] + HOUR_MS3;
 }
 function sendTiming(begunAt, afterMs, sentAt, now) {
   if (now - begunAt < afterMs) return "wait";
@@ -227,14 +527,16 @@ function waitBegan(statusSince, seenAt) {
 
 // src/collector/outbound/outboundChannel.ts
 function createOutboundChannel(options) {
-  const { afterMs, asking, waitMessage, overMessage, failure: failure2 } = options;
+  const { afterMs, asking, waitMessage, overMessage, reminderMessage, summaryMessage, failure: failure2 } = options;
   const now = options.now ?? Date.now;
   const wanted = new Set(options.events);
   let memory = EMPTY_CHANGE_MEMORY;
-  const over = [];
+  const ready = [];
   const open4 = /* @__PURE__ */ new Map();
   const done = /* @__PURE__ */ new Map();
   let sentAt = [];
+  const reminders = createReminderWatch();
+  const hold = createQuietHold();
   let last = null;
   let queue = Promise.resolve();
   function send2(content) {
@@ -251,18 +553,42 @@ function createOutboundChannel(options) {
     handle(snapshot) {
       try {
         const at = now();
+        const rules = rulesOf(snapshot);
+        const quiet = quietOf(snapshot);
         const result = sessionChanges(memory, snapshot);
         memory = result.memory;
-        for (const id of result.stopped) open4.delete(id);
+        for (const id of result.stopped) {
+          open4.delete(id);
+          hold.waitEnded(id, at);
+        }
+        reminders.observe(snapshot, result.stopped, at);
+        if (hold.holding() && !quiet) {
+          const end = hold.end(snapshot, at, rules.quietHours.leaveOutAnswered);
+          const { summary } = end;
+          if (summary) {
+            const items = summary.items.map((item) => ({
+              ...item,
+              agent: agentName(item.session, snapshot.sources)
+            }));
+            ready.push((sentNow) => summaryMessage({ ...summary, items, now: sentNow }));
+          }
+          for (const { session, begunAt } of end.open) open4.set(session.id, begunAt);
+        }
+        if (quiet) hold.begin(at);
         for (const { event, session } of result.changes) {
           if (!wanted.has(event)) continue;
           if (event !== "needs-you") {
-            over.push({
+            if (quiet) {
+              hold.holdOver(event, session, at);
+              continue;
+            }
+            const facts = {
               event,
               session: withoutWaitingText(session),
               agent: agentName(session, snapshot.sources),
               seenAt: at
-            });
+            };
+            ready.push((sentNow) => overMessage({ ...facts, now: sentNow }));
             continue;
           }
           const since = session.statusSince;
@@ -270,16 +596,25 @@ function createOutboundChannel(options) {
           open4.set(session.id, waitBegan(since, at));
         }
         sentAt = sendsInLastHour(sentAt, at);
-        while (over.length > 0 && limitLiftsAt(sentAt, at) === null) {
-          const facts = over.shift();
+        while (!quiet && ready.length > 0 && limitLiftsAt(sentAt, at) === null) {
+          const write = ready.shift();
           sentAt.push(at);
-          send2(overMessage({ ...facts, now: at }));
+          send2(write(at));
         }
+        const thresholdMs = rules.longWait.minutes * 6e4;
         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;
+          if (!session) continue;
+          const timing = sendTiming(begunAt, afterMs, sentAt, at);
+          if (timing === "wait") continue;
+          if (quiet) {
+            open4.delete(id);
+            hold.holdWait(session, begunAt);
+            continue;
+          }
+          if (timing === "limited") continue;
           open4.delete(id);
           sentAt.push(at);
           send2(
@@ -292,6 +627,24 @@ function createOutboundChannel(options) {
               now: at
             })
           );
+          if (rules.longWait.on) reminders.toldLate(id, at, thresholdMs);
+        }
+        if (!quiet && rules.longWait.on && wanted.has("needs-you")) {
+          for (const due of reminders.due(snapshot, at, thresholdMs, (id) => !open4.has(id))) {
+            if (limitLiftsAt(sentAt, at) !== null) break;
+            sentAt.push(at);
+            reminders.reminded(due.session.id, thresholdMs);
+            send2(
+              reminderMessage({
+                session: withoutWaitingText(due.session),
+                agent: agentName(due.session, snapshot.sources),
+                asking: asking ? waitingText(due.session.waitingText) ?? null : null,
+                begunAt: due.begunAt,
+                now: at,
+                thresholdMs
+              })
+            );
+          }
         }
         for (const session of snapshot.sessions) {
           if (session.status === "needs-you" && session.statusSince !== null && !open4.has(session.id)) {
@@ -307,6 +660,52 @@ function createOutboundChannel(options) {
   };
 }
 
+// src/core/time-rules/timeRulesWords.ts
+var MINUTE_MS = 6e4;
+function waitedInWords(ms) {
+  if (ms < MINUTE_MS) return "under a minute";
+  return partsInWords(durationParts(ms).filter((part) => part.unit !== "s"));
+}
+var WAITED_FOR = {
+  permission: "for permission",
+  question: "for an answer",
+  other: "for you"
+};
+function reminderPhrase(session, waitedMs) {
+  return `has waited ${waitedInWords(waitedMs)} ${WAITED_FOR[session.waitingReason ?? "other"]}`;
+}
+function reminderSentence(session, waitedMs) {
+  return `${oneLine(sessionTitle(session))} ${reminderPhrase(session, waitedMs)}`;
+}
+function reminderNotice(session, waitedMs) {
+  const phrase = reminderPhrase(session, waitedMs);
+  const said = `${phrase.charAt(0).toUpperCase()}${phrase.slice(1)}`;
+  const asking = session.waitingText?.trim();
+  return { title: noticeTitle(session), body: asking ? `${said}: ${asking}` : said };
+}
+var WHILE_QUIET = "While quiet";
+function summaryWaitedPhrase(item) {
+  const waited = waitedInWords(item.waitedMs);
+  return item.times === 1 ? `waited ${waited}` : `waited ${waited} over ${item.times} waits`;
+}
+function summaryItemPhrase(item, title = sessionTitle) {
+  const name = oneLine(title(item.session));
+  if (item.event !== "needs-you") return `${name} ${overPhrase(item.event)}`;
+  const waited = `${name} ${summaryWaitedPhrase(item)}`;
+  return item.then ? `${waited} then ${overPhrase(item.then.event)}` : waited;
+}
+function summaryLine(items, named = 4, title = sessionTitle) {
+  const shown = items.slice(0, named).map((item) => summaryItemPhrase(item, title));
+  const rest = items.length - shown.length;
+  if (rest === 0) {
+    return shown.length <= 1 ? shown[0] ?? "" : `${shown.slice(0, -1).join(", ")} and ${shown[shown.length - 1]}`;
+  }
+  return `${shown.join(", ")} and ${rest} more`;
+}
+function summaryNotice(items) {
+  return { title: WHILE_QUIET, body: summaryLine(items, void 0, noticeTitle) };
+}
+
 // src/collector/outbound/outboundSettings.ts
 var DEFAULT_AFTER_SECONDS = 60;
 var MAX_AFTER_SECONDS = 86400;
@@ -439,6 +838,7 @@ function maskAddress(address) {
 }
 
 // src/collector/email/emailMessage.ts
+var SENT_BY = `Sent by Agent Lookout on your computer. To stop these emails, start it again without ${EMAIL_TO_ENV}.`;
 function emailOf(happened, when, session, agentName2, asking = null) {
   const lines = [`${happened}.`, "", when, ""];
   const said = waitingText(asking);
@@ -449,10 +849,7 @@ function emailOf(happened, when, session, agentName2, asking = null) {
   if (app) lines.push(`App: ${app}`);
   const agent = agentName2 ? oneLine(agentName2) : "";
   if (agent) lines.push(`Agent: ${agent}`);
-  lines.push(
-    "",
-    `Sent by Agent Lookout on your computer. To stop these emails, start it again without ${EMAIL_TO_ENV}.`
-  );
+  lines.push("", SENT_BY);
   return { subject: happened, text: `${lines.join("\n")}
 ` };
 }
@@ -466,6 +863,42 @@ function waitEmail(facts) {
     facts.asking
   );
 }
+function reminderEmail(facts) {
+  const { session, begunAt, now } = facts;
+  return emailOf(
+    reminderSentence(session, now - begunAt),
+    `It has waited since ${clockAt(begunAt, now)}. Agent Lookout reminds you once a wait lasts ${waitedInWords(facts.thresholdMs)}, as Time rules in Settings says.`,
+    session,
+    facts.agent,
+    facts.asking
+  );
+}
+var MAX_SUMMARY_LINES = 50;
+function summaryItemLine(item, now) {
+  if (item.event !== "needs-you") return `${summaryItemPhrase(item)} at ${clockAt(item.at, now)}.`;
+  const waited = `${oneLine(sessionTitle(item.session))} ${summaryWaitedPhrase(item)}, from ${clockAt(item.at, now)}`;
+  return item.then ? `${waited}, then ${overPhrase(item.then.event)} at ${clockAt(item.then.at, now)}.` : `${waited}.`;
+}
+function summaryEmail(facts) {
+  const { items, now } = facts;
+  const lines = [
+    `During quiet hours, from ${clockAt(facts.from, now)} to ${clockAt(facts.to, now)}:`,
+    "",
+    ...items.slice(0, MAX_SUMMARY_LINES).map((item) => summaryItemLine(item, now))
+  ];
+  if (items.length > MAX_SUMMARY_LINES) lines.push(`And ${items.length - MAX_SUMMARY_LINES} more.`);
+  lines.push(
+    "",
+    "Quiet hours are set under Time rules in Settings. A session still waiting when they ended has an email of its own.",
+    "",
+    SENT_BY
+  );
+  return {
+    subject: oneLine(`${WHILE_QUIET}: ${summaryLine(items, 3)}`, 160),
+    text: `${lines.join("\n")}
+`
+  };
+}
 function overEmail(facts) {
   const { session, seenAt, now } = facts;
   return emailOf(
@@ -497,6 +930,8 @@ function createEmailNotifications(options) {
     asking: settings.asking,
     waitMessage: waitEmail,
     overMessage: overEmail,
+    reminderMessage: reminderEmail,
+    summaryMessage: summaryEmail,
     send: (content) => sender.send(content),
     failure: "the email could not be sent",
     now: options.now
@@ -523,7 +958,7 @@ function createEmailNotifications(options) {
 var HISTORY_FORMAT_VERSION = 1;
 var MAX_LINE_LENGTH = 8 * 1024;
 var MAX_FIELD_LENGTH = 1024;
-var DAY_MS = 24 * 60 * 60 * 1e3;
+var DAY_MS2 = 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);
@@ -545,7 +980,7 @@ function byFileOrder(a, b) {
   return a.dayStart - b.dayStart || a.part - b.part;
 }
 function dayEnd(file) {
-  return file.dayStart + DAY_MS;
+  return file.dayStart + DAY_MS2;
 }
 function recordAt(record) {
   if (record.kind === "point") return record.point.at;
@@ -571,7 +1006,7 @@ function recordValue(record) {
   }
 }
 function eventFields(event) {
-  const { id, at, sessionId, sessionName: sessionName2, kind, from, to, severity, by } = event;
+  const { id, at, sessionId, sessionName: sessionName2, kind, from, to, severity, by, decision } = event;
   return {
     id,
     at,
@@ -581,10 +1016,11 @@ function eventFields(event) {
     ...from !== void 0 && { from },
     ...to !== void 0 && { to },
     severity,
-    ...by !== void 0 && { by }
+    ...by !== void 0 && { by },
+    ...decision !== void 0 && { decision }
   };
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function moment(value) {
@@ -609,7 +1045,7 @@ function readPoint(value) {
   return { at, needsYou, working, idle, total };
 }
 function readEvent(value) {
-  if (!isRecord(value)) return null;
+  if (!isRecord2(value)) return null;
   const id = field(value.id);
   const at = moment(value.at);
   const sessionId = field(value.sessionId);
@@ -622,6 +1058,8 @@ function readEvent(value) {
   if (value.from !== void 0 && !from || value.to !== void 0 && !to) return null;
   const by = oneOf(EVENT_ACTORS, value.by);
   if (value.by !== void 0 && !by) return null;
+  const decision = oneOf(ANSWER_DECISIONS, value.decision);
+  if (value.decision !== void 0 && !decision) return null;
   return {
     id,
     at,
@@ -631,7 +1069,8 @@ function readEvent(value) {
     ...from && { from },
     ...to && { to },
     severity,
-    ...by && { by }
+    ...by && { by },
+    ...decision && { decision }
   };
 }
 function parseRecord(line) {
@@ -642,7 +1081,7 @@ function parseRecord(line) {
   } catch {
     return null;
   }
-  if (!isRecord(value)) return null;
+  if (!isRecord2(value)) return null;
   if ("point" in value) {
     const point = readPoint(value.point);
     return point && { kind: "point", point };
@@ -846,6 +1285,12 @@ function withoutRepeats(events, reported) {
 // src/collector/poller.ts
 var POLL_INTERVAL_MS = 2e3;
 var POLL_DEADLINE_MS = 15e3;
+function staleBy(sessions, at, thresholdMs) {
+  return sessions.map((session) => {
+    const stale = isStale(session, at, thresholdMs);
+    return stale === session.stale ? session : { ...session, stale };
+  });
+}
 function declared(adapter) {
   return adapter.capabilities === void 0 ? {} : { capabilities: adapter.capabilities };
 }
@@ -875,6 +1320,14 @@ function createPoller(options) {
   let inFlight = null;
   let timer = null;
   const memory = /* @__PURE__ */ new Map();
+  function sourceOf(sessionId) {
+    let found = null;
+    for (const adapter of adapters) {
+      if (!sessionId.startsWith(`${adapter.id}:`)) continue;
+      if (found === null || adapter.id.length > found.length) found = adapter.id;
+    }
+    return found;
+  }
   const resumed = /* @__PURE__ */ new Map();
   const overdue = /* @__PURE__ */ new Map();
   const settled = /* @__PURE__ */ new Map();
@@ -977,6 +1430,7 @@ function createPoller(options) {
       }
       baselines.set(basis, result.sessions.map(withoutWaitingText));
     });
+    const rules = options.timeRules?.();
     const snapshot = {
       generatedAt: at,
       // The way each was read goes with it, so what follows the snapshots
@@ -987,7 +1441,8 @@ function createPoller(options) {
         ...result.basis !== void 0 && { basis: result.basis },
         ...declared(adapters[index])
       })),
-      sessions: sortSessions(found)
+      sessions: sortSessions(staleBy(found, at, staleAfterMs(rules))),
+      ...rules && { timeRules: rules, quiet: isQuietAt(rules.quietHours, at) }
     };
     latest = snapshot;
     events.add(changes);
@@ -1035,9 +1490,8 @@ function createPoller(options) {
       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 source = sourceOf(event.sessionId);
+        if (source === null) continue;
         const list = resumed.get(source) ?? [];
         list.push({ id: event.sessionId, name: event.sessionName, status });
         resumed.set(source, list);
@@ -1066,6 +1520,7 @@ function createPoller(options) {
 }
 
 // src/collector/webhook/webhookMessage.ts
+var MAX_SUMMARY_ITEMS = 100;
 function slackSafe(text4) {
   return text4.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/@/g, "@\u200B");
 }
@@ -1104,6 +1559,43 @@ function waitPost(facts) {
     waitedSeconds: Math.floor(waitedMs / 1e3)
   };
 }
+function reminderPost(facts) {
+  const post = waitPost(facts);
+  const asking = waitingText(facts.asking);
+  const said = reminderSentence(facts.session, facts.now - facts.begunAt);
+  return {
+    ...post,
+    text: lineOf(asking ? `${said}: ${asking}` : said, [
+      post.session.folder,
+      post.session.app,
+      post.session.agent
+    ]),
+    reminder: true
+  };
+}
+function summaryPost(facts) {
+  const items = facts.items.slice(0, MAX_SUMMARY_ITEMS).map((item) => ({
+    event: item.event,
+    session: sessionOf(item.session, item.agent),
+    at: new Date(item.at).toISOString(),
+    ...item.event === "needs-you" && {
+      waitedSeconds: Math.floor(item.waitedMs / 1e3),
+      times: item.times,
+      ...item.then && {
+        then: { event: item.then.event, at: new Date(item.then.at).toISOString() }
+      }
+    }
+  }));
+  const more = facts.items.length - items.length;
+  return {
+    text: slackSafe(`${WHILE_QUIET}: ${summaryLine(facts.items)}`),
+    event: "quiet-summary",
+    from: new Date(facts.from).toISOString(),
+    to: new Date(facts.to).toISOString(),
+    items,
+    ...more > 0 && { more }
+  };
+}
 function overPost(facts) {
   const session = sessionOf(facts.session, facts.agent);
   return {
@@ -1139,6 +1631,8 @@ function createWebhookNotifications(options) {
     asking: settings.asking,
     waitMessage: waitPost,
     overMessage: overPost,
+    reminderMessage: reminderPost,
+    summaryMessage: summaryPost,
     send: (post) => sender.send(post),
     failure: "the post could not be sent",
     now: options.now
@@ -1167,6 +1661,7 @@ var JUMP_PATH = "/api/jump";
 var CLEAR_HISTORY_PATH = "/api/history/clear";
 var STOP_PATH = "/api/sessions/stop";
 var CLEAN_UP_PATH = "/api/sessions/clean-up";
+var ANSWER_PATH = "/api/permission/answer";
 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;
@@ -1294,6 +1789,9 @@ function createApiHandler(options) {
   if (options.clearHistory) actions.set(CLEAR_HISTORY_PATH, options.clearHistory);
   if (options.stop) actions.set(STOP_PATH, options.stop);
   if (options.cleanUp) actions.set(CLEAN_UP_PATH, options.cleanUp);
+  if (options.answer) actions.set(ANSWER_PATH, options.answer);
+  if (options.timeRules) actions.set(TIME_RULES_PATH, options.timeRules);
+  const serveSnapshot = options.serveSnapshot ?? ((snapshot) => snapshot);
   function route(req, res) {
     const refusal2 = refusalFor(req);
     if (refusal2) {
@@ -1331,7 +1829,7 @@ function createApiHandler(options) {
         return;
       }
       case "/api/sessions": {
-        send(res, 200, poller.getSnapshot());
+        send(res, 200, serveSnapshot(poller.getSnapshot()));
         return;
       }
       case "/api/events": {
@@ -1382,6 +1880,14 @@ function createApiHandler(options) {
         });
         return;
       }
+      case SETTINGS_PATH: {
+        if (options.settings) {
+          send(res, 200, options.settings());
+          return;
+        }
+        fail(res, 404, "There is nothing at that address.");
+        return;
+      }
       case "/api/waits": {
         if (options.waits) {
           send(res, 200, options.waits());
@@ -1599,9 +2105,9 @@ function createAppServer(options) {
 function portAnswers(host, port) {
   return new Promise((resolve) => {
     const socket = connect({ host, port });
-    const finish = (answers) => {
+    const finish = (answers2) => {
       socket.destroy();
-      resolve(answers);
+      resolve(answers2);
     };
     socket.setTimeout(1e3, () => finish(false));
     socket.once("connect", () => finish(true));
@@ -1630,7 +2136,7 @@ function urlFor(address) {
 
 // src/collector/hosts/standalone.ts
 import { existsSync } from "node:fs";
-import path18 from "node:path";
+import path23 from "node:path";
 
 // src/core/mapping/claudeCodeMapping.ts
 var LIVE_STATUS = /* @__PURE__ */ new Map([
@@ -1657,10 +2163,10 @@ function liveStatusOf(status, origin) {
   return REGISTRY_LIVE_STATUS.get(status);
 }
 function mapClaudeCodeStatus(fields, origin = "feed") {
-  const live = liveStatusOf(fields.status, origin);
+  const live2 = liveStatusOf(fields.status, origin);
   const background = typeof fields.state === "string" ? BACKGROUND_STATE.get(fields.state) : void 0;
   const backgroundSaysMore = background !== void 0 && background !== "working";
-  const status = live === "idle" && backgroundSaysMore ? background : live ?? background ?? "unknown";
+  const status = live2 === "idle" && backgroundSaysMore ? background : live2 ?? background ?? "unknown";
   if (status !== "needs-you") return { status };
   return { status, ...mapClaudeCodeWaitingFor(fields.waitingFor) };
 }
@@ -1688,14 +2194,6 @@ function claudeCodeOpenLink(surface, sessionId) {
   return `vscode://anthropic.claude-code/open?session=${encodeURIComponent(sessionId)}`;
 }
 
-// src/core/sessions/staleness.ts
-var STALE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
-function isStale(session, now, thresholdMs = STALE_THRESHOLD_MS) {
-  if (session.status !== "idle") return false;
-  if (session.statusSince === null) return false;
-  return now - session.statusSince >= thresholdMs;
-}
-
 // src/collector/terminal/terminalTabs.ts
 import path2 from "node:path";
 var TERMINAL_PATH = "/System/Applications/Utilities/Terminal.app/Contents/MacOS/Terminal";
@@ -2752,9 +3250,9 @@ function targetFor(entry, answer, options) {
   }
   return null;
 }
-function withStopOffers(sessions, live, answer, options) {
+function withStopOffers(sessions, live2, answer, options) {
   const byId = /* @__PURE__ */ new Map();
-  for (const entry of live) {
+  for (const entry of live2) {
     if (entry.sessionId !== void 0) byId.set(`${SOURCE_ID}:${entry.sessionId}`, entry);
   }
   const targets = /* @__PURE__ */ new Map();
@@ -2828,7 +3326,7 @@ function isMissing(error) {
 }
 
 // src/collector/adapters/claude-code/transcript/lastAsk.ts
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonEmpty(value) {
@@ -2836,8 +3334,8 @@ function nonEmpty(value) {
 }
 function blocksOf(line) {
   const message = line.message;
-  if (!isRecord2(message) || !Array.isArray(message.content)) return [];
-  return message.content.filter(isRecord2);
+  if (!isRecord3(message) || !Array.isArray(message.content)) return [];
+  return message.content.filter(isRecord3);
 }
 function linesOf(tail, fromStart) {
   const pieces = tail.split("\n");
@@ -2847,7 +3345,7 @@ function linesOf(tail, fromStart) {
     if (piece.trim() === "") continue;
     try {
       const value = JSON.parse(piece);
-      if (isRecord2(value)) lines.push(value);
+      if (isRecord3(value)) lines.push(value);
     } catch {
     }
   }
@@ -2855,7 +3353,7 @@ function linesOf(tail, fromStart) {
 }
 function isPrompt(line) {
   if (line.isMeta === true) return false;
-  const message = isRecord2(line.message) ? line.message : null;
+  const message = isRecord3(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");
@@ -2866,7 +3364,7 @@ function pendingToolUse(lines) {
   let movedOn = false;
   for (const line of lines) {
     if (line.isSidechain === true) continue;
-    const message = isRecord2(line.message) ? line.message : null;
+    const message = isRecord3(line.message) ? line.message : null;
     if (line.type === "assistant") {
       const messageId = nonEmpty(message?.id);
       const newest3 = uses.at(-1);
@@ -2878,7 +3376,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: isRecord2(block.input) ? block.input : {}, messageId });
+        uses.push({ id, name, input: isRecord3(block.input) ? block.input : {}, messageId });
         movedOn = false;
       }
     } else if (line.type === "user") {
@@ -2919,7 +3417,7 @@ function describeToolUse(name, input, cwd) {
   if (name === "AskUserQuestion") {
     const questions = Array.isArray(input.questions) ? input.questions : [];
     const first = questions[0];
-    const question = isRecord2(first) ? nonEmpty(first.question) : null;
+    const question = isRecord3(first) ? nonEmpty(first.question) : null;
     if (question === null) return null;
     return questions.length > 1 ? `${question} (+${questions.length - 1} more)` : question;
   }
@@ -3112,15 +3610,23 @@ var CLAUDE_CODE_CAPABILITIES = {
   stop: {
     level: "partly",
     reason: "In a terminal, in VS Code and for background jobs. Not in the desktop app."
+  },
+  answer: {
+    level: "partly",
+    reason: "With the Agent Lookout plugin installed. Allow only when all it allows is shown, so edits, plans and questions can only be denied."
   }
 };
 var STOP_TURNED_OFF = {
   level: "no",
   reason: `${STOP_ENV} is off, so no session is stopped from Agent Lookout.`
 };
+var ANSWER_TURNED_OFF = {
+  level: "no",
+  reason: "AGENT_LOOKOUT_ANSWER is off, so no permission prompt is answered from Agent Lookout."
+};
 var COULD_NOT_RUN = "The claude agents --json command could not be run";
-function capitalise(sentence) {
-  return sentence.charAt(0).toUpperCase() + sentence.slice(1);
+function capitalise(sentence2) {
+  return sentence2.charAt(0).toUpperCase() + sentence2.slice(1);
 }
 function startedAfter(entry, since, now) {
   const startedAt = plausibleTime(entry.startedAt, now);
@@ -3144,7 +3650,12 @@ function createClaudeCodeAdapter(options = {}) {
   const feedWithheld = homeOverride !== void 0 && !binaryNamed;
   const neverRun = feedOff || feedWithheld;
   const stops = stopOff(env) ? void 0 : options.stops;
-  const capabilities = stopOff(env) ? { ...CLAUDE_CODE_CAPABILITIES, stop: STOP_TURNED_OFF } : CLAUDE_CODE_CAPABILITIES;
+  const answersOff = env.AGENT_LOOKOUT_ANSWER?.trim().toLowerCase() === "off";
+  const capabilities = stopOff(env) || answersOff ? {
+    ...CLAUDE_CODE_CAPABILITIES,
+    ...stopOff(env) && { stop: STOP_TURNED_OFF },
+    ...answersOff && { answer: ANSWER_TURNED_OFF }
+  } : CLAUDE_CODE_CAPABILITIES;
   const claudeHome = path9.resolve(homeOverride ?? path9.join(homeDir, ".claude"));
   const sessionsDir = path9.join(claudeHome, "sessions");
   const homeName = tildify(claudeHome, homeDir);
@@ -3181,17 +3692,17 @@ function createClaudeCodeAdapter(options = {}) {
       (entry) => entry.sessionId !== void 0 && isClaudeCodeSessionKind(entry.kind) && isAlive(entry.pid)
     );
     const reused = await startCheck.reused(candidates);
-    const live = candidates.filter((entry) => !reused.has(entry.pid));
-    const unknownStatus = live.some((entry) => {
+    const live2 = candidates.filter((entry) => !reused.has(entry.pid));
+    const unknownStatus = live2.some((entry) => {
       if (mapClaudeCodeStatus(entry, "registry").status !== "unknown") return false;
       const saysNothing = entry.status === void 0 && entry.state === void 0;
       return !(saysNothing && startedAfter(entry, at - NEW_SESSION_GRACE_MS, at));
     });
-    return { registry, live, unknownStatus };
+    return { registry, live: live2, unknownStatus };
   }
-  function lacksOne(entries, live) {
-    const pids = new Set(live.map((entry) => entry.pid));
-    const sessionIds = new Set(live.map((entry) => entry.sessionId));
+  function lacksOne(entries, live2) {
+    const pids = new Set(live2.map((entry) => entry.pid));
+    const sessionIds = new Set(live2.map((entry) => entry.sessionId));
     return entries.some(
       (entry) => entry.pid !== void 0 && !pids.has(entry.pid) && !(entry.sessionId !== void 0 && sessionIds.has(entry.sessionId)) && isAlive(entry.pid)
     );
@@ -3262,10 +3773,10 @@ function createClaudeCodeAdapter(options = {}) {
     const read = lastRead;
     const answer = read?.feed.ok ? read.feed.entries : null;
     const problem = problemWith(reading, read);
-    const { registry, live } = reading;
+    const { registry, live: live2 } = reading;
     const offered = (result) => {
       if (!stops) return result;
-      const found = withStopOffers(result.sessions, live, answer, {
+      const found = withStopOffers(result.sessions, live2, answer, {
         sessionsDir,
         background: !neverRun
       });
@@ -3273,7 +3784,7 @@ function createClaudeCodeAdapter(options = {}) {
       return { ...result, sessions: found.sessions };
     };
     if (options.panes || options.terminals) {
-      const pids = new Set(live.map((entry) => entry.pid));
+      const pids = new Set(live2.map((entry) => entry.pid));
       for (const entry of answer ?? []) {
         if (entry.pid !== void 0 && isAlive(entry.pid)) pids.add(entry.pid);
       }
@@ -3298,11 +3809,11 @@ function createClaudeCodeAdapter(options = {}) {
       const listedPids = new Set(answer.map((entry) => entry.pid));
       const listedSessionIds = new Set(answer.map((entry) => entry.sessionId));
       const tooNewSince = read.askedAt - NEW_SESSION_GRACE_MS;
-      const fromRegistry = live.filter(
+      const fromRegistry = live2.filter(
         (entry) => listedPids.has(entry.pid) || listedSessionIds.has(entry.sessionId) || startedAfter(entry, tooNewSince, checkedAt)
       );
-      const livePids = new Set(live.map((entry) => entry.pid));
-      const liveSessionIds = new Set(live.map((entry) => entry.sessionId));
+      const livePids = new Set(live2.map((entry) => entry.pid));
+      const liveSessionIds = new Set(live2.map((entry) => entry.sessionId));
       const jobs = answer.filter(
         (entry) => (entry.id !== void 0 || entry.state !== void 0) && !(entry.pid !== void 0 && livePids.has(entry.pid)) && !(entry.sessionId !== void 0 && liveSessionIds.has(entry.sessionId))
       ).map((entry) => {
@@ -3350,7 +3861,7 @@ function createClaudeCodeAdapter(options = {}) {
     const withheld = feedWithheld && !feedOff;
     const whyNoAnswer = feedOff ? offNote : withheld ? `${CLAUDE_HOME_ENV} is set, so the claude command is not run` : read !== null && !read.feed.ok ? read.feed.problem : COULD_NOT_RUN;
     if (registry.readable) {
-      const sessions = uniqueById(live.map((entry) => sessionFromRegistry(entry, context)));
+      const sessions = uniqueById(live2.map((entry) => sessionFromRegistry(entry, context)));
       let detail2;
       if (problem === "unknown-status") {
         detail2 = `${whyNoAnswer}, and ${oddStatus}. Sessions are read from the registry alone, and that status is shown as unknown.`;
@@ -3671,7 +4182,7 @@ function createStopRoute(options) {
 // src/collector/actions/cleanUpRoute.ts
 var MAX_CLEAN_UP_BODY_BYTES = 8 * 1024;
 var MAX_SESSION_ID_LENGTH2 = 300;
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactly(value, keys) {
@@ -3685,14 +4196,14 @@ function cleanUpEntriesIn(body) {
   } catch {
     return null;
   }
-  if (!isRecord3(value) || !hasExactly(value, ["sessions"])) return null;
+  if (!isRecord4(value) || !hasExactly(value, ["sessions"])) return null;
   const { sessions } = value;
   if (!Array.isArray(sessions)) return null;
   if (sessions.length === 0 || sessions.length > MAX_CLEAN_UP_SESSIONS) return null;
   const entries = [];
   const seen = /* @__PURE__ */ new Set();
   for (const item of sessions) {
-    if (!isRecord3(item) || !hasExactly(item, ["sessionId", "statusSince"])) return null;
+    if (!isRecord4(item) || !hasExactly(item, ["sessionId", "statusSince"])) return null;
     const { sessionId, statusSince } = item;
     if (typeof sessionId !== "string" || sessionId === "") return null;
     if (sessionId.length > MAX_SESSION_ID_LENGTH2 || seen.has(sessionId)) return null;
@@ -3704,12 +4215,12 @@ function cleanUpEntriesIn(body) {
   }
   return entries;
 }
-function changedSince(entry, registry, listed, stopper) {
+function changedSince(entry, registry, listed, stopper, staleAfterMs2 = STALE_THRESHOLD_MS) {
   if (mapClaudeCodeStatus(registry, "registry").status !== "idle") return "became-active";
   if (registry.statusUpdatedAt !== entry.statusSince) return "became-active";
   if (listed.status !== "idle" || listed.statusSince !== entry.statusSince) return "became-active";
   if (listed.stale !== true) return "not-stale";
-  if (!isStale({ status: "idle", statusSince: entry.statusSince }, stopper.now())) {
+  if (!isStale({ status: "idle", statusSince: entry.statusSince }, stopper.now(), staleAfterMs2)) {
     return "not-stale";
   }
   return null;
@@ -3736,7 +4247,13 @@ function createCleanUpRoute(options) {
         outcomes[index] = confirmed.reason;
         continue;
       }
-      const changed = changedSince(entry, confirmed.entry, session, stopper);
+      const changed = changedSince(
+        entry,
+        confirmed.entry,
+        session,
+        stopper,
+        options.staleAfterMs?.() ?? STALE_THRESHOLD_MS
+      );
       if (changed !== null) {
         outcomes[index] = changed;
         continue;
@@ -3797,69 +4314,845 @@ function createCleanUpRoute(options) {
   };
 }
 
-// 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;
+// src/collector/answers/answerRoute.ts
+var MAX_ANSWER_BODY_BYTES = 1024;
+var ANSWERS2 = {
+  "no-ask": {
+    status: 404,
+    error: "Agent Lookout holds no such request of that session. It may have been answered."
+  },
+  "not-allowable": {
+    status: 409,
+    error: "Only Deny is offered for this request. Answer it in the session to allow it."
+  },
+  gone: {
+    status: 409,
+    error: "The session has moved on: it was answered there, or it is no longer waiting."
+  },
+  "too-soon": { status: 429, error: "That request is being answered." },
+  failed: { status: 500, error: "The answer could not be handed to the session." }
+};
+function answerFailed(reason) {
+  const { status, error } = ANSWERS2[reason];
+  return { status, body: { error, reason } };
 }
-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 });
+var REQUEST_ID = /^[0-9a-f]{32}$/;
+function answerIn(text4) {
+  let value;
+  try {
+    value = JSON.parse(text4);
+  } catch {
+    return null;
   }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value;
+  const keys = Object.keys(record).sort();
+  if (keys.join() !== "decision,requestId,sessionId") return null;
+  const { sessionId, requestId, decision } = record;
+  if (typeof sessionId !== "string" || sessionId === "" || sessionId.length > 200) return null;
+  if (typeof requestId !== "string" || !REQUEST_ID.test(requestId)) return null;
+  if (!ANSWER_DECISIONS.includes(decision)) return null;
+  return { sessionId, requestId, decision };
+}
+function answeredEvent(session, decision, at) {
+  return {
+    id: `${session.id}@${at}:answered`,
+    at,
+    sessionId: session.id,
+    sessionName: session.name,
+    kind: "answered",
+    from: session.status,
+    severity: "advisory",
+    by: "agent-lookout",
+    decision
+  };
 }
-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 answerRefusalFor(req) {
+  return actionRefusalFor(req, ANSWER_ACTION, MAX_ANSWER_BODY_BYTES);
 }
-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;
+function createAnswerRoute(options) {
+  const { poller, events, asks } = options;
+  const now = options.now ?? Date.now;
+  return async function answerPermission(req) {
+    const refused = answerRefusalFor(req);
+    if (refused) {
+      req.resume();
+      return refused;
+    }
+    const body = await readRequestBody(req, MAX_ANSWER_BODY_BYTES);
+    if (!body.ok) {
+      req.resume();
+      return body.tooLarge ? refusal(413, `The body must be no more than ${MAX_ANSWER_BODY_BYTES} bytes.`) : refusal(400, "The body could not be read.");
+    }
+    const asked = answerIn(body.text);
+    if (asked === null) {
+      return refusal(
+        400,
+        'The body must be {"sessionId": "...", "requestId": "...", "decision": "allow" or "deny"} and nothing else.'
+      );
+    }
+    const session = poller.getSnapshot().sessions.find((listed) => listed.id === asked.sessionId);
+    if (!session) return answerFailed("no-ask");
+    const outcome = await asks.answer(asked.sessionId, asked.requestId, asked.decision);
+    if (outcome !== "answered") return answerFailed(outcome);
+    events.add([answeredEvent(session, asked.decision, now())]);
+    void poller.pollOnce().catch(() => {
+    });
+    return {
+      status: 200,
+      body: { ok: true, decision: asked.decision }
+    };
+  };
+}
+
+// src/collector/answers/answerSettings.ts
+import os3 from "node:os";
+import path10 from "node:path";
+var ANSWER_ENV = "AGENT_LOOKOUT_ANSWER";
+var ANSWER_SOCKET_ENV = "AGENT_LOOKOUT_ANSWER_SOCKET";
+var ANSWER_WAIT_ENV = "AGENT_LOOKOUT_ANSWER_WAIT";
+var DEFAULT_HOLD_MS = 3e5;
+var MIN_HOLD_MS = 5e3;
+var MAX_HOLD_MS = 54e4;
+var MAX_SOCKET_PATH_BYTES = 103;
+function answerOff(env) {
+  return env[ANSWER_ENV]?.trim().toLowerCase() === "off";
+}
+function holdMsFrom(value) {
+  const text4 = value?.trim();
+  if (text4 === void 0 || text4 === "") return DEFAULT_HOLD_MS;
+  if (!/^\d{1,4}$/.test(text4)) return null;
+  const ms = Number(text4) * 1e3;
+  return ms < MIN_HOLD_MS || ms > MAX_HOLD_MS ? null : ms;
+}
+function readAnswerSetup(env, homeDir = os3.homedir(), platform = process.platform) {
+  const holdMs = holdMsFrom(env[ANSWER_WAIT_ENV]);
+  if (answerOff(env)) {
+    return { on: false, socketPath: null, holdMs: holdMs ?? DEFAULT_HOLD_MS, problem: null };
+  }
+  if (platform === "win32") {
+    return {
+      on: false,
+      socketPath: null,
+      holdMs: holdMs ?? DEFAULT_HOLD_MS,
+      problem: "Answering permission prompts is not offered on Windows."
+    };
   }
-  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);
+  if (holdMs === null) {
+    return {
+      on: false,
+      socketPath: null,
+      holdMs: DEFAULT_HOLD_MS,
+      problem: `${ANSWER_WAIT_ENV} must be a number of seconds from ${MIN_HOLD_MS / 1e3} to ${MAX_HOLD_MS / 1e3}, so answering is off.`
+    };
   }
-  return sum;
+  const named = env[ANSWER_SOCKET_ENV]?.trim();
+  if (!named && env[CLAUDE_HOME_ENV]?.trim()) {
+    return {
+      on: false,
+      socketPath: null,
+      holdMs,
+      problem: `${CLAUDE_HOME_ENV} is set, so permission prompts are not answered. Set ${ANSWER_SOCKET_ENV} as well to answer them.`,
+      quiet: true
+    };
+  }
+  const ownDir = path10.resolve(homeDir, ".agent-lookout");
+  const socketPath = path10.resolve(named || path10.join(ownDir, "answer.sock"));
+  if (Buffer.byteLength(socketPath) > MAX_SOCKET_PATH_BYTES) {
+    return {
+      on: false,
+      socketPath: null,
+      holdMs,
+      problem: `The path of the answer socket is longer than ${MAX_SOCKET_PATH_BYTES} bytes, which a socket cannot have, so answering is off. Set ${ANSWER_SOCKET_ENV} to a shorter path.`
+    };
+  }
+  return {
+    on: true,
+    socketPath,
+    holdMs,
+    problem: null,
+    ownFolder: path10.dirname(socketPath) === ownDir
+  };
 }
 
-// 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";
+// src/collector/answers/heldAsks.ts
+import { randomBytes } from "node:crypto";
+
+// src/collector/answers/shownAsk.ts
+var MAX_SHOWN_CHARS = 4e3;
+var MAX_SHOWN_LINES = 40;
+var MAX_BLANK_RUN = 2;
+var MAX_INPUTS = 30;
+var MAX_TOOL_NAME_CHARS = 200;
+var MAX_DESCRIPTION_CHARS = 200;
+var EDIT_TOOLS = ["Edit", "Write", "MultiEdit", "NotebookEdit"];
+var NOT_YES_OR_NO_TOOLS = ["ExitPlanMode", "AskUserQuestion"];
+var EDIT_INPUTS = ["file_path", "notebook_path"];
+var HIDDEN = /[\p{Cc}\p{Cf}\p{Co}\p{Cn}\p{Cs}\p{Default_Ignorable_Code_Point}\u2028\u2029]/gu;
+var RIGHT_TO_LEFT = /[\p{Script=Hebrew}\p{Script=Arabic}\p{Script=Syriac}\p{Script=Thaana}\p{Script=Nko}\p{Script=Samaritan}\p{Script=Mandaic}\p{Script=Adlam}\p{Script=Hanifi_Rohingya}\p{Script=Mende_Kikakui}\p{Script=Old_Hungarian}\p{Script=Kharoshthi}\p{Script=Phoenician}\p{Script=Imperial_Aramaic}\p{Script=Avestan}\p{Script=Old_South_Arabian}\p{Script=Old_North_Arabian}\p{Script=Nabataean}\p{Script=Palmyrene}\p{Script=Manichaean}\p{Script=Inscriptional_Pahlavi}\p{Script=Inscriptional_Parthian}\p{Script=Psalter_Pahlavi}\p{Script=Sogdian}\p{Script=Old_Sogdian}\p{Script=Elymaic}\p{Script=Lydian}\p{Script=Cypriot}]/u;
+var BLANK_RUN = new RegExp(`\\n(?:[ \\t]*\\n){${MAX_BLANK_RUN + 1},}`);
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function unendedWaits(events) {
-  const newest2 = /* @__PURE__ */ new Map();
+function visible(text4) {
+  let hidden = false;
+  const shown = text4.replace(HIDDEN, (character) => {
+    if (character === "\n" || character === "	") return character;
+    hidden = true;
+    return `\\u{${(character.codePointAt(0) ?? 0).toString(16)}}`;
+  });
+  return { text: shown, hidden };
+}
+function valueText(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0) return "undefined";
+  return JSON.stringify(value, null, 2) ?? String(value);
+}
+function budget() {
+  let left = MAX_SHOWN_CHARS;
+  let lines = 0;
+  let cut2 = false;
+  let hidden = false;
+  let blankRun = false;
+  return {
+    /** Takes a text to show. A name, drawn on a line of its own beside its value, adds no lines. */
+    take(text4, kind = "value") {
+      const seen = visible(text4);
+      if (seen.hidden) hidden = true;
+      if (BLANK_RUN.test(`
+${seen.text}
+`)) blankRun = true;
+      if (kind === "value") lines += seen.text.split("\n").length;
+      if (lines > MAX_SHOWN_LINES) cut2 = true;
+      const characters = Array.from(seen.text);
+      if (characters.length <= left) {
+        left -= characters.length;
+        return seen.text;
+      }
+      cut2 = true;
+      const kept = characters.slice(0, Math.max(0, left)).join("");
+      left = 0;
+      return `${kept}\u2026`;
+    },
+    markCut() {
+      cut2 = true;
+    },
+    get cut() {
+      return cut2;
+    },
+    get hidden() {
+      return hidden;
+    },
+    get blankRun() {
+      return blankRun;
+    }
+  };
+}
+function inputsOf(input, keys, shown) {
+  const listed = keys.slice(0, MAX_INPUTS);
+  if (keys.length > MAX_INPUTS) shown.markCut();
+  return listed.map((key) => ({
+    name: shown.take(key, "name"),
+    value: shown.take(valueText(input[key]))
+  }));
+}
+function shownAsk(toolName, toolInput, agentId) {
+  if (typeof toolName !== "string") return null;
+  const tool = toolName.trim();
+  if (tool === "" || Array.from(tool).length > MAX_TOOL_NAME_CHARS) return null;
+  if (visible(tool).hidden || /\s/.test(tool)) return null;
+  const input = toolInput === void 0 ? {} : toolInput;
+  if (!isRecord5(input)) return null;
+  const shown = budget();
+  const subagent = typeof agentId === "string" && agentId !== "" ? { subagent: true } : {};
+  let denyOnly;
+  let rightToLeft = false;
+  let ask;
+  if (EDIT_TOOLS.includes(tool)) {
+    const keys = EDIT_INPUTS.filter((key) => input[key] !== void 0);
+    ask = { tool, inputs: inputsOf(input, keys, shown), allow: false };
+    denyOnly = "edit";
+  } else if (tool === "Bash" && typeof input.command === "string" && input.command.trim() !== "") {
+    const command = shown.take(input.command);
+    rightToLeft = RIGHT_TO_LEFT.test(input.command);
+    const description = typeof input.description === "string" ? oneLine(input.description, MAX_DESCRIPTION_CHARS) || void 0 : void 0;
+    const rest = Object.keys(input).filter((key) => key !== "command" && key !== "description");
+    const inputs = inputsOf(input, rest, shown);
+    ask = {
+      tool,
+      command,
+      ...description !== void 0 && { description },
+      ...inputs.length > 0 && { inputs },
+      allow: false
+    };
+  } else {
+    ask = { tool, inputs: inputsOf(input, Object.keys(input), shown), allow: false };
+    if (NOT_YES_OR_NO_TOOLS.includes(tool)) denyOnly = "not-yes-or-no";
+  }
+  denyOnly ??= shown.hidden ? "hidden-characters" : rightToLeft ? "right-to-left" : shown.blankRun ? "blank-lines" : shown.cut ? "too-long" : void 0;
+  return denyOnly === void 0 ? { ...ask, allow: true, ...subagent } : { ...ask, allow: false, denyOnly, ...subagent };
+}
+
+// src/collector/answers/heldAsks.ts
+var ALLOW_OUTPUT = JSON.stringify({
+  hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "allow" } }
+});
+var DENY_MESSAGE = "The person denied this from Agent Lookout. It was their choice, not a problem with a hook or a setting, so do not look for one. Do not try it again unless they ask.";
+var DENY_OUTPUT = JSON.stringify({
+  hookSpecificOutput: {
+    hookEventName: "PermissionRequest",
+    decision: { behavior: "deny", message: DENY_MESSAGE }
+  }
+});
+function decisionOutput(decision) {
+  return decision === "allow" ? ALLOW_OUTPUT : DENY_OUTPUT;
+}
+var CHECK_EVERY_MS = 500;
+var GRACE_MS = 3e3;
+var MAX_HELD = 32;
+var MISSED_AFTER_MS = 5e3;
+var REMEMBER_REQUEST_MS = 6e4;
+var SOURCE = "claude-code";
+var SESSION_ID2 = /^[A-Za-z0-9][A-Za-z0-9-]{0,99}$/;
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readHookRequest(body) {
+  let value;
+  try {
+    value = JSON.parse(body);
+  } catch {
+    return null;
+  }
+  if (!isRecord6(value) || value.hook_event_name !== "PermissionRequest") return null;
+  const id = value.session_id;
+  if (typeof id !== "string" || !SESSION_ID2.test(id)) return null;
+  const shown = shownAsk(value.tool_name, value.tool_input, value.agent_id);
+  return shown === null ? null : { sessionId: `${SOURCE}:${id}`, shown };
+}
+var realEvery = (run, ms) => {
+  const timer = setInterval(run, ms);
+  timer.unref?.();
+  return () => clearInterval(timer);
+};
+function createHeldAsks(options) {
+  const { status: reader, holdMs } = options;
+  const now = options.now ?? Date.now;
+  const every2 = options.every ?? realEvery;
+  const newId = options.newId ?? (() => randomBytes(16).toString("hex"));
+  const startedAt = now();
+  const held = /* @__PURE__ */ new Map();
+  const lastRequest = /* @__PURE__ */ new Map();
+  let seenAt = null;
+  let missedAt = null;
+  let stopTimer = null;
+  let inFlight = null;
+  function drop(entry, reason) {
+    if (held.get(entry.sessionId) === entry) held.delete(entry.sessionId);
+    if (entry.reply.isOpen()) entry.reply.send("");
+    options.onDrop?.(reason, entry.sessionId);
+    if (held.size === 0 && stopTimer !== null) {
+      stopTimer();
+      stopTimer = null;
+    }
+  }
+  async function read(sessionId) {
+    try {
+      return await reader.statusOf(sessionId);
+    } catch {
+      return { status: "unknown" };
+    }
+  }
+  async function checkOne(entry, at) {
+    if (entry.answering) return;
+    if (!entry.reply.isOpen()) return drop(entry, "closed");
+    if (at >= entry.until) return drop(entry, "limit");
+    const reading = await read(entry.sessionId);
+    if (held.get(entry.sessionId) !== entry || entry.answering) return;
+    if (reading.status === "waiting") {
+      if (!entry.confirmed) {
+        entry.confirmed = true;
+        entry.wait = reading.wait;
+        return;
+      }
+      if (reading.wait !== entry.wait) drop(entry, "left-waiting");
+      return;
+    }
+    if (entry.confirmed || at - entry.arrivedAt >= GRACE_MS) drop(entry, "left-waiting");
+  }
+  async function check() {
+    while (inFlight !== null) await inFlight;
+    const at = now();
+    const run = Promise.all([...held.values()].map((entry) => checkOne(entry, at))).then(() => {
+    });
+    inFlight = run;
+    try {
+      await run;
+    } finally {
+      if (inFlight === run) inFlight = null;
+    }
+  }
+  function status() {
+    const plugin = seenAt !== null && (missedAt === null || seenAt > missedAt) ? "seen" : missedAt !== null ? "missed" : "unknown";
+    return { state: "on", plugin, holdMs };
+  }
+  function toAsk(entry) {
+    return { requestId: entry.requestId, ...entry.shown, until: entry.until };
+  }
+  return {
+    receive(request2, reply) {
+      const at = now();
+      const older = held.get(request2.sessionId);
+      if (older) drop(older, "newer");
+      const entry = {
+        requestId: newId(),
+        sessionId: request2.sessionId,
+        shown: request2.shown,
+        arrivedAt: at,
+        until: at + holdMs,
+        reply,
+        confirmed: false,
+        wait: null,
+        answering: false
+      };
+      if (held.size >= MAX_HELD) {
+        drop(entry, "full");
+        return;
+      }
+      held.set(request2.sessionId, entry);
+      reply.onClose(() => {
+        if (held.get(entry.sessionId) === entry && !entry.answering) drop(entry, "closed");
+      });
+      stopTimer ??= every2(() => {
+        if (inFlight === null) void check();
+      }, CHECK_EVERY_MS);
+      void check();
+    },
+    check,
+    async answer(sessionId, requestId, decision) {
+      const entry = held.get(sessionId);
+      if (!entry || entry.requestId !== requestId || !entry.confirmed) return "no-ask";
+      if (decision === "allow" && !entry.shown.allow) return "not-allowable";
+      if (entry.answering) return "too-soon";
+      entry.answering = true;
+      const reading = await read(sessionId);
+      if (held.get(sessionId) !== entry || !entry.reply.isOpen()) {
+        if (held.get(sessionId) === entry) drop(entry, "closed");
+        return "gone";
+      }
+      const sameWait = reading.status === "waiting" && reading.wait === entry.wait;
+      if (!sameWait || now() >= entry.until) {
+        drop(entry, sameWait ? "limit" : "left-waiting");
+        return "gone";
+      }
+      held.delete(sessionId);
+      entry.reply.send(decisionOutput(decision));
+      if (held.size === 0 && stopTimer !== null) {
+        stopTimer();
+        stopTimer = null;
+      }
+      return "answered";
+    },
+    withAsks(snapshot) {
+      const answering = status();
+      if (held.size === 0) return { ...snapshot, answering };
+      const sessions = snapshot.sessions.map((session) => {
+        const entry = held.get(session.id);
+        if (!entry || !entry.confirmed || entry.answering || session.status !== "needs-you") {
+          return session;
+        }
+        return { ...session, ask: toAsk(entry) };
+      });
+      return { ...snapshot, sessions, answering };
+    },
+    noteRequest(sessionId) {
+      const at = now();
+      seenAt = at;
+      if (sessionId !== null) lastRequest.set(sessionId, at);
+    },
+    observe(snapshot) {
+      const at = snapshot.generatedAt;
+      const waitingIds = /* @__PURE__ */ new Set();
+      for (const session of snapshot.sessions) {
+        if (session.source !== SOURCE || session.status !== "needs-you") continue;
+        if (session.waitingReason !== "permission" || session.alive === false) continue;
+        waitingIds.add(session.id);
+        const since = session.statusSince;
+        if (since === null || since < startedAt + 1e3) continue;
+        if (at - since < MISSED_AFTER_MS) continue;
+        const last = lastRequest.get(session.id);
+        if (last !== void 0 && last >= since - MISSED_AFTER_MS) continue;
+        if (missedAt === null || since > missedAt) missedAt = since;
+      }
+      for (const [id, last] of lastRequest) {
+        if (!waitingIds.has(id) && !held.has(id) && at - last > REMEMBER_REQUEST_MS) {
+          lastRequest.delete(id);
+        }
+      }
+    },
+    status,
+    dropAll() {
+      for (const entry of [...held.values()]) drop(entry, "stopped");
+    },
+    get size() {
+      return held.size;
+    }
+  };
+}
+
+// src/collector/answers/hookSocket.ts
+import { chmod, lstat as lstat2, mkdir, stat as stat4, unlink } from "node:fs/promises";
+import http from "node:http";
+import net from "node:net";
+import path11 from "node:path";
+var HOOK_PATH = "/hooks/permission-request";
+var HOOK_HEADER = "x-agent-lookout-hook";
+var HOOK_HEADER_VALUE = "permission-request";
+var MAX_HOOK_BODY_BYTES = 1024 * 1024;
+var HOOK_BODY_TIMEOUT_MS = 1e4;
+var MAX_CONNECTIONS = 64;
+function errorCode2(error) {
+  return error?.code;
+}
+function answers(socketPath) {
+  return new Promise((resolve) => {
+    const client = net.connect(socketPath);
+    const done = (result) => {
+      client.destroy();
+      resolve(result);
+    };
+    client.setTimeout(1e3, () => done(true));
+    client.once("connect", () => done(true));
+    client.once("error", () => done(false));
+  });
+}
+function sendNothing(res) {
+  if (res.headersSent) {
+    res.end();
+    return;
+  }
+  res.writeHead(200, { "Content-Length": 0, Connection: "close" });
+  res.end();
+}
+function header2(req, name) {
+  const value = req.headers[name];
+  return typeof value === "string" ? value : void 0;
+}
+function isHookRequest(req) {
+  if (req.method !== "POST" || req.url !== HOOK_PATH) return false;
+  if (req.headers.origin !== void 0) return false;
+  if (header2(req, HOOK_HEADER) !== HOOK_HEADER_VALUE) return false;
+  const type = header2(req, "content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+  return type === "application/json";
+}
+function replyTo(res) {
+  let closed = false;
+  res.once("close", () => {
+    closed = true;
+  });
+  return {
+    send(body) {
+      if (closed || res.writableEnded) return;
+      if (body === "") {
+        sendNothing(res);
+        return;
+      }
+      res.writeHead(200, {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(body),
+        Connection: "close"
+      });
+      res.end(body);
+    },
+    isOpen: () => !closed && !res.writableEnded && !res.destroyed,
+    onClose(listener) {
+      res.once("close", () => {
+        if (!res.writableFinished) listener();
+      });
+    }
+  };
+}
+function createHookSocket(options) {
+  const { socketPath, asks } = options;
+  const maxBody = options.maxBodyBytes ?? MAX_HOOK_BODY_BYTES;
+  const bodyTimeoutMs = options.bodyTimeoutMs ?? HOOK_BODY_TIMEOUT_MS;
+  const uid = options.uid ?? process.getuid?.() ?? -1;
+  const folder = path11.dirname(socketPath);
+  let server = null;
+  let made = null;
+  async function handle(req, res) {
+    if (!isHookRequest(req)) {
+      req.resume();
+      sendNothing(res);
+      return;
+    }
+    const length = header2(req, "content-length");
+    if (length !== void 0 && (!/^\d+$/.test(length) || Number(length) > maxBody)) {
+      req.resume();
+      sendNothing(res);
+      return;
+    }
+    const timer = setTimeout(() => req.destroy(), bodyTimeoutMs);
+    const body = await readRequestBody(req, maxBody);
+    clearTimeout(timer);
+    if (!body.ok) {
+      req.resume();
+      sendNothing(res);
+      return;
+    }
+    const request2 = readHookRequest(body.text);
+    asks.noteRequest(request2?.sessionId ?? null);
+    if (request2 === null) {
+      sendNothing(res);
+      return;
+    }
+    asks.receive(request2, replyTo(res));
+  }
+  async function readyFolder() {
+    try {
+      const madeHere = await mkdir(folder, { recursive: true, mode: 448 });
+      const info = await lstat2(folder);
+      if (!info.isDirectory()) return `${folder} is not a folder, so answering is off.`;
+      if (uid >= 0 && info.uid !== uid) {
+        return `${folder} belongs to another user, so answering is off.`;
+      }
+      if ((info.mode & 63) !== 0) {
+        if (madeHere === void 0 && !options.ownFolder) {
+          return `Other users can open ${folder}, so answering is off. Name a socket in a folder only you can open.`;
+        }
+        await chmod(folder, 448);
+      }
+      return null;
+    } catch {
+      return `The folder ${folder} could not be made ready, so answering is off.`;
+    }
+  }
+  async function freePath() {
+    let info;
+    try {
+      info = await lstat2(socketPath);
+    } catch (error) {
+      return errorCode2(error) === "ENOENT" ? null : `${socketPath} could not be read.`;
+    }
+    if (!info.isSocket())
+      return `Something other than a socket is at ${socketPath}, so answering is off.`;
+    if (await answers(socketPath)) {
+      return "Another copy of Agent Lookout answers permission prompts on this computer.";
+    }
+    try {
+      await unlink(socketPath);
+      return null;
+    } catch {
+      return `The leftover socket at ${socketPath} could not be removed, so answering is off.`;
+    }
+  }
+  return {
+    async start() {
+      if (server !== null) return { ok: true };
+      const problem = await readyFolder() ?? await freePath();
+      if (problem !== null) return { ok: false, problem };
+      const listening = http.createServer(
+        { requestTimeout: 0, headersTimeout: bodyTimeoutMs, keepAliveTimeout: 1e3 },
+        (req, res) => {
+          handle(req, res).catch(() => sendNothing(res));
+        }
+      );
+      listening.maxConnections = MAX_CONNECTIONS;
+      const listened = await new Promise((resolve) => {
+        listening.once(
+          "error",
+          (error) => resolve(
+            errorCode2(error) === "EADDRINUSE" ? "Another copy of Agent Lookout answers permission prompts on this computer." : `Agent Lookout could not listen at ${socketPath}, so answering is off.`
+          )
+        );
+        listening.listen(socketPath, () => resolve(null));
+      });
+      if (listened !== null) return { ok: false, problem: listened };
+      listening.on("error", () => {
+      });
+      try {
+        await chmod(socketPath, 384);
+        made = (await stat4(socketPath)).ino;
+      } catch {
+        listening.close();
+        return { ok: false, problem: `The socket at ${socketPath} could not be made private.` };
+      }
+      server = listening;
+      return { ok: true };
+    },
+    async close() {
+      asks.dropAll();
+      const closing = server;
+      server = null;
+      if (closing === null) return;
+      await new Promise((resolve) => {
+        closing.close(() => resolve());
+        closing.closeAllConnections();
+      });
+      try {
+        if (made !== null && (await stat4(socketPath)).ino === made) await unlink(socketPath);
+      } catch {
+      }
+      made = null;
+    }
+  };
+}
+
+// src/collector/answers/registryStatus.ts
+import os4 from "node:os";
+import path12 from "node:path";
+function createRegistryStatus(options) {
+  const homeDir = options.homeDir ?? os4.homedir();
+  const readFile2 = options.readFile ?? readRegularFile;
+  const home = options.env[CLAUDE_HOME_ENV]?.trim() || path12.join(homeDir, ".claude");
+  const sessionsDir = path12.join(path12.resolve(home), "sessions");
+  return {
+    async statusOf(sessionId) {
+      const unknown = { status: "unknown" };
+      const session = options.snapshot().sessions.find((candidate) => candidate.id === sessionId);
+      if (!session || session.source !== "claude-code" || session.alive === false) return unknown;
+      const pid = session.pid;
+      if (pid === void 0 || !Number.isSafeInteger(pid) || pid <= 1) return unknown;
+      const ownId = sessionId.slice("claude-code:".length);
+      let content;
+      try {
+        content = await readFile2(path12.join(sessionsDir, `${pid}.json`));
+      } catch {
+        return unknown;
+      }
+      const entry = parseRegistryEntry(content);
+      if (entry === null || entry.pid !== pid || entry.sessionId !== ownId) return unknown;
+      const forPermission = entry.status === "waiting" && mapClaudeCodeWaitingFor(entry.waitingFor).waitingReason === "permission";
+      if (!forPermission) return { status: "not-waiting" };
+      return {
+        status: "waiting",
+        wait: `${entry.statusUpdatedAt ?? ""}|${entry.waitingFor ?? ""}`
+      };
+    }
+  };
+}
+
+// src/collector/answers/answering.ts
+function createAnswering(options) {
+  const { env, poller, events } = options;
+  const setup = readAnswerSetup(env, options.homeDir, options.platform);
+  if (!setup.on) {
+    if (setup.problem !== null && !setup.quiet) options.warn?.(setup.problem);
+    const off = setup.problem === null ? { state: "off", plugin: "unknown", holdMs: setup.holdMs } : { state: "unavailable", plugin: "unknown", problem: setup.problem, holdMs: setup.holdMs };
+    return {
+      start: async () => {
+      },
+      stop: async () => {
+      },
+      serve: (snapshot) => ({ ...snapshot, answering: off }),
+      observe: () => {
+      }
+    };
+  }
+  const asks = createHeldAsks({
+    status: options.status ?? createRegistryStatus({ snapshot: poller.getSnapshot, env }),
+    holdMs: setup.holdMs,
+    now: options.now,
+    every: options.every
+  });
+  const socket = createHookSocket({
+    socketPath: setup.socketPath,
+    asks,
+    ownFolder: setup.ownFolder
+  });
+  let problem = null;
+  let listening = false;
+  return {
+    async start() {
+      const started = await socket.start();
+      listening = started.ok;
+      problem = started.ok ? null : started.problem;
+      if (problem !== null) options.warn?.(problem);
+    },
+    async stop() {
+      listening = false;
+      await socket.close();
+    },
+    serve(snapshot) {
+      if (problem !== null) {
+        return {
+          ...snapshot,
+          answering: { state: "unavailable", plugin: "unknown", holdMs: setup.holdMs, problem }
+        };
+      }
+      return asks.withAsks(snapshot);
+    },
+    observe(snapshot) {
+      if (listening) asks.observe(snapshot);
+    },
+    route: createAnswerRoute({ poller, events, asks, now: options.now })
+  };
+}
+
+// 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) {
+  if (!isStatusEvent(event)) return false;
+  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);
@@ -4020,14 +5313,14 @@ function waitTotals(input) {
 }
 
 // src/collector/adapters/codex/index.ts
-import os3 from "node:os";
-import path11 from "node:path";
+import os5 from "node:os";
+import path14 from "node:path";
 
 // src/core/mapping/codexMapping.ts
 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;
+  const { lastTurn, live: live2 } = fields;
   let open4;
   if (lastTurn === null) {
     open4 = "idle";
@@ -4040,7 +5333,7 @@ function mapCodexStatus(fields) {
   } else {
     return "unknown";
   }
-  return live === false ? "finished" : open4;
+  return live2 === 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})?$/;
@@ -4064,7 +5357,7 @@ var IMPORTED_TURN_ID = /^external-import-turn-\d{1,9}$/;
 function isImportedCodexTurn(turnId) {
   return typeof turnId === "string" && IMPORTED_TURN_ID.test(turnId);
 }
-function isRecord4(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var CODEX_DESKTOP_ORIGINATOR = "Codex Desktop";
@@ -4072,7 +5365,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 (isRecord4(source) && source.custom === "chatgpt") return "desktop";
+  if (isRecord7(source) && source.custom === "chatgpt") return "desktop";
   return "unknown";
 }
 var NOT_A_SESSION_SOURCE = /* @__PURE__ */ new Set(["subagent", "internal", "mcp"]);
@@ -4083,7 +5376,7 @@ function isCodexSessionSource(source, meta = {}) {
     return false;
   }
   if (typeof source === "string") return !NOT_A_SESSION_SOURCE.has(source);
-  if (isRecord4(source)) return !Object.keys(source).some((kind) => NOT_A_SESSION_SOURCE.has(kind));
+  if (isRecord7(source)) return !Object.keys(source).some((kind) => NOT_A_SESSION_SOURCE.has(kind));
   return true;
 }
 
@@ -4102,7 +5395,7 @@ function parseCodexTime(value) {
 var LINE_TIME = /^\{"timestamp":"([^"]{1,64})"/;
 var TURN_HINT = /"type":"(?:task|turn)_/;
 var TURN_TYPE = /^(?:task|turn)_/;
-function isRecord5(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function text3(value) {
@@ -4113,7 +5406,7 @@ function label(value) {
 }
 function compactSource(value) {
   if (typeof value === "string") return text3(value);
-  if (!isRecord5(value)) return void 0;
+  if (!isRecord8(value)) return void 0;
   return Object.fromEntries(
     Object.entries(value).map(([kind, detail]) => [
       kind,
@@ -4124,7 +5417,7 @@ function compactSource(value) {
 function parse(line) {
   try {
     const value = JSON.parse(line);
-    return isRecord5(value) ? value : null;
+    return isRecord8(value) ? value : null;
   } catch {
     return null;
   }
@@ -4132,7 +5425,7 @@ function parse(line) {
 function readMetaLine(line) {
   if (!line.includes('"session_meta"')) return null;
   const value = parse(line);
-  if (!value || value.type !== "session_meta" || !isRecord5(value.payload)) return null;
+  if (!value || value.type !== "session_meta" || !isRecord8(value.payload)) return null;
   const payload = value.payload;
   const meta = {
     id: text3(payload.id),
@@ -4152,7 +5445,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" || !isRecord5(value.payload)) return null;
+  if (!value || value.type !== "event_msg" || !isRecord8(value.payload)) return null;
   const turn = value.payload.type;
   if (typeof turn !== "string" || !TURN_TYPE.test(turn)) return null;
   return {
@@ -4192,7 +5485,7 @@ async function readHead(file, size) {
 }
 async function scanTail(file, size) {
   let position = size;
-  let budget = TAIL_LIMIT_BYTES;
+  let budget2 = TAIL_LIMIT_BYTES;
   let fragment = Buffer.alloc(0);
   let end = null;
   let lastLineAt = null;
@@ -4209,11 +5502,11 @@ async function scanTail(file, size) {
     lastLineAt,
     end
   });
-  while (position > 0 && budget > 0) {
-    const length = Math.min(TAIL_CHUNK_BYTES, position, budget);
+  while (position > 0 && budget2 > 0) {
+    const length = Math.min(TAIL_CHUNK_BYTES, position, budget2);
     const start = position - length;
     const chunk = await readExactly(file, start, length);
-    budget -= length;
+    budget2 -= length;
     position = start;
     const buffer = fragment.byteLength > 0 ? Buffer.concat([chunk, fragment]) : chunk;
     let cut2 = buffer.byteLength;
@@ -4338,7 +5631,7 @@ function createRolloutReader(io) {
 }
 
 // src/collector/adapters/codex/rollouts.ts
-import path10 from "node:path";
+import path13 from "node:path";
 var UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
 var ROLLOUT_FILE_NAME = new RegExp(
   `^rollout-\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2}-\\d{2}-(${UUID})(?:_(${UUID}))?\\.jsonl$`,
@@ -4356,7 +5649,7 @@ function twoDigits(value) {
 function recentDayFolders(sessionsDir, now) {
   const folders = [now, now - 24 * 60 * 60 * 1e3].map((at) => {
     const date = new Date(at);
-    return path10.join(
+    return path13.join(
       sessionsDir,
       String(date.getFullYear()),
       twoDigits(date.getMonth() + 1),
@@ -4385,12 +5678,12 @@ function createRolloutFinder(options) {
     const refs = [];
     for (const name of (await names(dir)).sort()) {
       const threadId = threadIdOfRollout(name);
-      if (threadId !== null) refs.push({ path: path10.join(dir, name), threadId });
+      if (threadId !== null) refs.push({ path: path13.join(dir, name), threadId });
     }
     return refs;
   }
   async function subfolders(dir, pattern) {
-    return (await names(dir)).filter((name) => pattern.test(name)).sort().map((name) => path10.join(dir, name));
+    return (await names(dir)).filter((name) => pattern.test(name)).sort().map((name) => path13.join(dir, name));
   }
   async function buildIndex() {
     const years = await subfolders(sessionsDir, YEAR);
@@ -4434,7 +5727,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 isRecord6(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseSessionIndex(content) {
@@ -4447,7 +5740,7 @@ function parseSessionIndex(content) {
     } catch {
       continue;
     }
-    if (!isRecord6(value)) continue;
+    if (!isRecord9(value)) continue;
     const { id, thread_name: name } = value;
     if (typeof id !== "string" || id === "" || typeof name !== "string") continue;
     const trimmed = name.trim();
@@ -4504,11 +5797,11 @@ function lastActivity(state, now) {
   return plausibleTime(state.lastLineAt, now) ?? plausibleTime(state.lastTurnAt, now) ?? plausibleTime(parseCodexTime(state.meta?.timestamp), now);
 }
 function codexSession(input) {
-  const { threadId, state, live, now } = input;
+  const { threadId, state, live: live2, now } = input;
   const id = `${SOURCE_ID2}:${threadId}`;
   const cwd = state.meta?.cwd ?? null;
   const project = projectOf(cwd);
-  const status = mapCodexStatus({ lastTurn: state.lastTurn, live });
+  const status = mapCodexStatus({ lastTurn: state.lastTurn, live: live2 });
   const startedAt = plausibleTime(parseCodexTime(state.meta?.timestamp), now);
   let statusSince = null;
   if (status === "working" || status === "idle" && state.lastTurn !== null) {
@@ -4593,11 +5886,15 @@ var CODEX_CAPABILITIES = {
   stop: {
     level: "no",
     reason: "Codex's files name no process that Agent Lookout could confirm and stop."
-  }
+  },
+  answer: {
+    level: "no",
+    reason: "Codex records no approval waits, so there is nothing to answer from here."
+  }
 };
 function createCodexAdapter(options = {}) {
   const env = options.env ?? process.env;
-  const homeDir = options.homeDir ?? os3.homedir();
+  const homeDir = options.homeDir ?? os5.homedir();
   const now = options.now ?? Date.now;
   const io = options.io ?? nodeIo2;
   const pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS;
@@ -4605,10 +5902,10 @@ function createCodexAdapter(options = {}) {
   const ownOverride = env[CODEX_HOME_ENV]?.trim() || void 0;
   const codexOverride = env[CODEX_OWN_HOME_ENV]?.trim() || void 0;
   const homeFrom = ownOverride ? "agent-lookout" : codexOverride ? "codex" : "default";
-  const codexHome = path11.resolve(ownOverride ?? codexOverride ?? path11.join(homeDir, ".codex"));
-  const sessionsDir = path11.join(codexHome, "sessions");
-  const locksDir = path11.join(codexHome, WRITER_LOCK_DIR);
-  const indexFile = path11.join(codexHome, SESSION_INDEX_FILE);
+  const codexHome = path14.resolve(ownOverride ?? codexOverride ?? path14.join(homeDir, ".codex"));
+  const sessionsDir = path14.join(codexHome, "sessions");
+  const locksDir = path14.join(codexHome, WRITER_LOCK_DIR);
+  const indexFile = path14.join(codexHome, SESSION_INDEX_FILE);
   const homeName = tildify(codexHome, homeDir);
   const sessionsName = tildify(sessionsDir, homeDir);
   const locksName = tildify(locksDir, homeDir);
@@ -4769,17 +6066,17 @@ function createCodexAdapter(options = {}) {
     reader.keepOnly(read);
     let olderCodex = false;
     const sessions = [...chosen.entries()].map(([threadId, { state, writtenAt }]) => {
-      const live = codexLiveness({
+      const live2 = codexLiveness({
         lockFolder: locks.supported,
         locked: locked(threadId),
         cliVersion: state.meta?.cliVersion
       });
-      if (locks.supported && live === "unknown") olderCodex = true;
+      if (locks.supported && live2 === "unknown") olderCodex = true;
       return codexSession({
         threadId,
         state,
         name: names.get(threadId),
-        live,
+        live: live2,
         writtenAt: Math.max(writtenAt, subagentWrites.get(threadId) ?? -Infinity),
         now: checkedAt
       });
@@ -4815,8 +6112,8 @@ function createCodexAdapter(options = {}) {
 }
 
 // src/collector/adapters/status-files/index.ts
-import os4 from "node:os";
-import path12 from "node:path";
+import os6 from "node:os";
+import path15 from "node:path";
 
 // src/core/mapping/statusFileMapping.ts
 var STATUS = /* @__PURE__ */ new Map([
@@ -4948,6 +6245,10 @@ var STATUS_FILE_CAPABILITIES = {
   stop: {
     level: "no",
     reason: "Any program can write a status file, so nothing in one is used to stop a session."
+  },
+  answer: {
+    level: "no",
+    reason: "A status file only says a session waits, and holds nothing to answer it through."
   }
 };
 function counted(count2, one, many) {
@@ -4955,13 +6256,13 @@ function counted(count2, one, many) {
 }
 function createStatusFileAdapter(options = {}) {
   const env = options.env ?? process.env;
-  const homeDir = options.homeDir ?? os4.homedir();
+  const homeDir = options.homeDir ?? os6.homedir();
   const now = options.now ?? Date.now;
   const io = options.io ?? nodeIo2;
   const isAlive = options.isAlive ?? isProcessAlive;
   const pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS;
   const override = env[STATUS_DIR_ENV]?.trim() || void 0;
-  const dir = path12.resolve(override ?? path12.join(homeDir, ".agent-lookout", "sessions"));
+  const dir = path15.resolve(override ?? path15.join(homeDir, ".agent-lookout", "sessions"));
   const dirName = tildify(dir, homeDir);
   const decoder2 = new TextDecoder();
   let lastRead = /* @__PURE__ */ new Map();
@@ -5021,7 +6322,7 @@ function createStatusFileAdapter(options = {}) {
     if (names.length <= MAX_FILES) return names;
     const written = await Promise.all(
       names.map(async (name) => {
-        const info = await io.lstat(path12.join(dir, name)).catch(() => null);
+        const info = await io.lstat(path15.join(dir, name)).catch(() => null);
         return { name, mtimeMs: info?.mtimeMs ?? -Infinity };
       })
     );
@@ -5071,7 +6372,7 @@ function createStatusFileAdapter(options = {}) {
     const nextRead = /* @__PURE__ */ new Map();
     const nextStatuses = /* @__PURE__ */ new Map();
     for (const fileName2 of await toRead(listed)) {
-      const reading = await readOne(path12.join(dir, fileName2));
+      const reading = await readOne(path15.join(dir, fileName2));
       let kept;
       if (reading.kind === "read") {
         kept = reading;
@@ -5296,8 +6597,8 @@ function createEventStore(capacity = EVENT_CAPACITY) {
 }
 
 // src/collector/git/branchFinder.ts
-import os5 from "node:os";
-import path14 from "node:path";
+import os7 from "node:os";
+import path17 from "node:path";
 
 // src/collector/git/gitHead.ts
 var MAX_GIT_FILE_BYTES = 4 * 1024;
@@ -5337,18 +6638,18 @@ function parseCommonDir(content) {
 
 // src/collector/git/repository.ts
 import { createHash as createHash2 } from "node:crypto";
-import path13 from "node:path";
+import path16 from "node:path";
 var REPOSITORY_ID_LENGTH = 16;
 function repositoryId(gitFolder) {
   return createHash2("sha256").update(gitFolder).digest("hex").slice(0, REPOSITORY_ID_LENGTH);
 }
 function sharedName(common) {
-  const base = path13.basename(common);
-  if (base.startsWith(".")) return path13.basename(path13.dirname(common));
+  const base = path16.basename(common);
+  if (base.startsWith(".")) return path16.basename(path16.dirname(common));
   return base.endsWith(".git") ? base.slice(0, -".git".length) : base;
 }
 function repositoryOf({ dir, gitDir, commonDir }) {
-  const name = sessionName(commonDir === null ? path13.basename(dir) : sharedName(commonDir));
+  const name = sessionName(commonDir === null ? path16.basename(dir) : sharedName(commonDir));
   return name === void 0 ? null : { id: repositoryId(commonDir ?? gitDir), name };
 }
 
@@ -5377,13 +6678,13 @@ async function readGitFile(io, file, maxBytes = MAX_GIT_FILE_BYTES) {
   }
 }
 async function commonDirOf(io, gitDir) {
-  const content = await readGitFile(io, path14.join(gitDir, "commondir"));
+  const content = await readGitFile(io, path17.join(gitDir, "commondir"));
   if (content === void 0) return null;
   const target = content === null ? null : parseCommonDir(content);
-  return target === null ? void 0 : path14.resolve(gitDir, target);
+  return target === null ? void 0 : path17.resolve(gitDir, target);
 }
 async function headIn(dir, kind, io) {
-  const marker = path14.join(dir, ".git");
+  const marker = path17.join(dir, ".git");
   let gitDir;
   if (kind === "directory") {
     gitDir = marker;
@@ -5391,11 +6692,11 @@ async function headIn(dir, kind, io) {
     const content2 = await readGitFile(io, marker);
     const target = typeof content2 === "string" ? parseGitFile(content2) : null;
     if (target === null) return null;
-    gitDir = path14.resolve(dir, target);
+    gitDir = path17.resolve(dir, target);
   } else {
     return null;
   }
-  const content = await readGitFile(io, path14.join(gitDir, "HEAD"));
+  const content = await readGitFile(io, path17.join(gitDir, "HEAD"));
   const head = typeof content === "string" ? parseHead(content) : null;
   if (head === null) return null;
   const commonDir = kind === "file" ? await commonDirOf(io, gitDir) : null;
@@ -5404,20 +6705,20 @@ async function headIn(dir, kind, io) {
   return { head: { ...head, repository }, gitFolder: commonDir ?? gitDir };
 }
 async function findHead(cwd, { io, homeDir }) {
-  if (!path14.isAbsolute(cwd)) return null;
-  const home = path14.resolve(homeDir);
-  let dir = path14.resolve(cwd);
+  if (!path17.isAbsolute(cwd)) return null;
+  const home = path17.resolve(homeDir);
+  let dir = path17.resolve(cwd);
   try {
     if ((await io.stat(dir)).kind !== "directory") return null;
   } catch {
     return null;
   }
   for (let level = 0; level < MAX_LEVELS; level += 1) {
-    const parent = path14.dirname(dir);
+    const parent = path17.dirname(dir);
     if (dir === home || dir === parent) return null;
     let kind;
     try {
-      kind = (await io.lstat(path14.join(dir, ".git"))).kind;
+      kind = (await io.lstat(path17.join(dir, ".git"))).kind;
     } catch (error) {
       if (!isMissing(error)) return null;
       dir = parent;
@@ -5438,7 +6739,7 @@ function within(work, ms) {
   });
 }
 function createBranchFinder(options = {}) {
-  const where = { io: options.io ?? nodeIo2, homeDir: options.homeDir ?? os5.homedir() };
+  const where = { io: options.io ?? nodeIo2, homeDir: options.homeDir ?? os7.homedir() };
   const now = options.now ?? Date.now;
   const waitMs = options.waitMs ?? READ_WAIT_MS;
   const known = /* @__PURE__ */ new Map();
@@ -5452,7 +6753,9 @@ function createBranchFinder(options = {}) {
   return {
     async annotate(sessions) {
       const folders = /* @__PURE__ */ new Set();
-      for (const session of sessions) if (session.cwd) folders.add(session.cwd);
+      for (const session of sessions) {
+        if (session.cwd && session.machine === void 0) folders.add(session.cwd);
+      }
       for (const folder of known.keys()) if (!folders.has(folder)) known.delete(folder);
       if (!running) {
         const at = now();
@@ -5468,6 +6771,7 @@ function createBranchFinder(options = {}) {
         }
       }
       return sessions.map((session) => {
+        if (session.machine !== void 0) return session;
         const head = session.cwd ? known.get(session.cwd)?.found?.head : null;
         return head ? { ...session, git: head } : session;
       });
@@ -5497,14 +6801,14 @@ var STATUS_STATE = {
   PENDING: "pending",
   EXPECTED: "pending"
 };
-function isRecord7(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function textOf(value) {
   return typeof value === "string" ? value : "";
 }
 function checkOf(value) {
-  if (!isRecord7(value)) return null;
+  if (!isRecord10(value)) return null;
   const startedAt = Date.parse(textOf(value.startedAt));
   const at = Number.isNaN(startedAt) ? -Infinity : startedAt;
   if (value.__typename === "CheckRun") {
@@ -5553,7 +6857,7 @@ function readGhAnswer(stdout, repository) {
   } catch {
     return null;
   }
-  if (!isRecord7(data)) return null;
+  if (!isRecord10(data)) return null;
   const { number } = data;
   const state = stateOf2(data.state, data.isDraft);
   const title = typeof data.title === "string" ? sessionName(data.title) : void 0;
@@ -5691,7 +6995,7 @@ function createGhAsker(options) {
 }
 
 // src/collector/git/pullRequestTarget.ts
-import path15 from "node:path";
+import path18 from "node:path";
 
 // src/collector/git/gitConfig.ts
 var MAX_CONFIG_BYTES = 64 * 1024;
@@ -5949,7 +7253,7 @@ function targetOf(config, branch, base, defaultBranch) {
 async function readPullRequestTarget(gitFolder, branch, io = nodeIo2) {
   try {
     if (!isAskableBranch(branch)) return null;
-    const text4 = await readGitFile(io, path15.join(gitFolder, "config"), MAX_CONFIG_BYTES);
+    const text4 = await readGitFile(io, path18.join(gitFolder, "config"), MAX_CONFIG_BYTES);
     if (typeof text4 !== "string") return null;
     const config = parseGitConfig(text4);
     const base = config === null ? null : baseRemoteOf(config);
@@ -5958,7 +7262,7 @@ async function readPullRequestTarget(gitFolder, branch, io = nodeIo2) {
     if (base.name !== null && isSafeRemoteName(base.name)) {
       const head = await readGitFile(
         io,
-        path15.join(gitFolder, "refs", "remotes", base.name, "HEAD")
+        path18.join(gitFolder, "refs", "remotes", base.name, "HEAD")
       );
       if (typeof head === "string") defaultBranch = parseRemoteHead(head, base.name);
     }
@@ -5972,9 +7276,8 @@ async function readPullRequestTarget(gitFolder, branch, io = nodeIo2) {
 var PULL_REQUEST_CHECK_MS = 12e4;
 function placeOf2(session, gitFolderOf) {
   const branch = session.git?.branch;
-  if (session.cwd === null || branch === void 0 || session.git?.repository === void 0) {
-    return null;
-  }
+  if (session.machine !== void 0 || session.cwd === null || branch === void 0) return null;
+  if (session.git?.repository === void 0) return null;
   const gitFolder = gitFolderOf(session.cwd);
   return gitFolder === null ? null : { key: `${gitFolder}\0${branch}`, gitFolder, branch };
 }
@@ -5988,7 +7291,7 @@ function createPullRequestFinder(options) {
   const now = options.now ?? Date.now;
   const intervalMs = options.intervalMs ?? PULL_REQUEST_CHECK_MS;
   const reads = /* @__PURE__ */ new Map();
-  const answers = /* @__PURE__ */ new Map();
+  const answers2 = /* @__PURE__ */ new Map();
   let running = null;
   let pausedUntil = -Infinity;
   let gh = "unknown";
@@ -6000,22 +7303,22 @@ function createPullRequestFinder(options) {
       case "none":
         gh = "ready";
         last = { at, ok: true };
-        answers.set(question, {
+        answers2.set(question, {
           pullRequest: answer.kind === "found" ? answer.pullRequest : null,
           askedAt: at
         });
         return true;
       case "failed":
         last = { at, ok: false, reason: answer.reason };
-        answers.set(question, {
-          pullRequest: answers.get(question)?.pullRequest ?? null,
+        answers2.set(question, {
+          pullRequest: answers2.get(question)?.pullRequest ?? null,
           askedAt: at
         });
         return true;
       case "not-found":
       case "signed-out":
         gh = answer.kind;
-        answers.clear();
+        answers2.clear();
         pausedUntil = at + intervalMs;
         return false;
     }
@@ -6033,7 +7336,7 @@ function createPullRequestFinder(options) {
       asked.add(question);
       const at = now();
       if (at < pausedUntil) return;
-      if (!due(at, answers.get(question)?.askedAt)) continue;
+      if (!due(at, answers2.get(question)?.askedAt)) continue;
       const answer = await ask(target).catch(() => ({
         kind: "failed",
         reason: "gh could not be run"
@@ -6054,13 +7357,13 @@ function createPullRequestFinder(options) {
       for (const key of reads.keys()) if (!places.has(key)) reads.delete(key);
       const wanted = /* @__PURE__ */ new Set();
       for (const { target } of reads.values()) if (target) wanted.add(questionOf(target));
-      for (const question of answers.keys()) if (!wanted.has(question)) answers.delete(question);
+      for (const question of answers2.keys()) if (!wanted.has(question)) answers2.delete(question);
       if (!running) {
         const at = now();
         const toRead = [...places.values()].filter(
           (place) => due(at, reads.get(place.key)?.readAt)
         );
-        const toAsk = at >= pausedUntil && [...wanted].some((question) => due(at, answers.get(question)?.askedAt));
+        const toAsk = at >= pausedUntil && [...wanted].some((question) => due(at, answers2.get(question)?.askedAt));
         if (toRead.length > 0 || toAsk) {
           running = round(toRead).catch(() => {
           }).finally(() => {
@@ -6071,7 +7374,7 @@ function createPullRequestFinder(options) {
       return sessions.map((session) => {
         const place = placeOf2(session, gitFolderOf);
         const target = place === null ? null : reads.get(place.key)?.target;
-        const pullRequest = target ? answers.get(questionOf(target))?.pullRequest : null;
+        const pullRequest = target ? answers2.get(questionOf(target))?.pullRequest : null;
         return pullRequest && session.git ? { ...session, git: { ...session.git, pullRequest } } : session;
       });
     },
@@ -6130,7 +7433,7 @@ function createClearHistoryRoute(options) {
 }
 
 // src/collector/history/historyKeeper.ts
-import path16 from "node:path";
+import path19 from "node:path";
 
 // src/collector/history/historyFiles.ts
 import {
@@ -6143,7 +7446,7 @@ import {
   unlinkSync,
   writeSync
 } from "node:fs";
-import { lstat as lstat2, lutimes, mkdir, open as open3, readdir as readdir3, unlink } from "node:fs/promises";
+import { lstat as lstat3, lutimes, mkdir as mkdir2, open as open3, readdir as readdir3, unlink as unlink2 } from "node:fs/promises";
 function infoOf2(info) {
   return { kind: info.isFile() ? "file" : "other", size: info.size, mtimeMs: info.mtimeMs };
 }
@@ -6215,10 +7518,10 @@ async function writeTo(file, flags, text4) {
 }
 var nodeHistoryFs = {
   async makeFolder(dir) {
-    await mkdir(dir, { recursive: true, mode: FOLDER_MODE });
+    await mkdir2(dir, { recursive: true, mode: FOLDER_MODE });
   },
   list: (dir) => readdir3(dir),
-  lstat: async (file) => infoOf2(await lstat2(file)),
+  lstat: async (file) => infoOf2(await lstat3(file)),
   lstatNow: (file) => infoOf2(lstatSync(file)),
   readRegular,
   readRegularNow,
@@ -6232,7 +7535,7 @@ var nodeHistoryFs = {
   },
   async remove(file) {
     try {
-      await unlink(file);
+      await unlink2(file);
     } catch (error) {
       if (!isMissing2(error)) throw error;
     }
@@ -6247,7 +7550,7 @@ var nodeHistoryFs = {
 };
 
 // src/collector/history/writerLock.ts
-import { randomBytes } from "node:crypto";
+import { randomBytes as randomBytes2 } from "node:crypto";
 var LOCK_FILE = "writer.lock";
 var LOCK_STALE_MS = 3e4;
 var MAX_LOCK_BYTES = 256;
@@ -6272,8 +7575,8 @@ function createWriterLock(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 staleAfterMs2 = options.staleAfterMs ?? LOCK_STALE_MS;
+  const token = options.token ?? randomBytes2(8).toString("hex");
   const sources = options.sources ?? null;
   const content = `${JSON.stringify({ pid, token, ...sources !== null && { sources } })}
 `;
@@ -6283,7 +7586,7 @@ function createWriterLock(options) {
   function verdict(info, holder2) {
     heldByOtherSources = false;
     if (info.kind !== "file") return "leave";
-    const fresh = now() - info.mtimeMs < staleAfterMs;
+    const fresh = now() - info.mtimeMs < staleAfterMs2;
     if (!fresh || isOwn(holder2)) return "take-over";
     if (holder2 === null) return "leave";
     if (holder2.pid === pid || isAlive(holder2.pid)) {
@@ -6432,7 +7735,7 @@ function createHistoryKeeper(options) {
   });
   const lock = createWriterLock({
     fs,
-    file: path16.join(dir, LOCK_FILE),
+    file: path19.join(dir, LOCK_FILE),
     pid: options.pid,
     now,
     isAlive: options.isAlive,
@@ -6458,7 +7761,7 @@ function createHistoryKeeper(options) {
     });
     return next;
   }
-  const full = (name) => path16.join(dir, name);
+  const full = (name) => path19.join(dir, name);
   function hold(record) {
     if (unusable !== null || !running) return;
     const line = encodeRecord(record);
@@ -6720,12 +8023,12 @@ function createHistoryKeeper(options) {
     return serially(async () => {
       if (!running || unusable !== null) return;
       const kept = lock.held && await lock.keep();
-      const holds = kept || running && await lock.take();
+      const holds2 = kept || running && await lock.take();
       if (!running) {
         lock.releaseNow();
         return;
       }
-      if (!holds) {
+      if (!holds2) {
         writer = false;
         queue = [];
         startedAt = null;
@@ -6909,184 +8212,1339 @@ function keptHistoryStore(store, keeper) {
       store.add(point);
       keeper.addPoint(point);
     },
-    list: (windowMs, at) => store.list(windowMs, at),
-    clear: () => store.clear(),
-    get size() {
-      return store.size;
+    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 os8 from "node:os";
+import path20 from "node:path";
+var HISTORY_ENV = "AGENT_LOOKOUT_HISTORY";
+var HISTORY_DIR_ENV = "AGENT_LOOKOUT_HISTORY_DIR";
+function readHistorySetup(env, homeDir = os8.homedir()) {
+  if (env[HISTORY_ENV]?.trim().toLowerCase() === "off") return { on: false };
+  const override = env[HISTORY_DIR_ENV]?.trim() || void 0;
+  const dir = path20.resolve(override ?? path20.join(homeDir, ".agent-lookout", "history"));
+  return {
+    on: true,
+    dir,
+    folder: tildify(dir, homeDir),
+    sources: sourcesFingerprint(env, homeDir)
+  };
+}
+function sourcesFingerprint(env, homeDir = os8.homedir()) {
+  const set = (name) => env[name]?.trim() || void 0;
+  const folders = [
+    path20.resolve(set(CLAUDE_HOME_ENV) ?? path20.join(homeDir, ".claude")),
+    path20.resolve(set(CODEX_HOME_ENV) ?? set(CODEX_OWN_HOME_ENV) ?? path20.join(homeDir, ".codex")),
+    path20.resolve(set(STATUS_DIR_ENV) ?? path20.join(homeDir, ".agent-lookout", "sessions"))
+  ];
+  return createHash3("sha256").update(JSON.stringify(folders)).digest("hex").slice(0, 32);
+}
+
+// src/collector/notifications/heldWait.ts
+var HANDOVER_GRACE_MS = 3e3;
+var PAGE_GONE_AFTER_MS = 5e3;
+function noPageReports(on) {
+  return { on, lastOnAt: null, lastOnSessionsAt: null };
+}
+function heldWaitOutcome(since, pages, now) {
+  if (!pages.on) return "drop";
+  if (pages.lastOnSessionsAt !== null && pages.lastOnSessionsAt > since) return "drop";
+  if (pages.lastOnAt === null || now - pages.lastOnAt > PAGE_GONE_AFTER_MS) return "show";
+  return now - since >= HANDOVER_GRACE_MS ? "show" : "hold";
+}
+
+// src/collector/notifications/serverNotifications.ts
+var NOTIFICATIONS_ENV = "AGENT_LOOKOUT_NOTIFICATIONS";
+function notificationsOnAtStart(env) {
+  return env[NOTIFICATIONS_ENV]?.trim().toLowerCase() === "on";
+}
+var NOTIFICATIONS_NOT_SHOWN_LINE = `${NOTIFICATIONS_ENV} is on, but Agent Lookout shows notifications itself on macOS only, so it shows none here. A dashboard tab with notifications on still shows them.`;
+function notificationsAtStartLine(env, notifierShows) {
+  return notificationsOnAtStart(env) && !notifierShows ? NOTIFICATIONS_NOT_SHOWN_LINE : null;
+}
+var SUMMARY_KEY = "summary";
+function reminderKey(sessionId) {
+  return `reminder ${sessionId}`;
+}
+function heldKey(event, sessionId) {
+  return `${event} ${sessionId}`;
+}
+function createServerNotifications(options) {
+  const { notifier } = options;
+  const now = options.now ?? Date.now;
+  let memory = EMPTY_CHANGE_MEMORY;
+  let pages = noPageReports(options.onAtStart);
+  let chosen = new Set(options.onAtStart ? DEFAULT_NOTICE_EVENTS : []);
+  const held = /* @__PURE__ */ new Map();
+  const reminders = createReminderWatch();
+  const quiet = createQuietHold();
+  function show(notice) {
+    try {
+      notifier.show(notice);
+    } catch {
+    }
+  }
+  const wants = (event) => pages.on && chosen.has(event);
+  function holdQuietly(change, at) {
+    const { event, session } = change;
+    if (event === "needs-you") quiet.holdWait(session, waitBegan(session.statusSince, at));
+    else quiet.holdOver(event, withoutWaitingText(session), at);
+  }
+  return {
+    pageSaid(said, fetchedSessions) {
+      const at = now();
+      chosen = new Set(said);
+      if (said.length === 0) {
+        pages = { ...pages, on: false };
+        return;
+      }
+      pages = {
+        on: true,
+        lastOnAt: at,
+        lastOnSessionsAt: fetchedSessions ? at : pages.lastOnSessionsAt
+      };
+    },
+    handle(snapshot) {
+      const at = now();
+      const rules = rulesOf(snapshot);
+      const quietNow = quietOf(snapshot);
+      const thresholdMs = rules.longWait.minutes * 6e4;
+      const result = sessionChanges(memory, snapshot);
+      memory = result.memory;
+      for (const id of result.stopped) {
+        held.delete(heldKey("needs-you", id));
+        held.delete(reminderKey(id));
+        quiet.waitEnded(id, at);
+      }
+      reminders.observe(snapshot, result.stopped, at);
+      if (quiet.holding() && !quietNow) {
+        const end = quiet.end(snapshot, at, rules.quietHours.leaveOutAnswered);
+        const items = end.summary?.items.filter((item) => wants(item.event)) ?? [];
+        if (end.summary && items.length > 0) {
+          held.set(SUMMARY_KEY, {
+            kind: "summary",
+            summary: { ...end.summary, items },
+            since: at
+          });
+        }
+        for (const { session } of end.open) {
+          if (!wants("needs-you")) continue;
+          held.set(heldKey("needs-you", session.id), {
+            kind: "change",
+            change: { event: "needs-you", session },
+            since: at
+          });
+          if (rules.longWait.on) reminders.toldLate(session.id, at, thresholdMs);
+        }
+      }
+      if (quietNow) quiet.begin(at);
+      for (const change of result.changes) {
+        if (!wants(change.event)) continue;
+        if (quietNow) holdQuietly(change, at);
+        else
+          held.set(heldKey(change.event, change.session.id), { kind: "change", change, since: at });
+      }
+      if (!quietNow && rules.longWait.on && wants("needs-you")) {
+        for (const reminder of reminders.due(snapshot, at, thresholdMs)) {
+          reminders.reminded(reminder.session.id, thresholdMs);
+          held.set(reminderKey(reminder.session.id), { kind: "reminder", reminder, since: at });
+        }
+      }
+      const listed = new Map(snapshot.sessions.map((session) => [session.id, session]));
+      for (const entry of held.values()) {
+        if (entry.kind === "summary") continue;
+        const session = entry.kind === "change" ? entry.change.session : entry.reminder.session;
+        const current = listed.get(session.id);
+        if (current?.status !== "needs-you") continue;
+        if (entry.kind === "reminder") entry.reminder = { ...entry.reminder, session: current };
+        else if (entry.change.event === "needs-you")
+          entry.change = { ...entry.change, session: current };
+      }
+      for (const [key, entry] of held) {
+        const event = entry.kind === "change" ? entry.change.event : "needs-you";
+        const outcome = entry.kind === "summary" || chosen.has(event) ? heldWaitOutcome(entry.since, pages, at) : "drop";
+        if (outcome === "hold") continue;
+        held.delete(key);
+        if (outcome !== "show") continue;
+        if (quietNow) {
+          if (entry.kind === "change") holdQuietly(entry.change, at);
+          else if (entry.kind === "reminder") {
+            quiet.holdWait(entry.reminder.session, entry.reminder.begunAt);
+          }
+          continue;
+        }
+        if (entry.kind === "change") show(changeNotice(entry.change));
+        else if (entry.kind === "reminder") {
+          show(reminderNotice(entry.reminder.session, at - entry.reminder.begunAt));
+        } else show(summaryNotice(entry.summary.items));
+      }
+    }
+  };
+}
+
+// src/collector/processes/osascript.ts
+import { execFile as execFile3 } from "node:child_process";
+var OSASCRIPT = "/usr/bin/osascript";
+var MAX_OUTPUT_BYTES4 = 64 * 1024;
+var NOT_RUN2 = { ok: false, stderr: "", timedOut: false };
+function runOsascript(args, options = {}) {
+  return new Promise((resolve) => {
+    try {
+      const child = execFile3(
+        OSASCRIPT,
+        [...args],
+        {
+          timeout: options.timeoutMs ?? TERMINAL_JUMP_TIMEOUT_MS,
+          maxBuffer: MAX_OUTPUT_BYTES4,
+          encoding: "utf8",
+          windowsHide: true
+        },
+        (error, stdout, stderr) => {
+          if (!error) {
+            resolve({ ok: true, stdout: String(stdout ?? "") });
+            return;
+          }
+          const timedOut = error.killed === true;
+          resolve({ ok: false, stderr: String(stderr ?? "").trim(), timedOut });
+        }
+      );
+      child.stdin?.end();
+    } catch {
+      resolve(NOT_RUN2);
+    }
+  });
+}
+
+// src/collector/notifications/systemNotifier.ts
+var OSASCRIPT_TIMEOUT_MS = 5e3;
+var SCRIPT = [
+  "on run argv",
+  "display notification (item 2 of argv) with title (item 1 of argv)",
+  "end run"
+];
+function osascriptArgs(notice) {
+  return [
+    ...SCRIPT.flatMap((line) => ["-e", line]),
+    "--",
+    oneLine(notice.title),
+    oneLine(notice.body, MAX_NOTICE_TEXT_LENGTH)
+  ];
+}
+function systemNotificationsShownOn(platform) {
+  return platform === "darwin";
+}
+var runForNotification = (args) => runOsascript(args, { timeoutMs: OSASCRIPT_TIMEOUT_MS });
+function createSystemNotifier(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const run = options.run ?? runForNotification;
+  return {
+    show(notice) {
+      if (!systemNotificationsShownOn(platform)) return;
+      try {
+        run(osascriptArgs(notice)).catch(() => {
+        });
+      } catch {
+      }
+    }
+  };
+}
+
+// src/collector/remotes/remoteReader.ts
+import { request } from "node:http";
+var REMOTE_ANSWER_TIMEOUT_MS = 6e3;
+var MAX_ANSWER_BYTES = 8 * 1024 * 1024;
+function askRemote(port, route, timeoutMs = REMOTE_ANSWER_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    let connected = false;
+    let settled = false;
+    const finish = (answer) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      req.destroy();
+      resolve(answer);
+    };
+    const req = request({
+      host: "127.0.0.1",
+      port,
+      path: route,
+      method: "GET",
+      // A connection of its own, closed after the answer.
+      agent: false,
+      headers: { Accept: "application/json" }
+    });
+    const timer = setTimeout(() => finish({ kind: "timeout" }), timeoutMs);
+    timer.unref?.();
+    req.on("socket", (socket) => socket.once("connect", () => connected = true));
+    req.on("error", () => finish(connected ? { kind: "closed" } : { kind: "refused" }));
+    req.on("response", (res) => {
+      if (res.statusCode !== 200) {
+        finish({ kind: "unreadable", why: `answered ${route} with status ${res.statusCode}` });
+        return;
+      }
+      const chunks = [];
+      let size = 0;
+      res.on("data", (chunk) => {
+        size += chunk.byteLength;
+        if (size > MAX_ANSWER_BYTES) finish({ kind: "unreadable", why: `sent too long an answer` });
+        else chunks.push(chunk);
+      });
+      res.on("error", () => finish({ kind: "closed" }));
+      res.on("end", () => {
+        try {
+          finish({ kind: "json", value: JSON.parse(Buffer.concat(chunks).toString("utf8")) });
+        } catch {
+          finish({ kind: "unreadable", why: `answered ${route} with something that is not JSON` });
+        }
+      });
+    });
+    req.end();
+  });
+}
+function versionIn(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const { ok, version } = value;
+  if (ok !== true || typeof version !== "string") return null;
+  return /^\d{1,4}\.\d{1,5}\.\d{1,6}(?:-[0-9A-Za-z.-]{1,40})?$/.test(version) ? version : null;
+}
+async function readRemote(port, timeoutMs = REMOTE_ANSWER_TIMEOUT_MS) {
+  const health = await askRemote(port, "/api/health", timeoutMs);
+  if (health.kind !== "json") return health;
+  const version = versionIn(health.value);
+  if (version === null) {
+    return { kind: "unreadable", why: "answered /api/health, but not as Agent Lookout does" };
+  }
+  const sessions = await askRemote(port, "/api/sessions", timeoutMs);
+  if (sessions.kind !== "json") return sessions;
+  return { kind: "read", version, snapshot: sessions.value };
+}
+
+// src/collector/remotes/remoteSessions.ts
+var MAX_REMOTE_SESSIONS = 500;
+var MAX_REMOTE_SOURCES = 20;
+var MAX_ID_LENGTH = 512;
+var MAX_PATH_LENGTH = 4096;
+var MAX_WORD_LENGTH2 = 200;
+function isRecord11(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function oneOf2(allowed, value) {
+  return allowed.includes(value) ? value : null;
+}
+function exact(value, max) {
+  if (typeof value !== "string") return null;
+  const cleaned = cut(value, max);
+  return cleaned === value ? value : null;
+}
+var COMMIT_ID2 = /^[0-9a-f]{7,64}$/;
+var REPOSITORY_ID = /^[0-9a-f]{16,64}$/;
+function readGit(value, machine) {
+  if (!isRecord11(value)) return void 0;
+  let head;
+  if (value.commit !== void 0) {
+    if (value.branch !== void 0 || typeof value.commit !== "string") return void 0;
+    if (!COMMIT_ID2.test(value.commit)) return void 0;
+    head = { commit: value.commit };
+  } else {
+    const branch = cut(value.branch, MAX_NAME_LENGTH);
+    if (branch === void 0) return void 0;
+    head = { branch };
+  }
+  const repository = value.repository;
+  if (isRecord11(repository) && typeof repository.id === "string") {
+    const name = sessionName(typeof repository.name === "string" ? repository.name : "");
+    if (name !== void 0 && REPOSITORY_ID.test(repository.id)) {
+      head.repository = { id: repositoryId(`${machine}
+${repository.id}`), name };
+    }
+  }
+  return head;
+}
+function readSession(value, machine, sources, now, keepWaitingText) {
+  if (!isRecord11(value)) return null;
+  const id = exact(value.id, MAX_ID_LENGTH);
+  const source = exact(value.source, MAX_WORD_LENGTH2);
+  if (id === null || source === null) return null;
+  if (isRemoteSource(source) || value.machine !== void 0) return null;
+  const project = sessionName(typeof value.project === "string" ? value.project : "") ?? null;
+  const status = oneOf2(SESSION_STATUSES, value.status) ?? "unknown";
+  const agent = cut(value.agent, MAX_WORD_LENGTH2) ?? sources.get(source) ?? source;
+  const session = {
+    id: `${remoteSourceId(machine)}:${id}`,
+    source: remoteSourceId(machine),
+    agent,
+    machine,
+    surface: oneOf2(SURFACES, value.surface) ?? "unknown",
+    name: sessionName(typeof value.name === "string" ? value.name : "") ?? project ?? id,
+    cwd: cut(value.cwd, MAX_PATH_LENGTH) ?? null,
+    project,
+    status,
+    startedAt: plausibleTime(value.startedAt, now),
+    statusSince: plausibleTime(value.statusSince, now),
+    links: {},
+    stale: value.stale === true
+  };
+  if (status === "needs-you") {
+    const reason = oneOf2(WAITING_REASONS, value.waitingReason);
+    if (reason) session.waitingReason = reason;
+    const detail = cut(value.waitingDetail, MAX_WORD_LENGTH2);
+    if (detail !== void 0) session.waitingDetail = detail;
+    const asking = keepWaitingText ? waitingText(value.waitingText) : void 0;
+    if (asking !== void 0) session.waitingText = asking;
+  }
+  const lastWriteAt = plausibleTime(value.lastWriteAt, now);
+  if (lastWriteAt !== null) session.lastWriteAt = lastWriteAt;
+  if (typeof value.alive === "boolean") session.alive = value.alive;
+  const git = readGit(value.git, machine);
+  if (git) session.git = git;
+  return session;
+}
+function readCell(value) {
+  if (!isRecord11(value)) return null;
+  if (value.level === "yes") return { level: "yes" };
+  const level = oneOf2(["no", "partly"], value.level);
+  const reason = cut(value.reason, MAX_WORD_LENGTH2);
+  return level && reason !== void 0 ? { level, reason } : null;
+}
+var ACTS_HERE = ["jump", "stop", "answer"];
+function readCapabilities(value, machine) {
+  if (!isRecord11(value)) return null;
+  const read = {};
+  for (const capability of CAPABILITIES) {
+    if (ACTS_HERE.includes(capability)) continue;
+    const cell = readCell(value[capability]);
+    if (!cell) return null;
+    read[capability] = cell;
+  }
+  return {
+    ...read,
+    jump: { level: "no", reason: `Jump acts on this computer only, not on ${machine}.` },
+    stop: { level: "no", reason: `Stop acts on this computer only, not on ${machine}.` },
+    answer: { level: "no", reason: `Answer acts on this computer only, not on ${machine}.` }
+  };
+}
+function readRemoteSnapshot(value, machine, now, options = {}) {
+  if (!isRecord11(value) || !Array.isArray(value.sessions) || !Array.isArray(value.sources)) {
+    return null;
+  }
+  const named = /* @__PURE__ */ new Map();
+  const sources = [];
+  const agents = [];
+  for (const item of value.sources) {
+    if (sources.length >= MAX_REMOTE_SOURCES) break;
+    if (!isRecord11(item)) continue;
+    const id = exact(item.id, MAX_WORD_LENGTH2);
+    if (id === null || isRemoteSource(id) || item.machine !== void 0) continue;
+    const label2 = cut(item.label, MAX_WORD_LENGTH2) ?? id;
+    const state = oneOf2(SOURCE_STATES, item.state) ?? "error";
+    if (named.has(id)) continue;
+    named.set(id, label2);
+    sources.push({ label: label2, state });
+    if (state === "unavailable" || state === "not-set-up") continue;
+    const capabilities = readCapabilities(item.capabilities, machine);
+    if (capabilities) agents.push({ label: label2, capabilities });
+  }
+  const sessions = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of value.sessions) {
+    if (sessions.length >= MAX_REMOTE_SESSIONS) break;
+    const session = readSession(item, machine, named, now, options.waitingText !== false);
+    if (!session || seen.has(session.id)) continue;
+    seen.add(session.id);
+    sessions.push(session);
+  }
+  return { sessions, sources, agents };
+}
+
+// src/collector/remotes/sshProgram.ts
+import path21 from "node:path";
+var SSH_BIN_ENV = "AGENT_LOOKOUT_SSH_BIN";
+var SSH_LOCATIONS = ["/usr/bin/ssh", "/opt/homebrew/bin/ssh", "/usr/local/bin/ssh"];
+var SERVER_ALIVE_SECONDS = 15;
+async function findSsh(env, isExecutable = isExecutableFile) {
+  const named = env[SSH_BIN_ENV]?.trim();
+  if (named) {
+    const resolved = path21.resolve(named);
+    if (await isExecutable(resolved)) return { found: true, path: resolved };
+    return {
+      found: false,
+      looked: `${SSH_BIN_ENV} is set to ${named}, which is not a program this user can run`,
+      named: true
+    };
+  }
+  const candidates = [.../* @__PURE__ */ new Set([...pathCandidates(env, "ssh"), ...SSH_LOCATIONS])];
+  for (const candidate of candidates) {
+    if (await isExecutable(candidate)) return { found: true, path: candidate };
+  }
+  return {
+    found: false,
+    looked: `The ssh command was not found on PATH or in ${SSH_LOCATIONS.map((at) => path21.dirname(at)).join(", ")}`
+  };
+}
+function sshArguments(forward) {
+  return [
+    "-N",
+    "-o",
+    "BatchMode=yes",
+    "-o",
+    "ExitOnForwardFailure=yes",
+    "-o",
+    `ServerAliveInterval=${SERVER_ALIVE_SECONDS}`,
+    "-o",
+    "ControlMaster=no",
+    "-o",
+    "ControlPath=none",
+    "-L",
+    `127.0.0.1:${forward.localPort}:127.0.0.1:${forward.remotePort}`,
+    "--",
+    forward.target
+  ];
+}
+
+// src/collector/remotes/remoteAdapter.ts
+var BASIS3 = "api";
+var NOT_CONNECTED = "unavailable";
+var ANSWER_WAIT_MS = 500;
+var STILL_CONNECTING_MS = 1e4;
+function within2(work, ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+    void work.then(() => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+function sentence(text4) {
+  return /[.!?]$/.test(text4) ? text4 : `${text4}.`;
+}
+function inSeconds(at, now) {
+  const seconds = Math.max(1, Math.ceil((at - now) / 1e3));
+  return `in ${seconds} ${seconds === 1 ? "second" : "seconds"}`;
+}
+function createRemoteAdapter(options) {
+  const { remote, tunnel, version } = options;
+  const read = options.read ?? ((port) => readRemote(port));
+  const now = options.now ?? Date.now;
+  const pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS;
+  const answerWaitMs = options.answerWaitMs ?? ANSWER_WAIT_MS;
+  const stillConnectingMs = options.stillConnectingMs ?? STILL_CONNECTING_MS;
+  const waitingText2 = options.waitingText ?? true;
+  const id = remoteSourceId(remote.name);
+  const label2 = remote.name;
+  const where = `port ${remote.port} of ${remote.name}`;
+  let latest = null;
+  let underWay = null;
+  let problem = null;
+  let agents = [];
+  let command = null;
+  let connectingSince = null;
+  function facts(snapshot, remoteVersion) {
+    const watching = [{ label: "Connects to", value: remote.target }];
+    if (command !== null) watching.push({ label: "Command", value: command });
+    watching.push(
+      { label: "Asks for", value: "/api/health and /api/sessions" },
+      { label: "Read", value: every(pollIntervalMs) }
+    );
+    if (remoteVersion !== null) {
+      watching.push({ label: "Agent Lookout there", value: remoteVersion });
+    }
+    for (const source of snapshot?.sources ?? []) {
+      watching.push({ label: `${source.label} there`, value: SOURCE_STATE_LABEL[source.state] });
+    }
+    return watching;
+  }
+  function result(state, found, checkedAt, snapshot = null, remoteVersion = null) {
+    const health = {
+      id,
+      label: label2,
+      machine: remote.name,
+      state,
+      detail: found.detail,
+      watching: facts(snapshot, remoteVersion),
+      checkedAt
+    };
+    if (found.advice) health.advice = found.advice;
+    if (agents.length > 0) health.agents = agents;
+    const sessions = state === "ok" && snapshot ? snapshot.sessions : [];
+    return state === "ok" ? { health, sessions, basis: BASIS3 } : { health, sessions };
+  }
+  function connecting(at) {
+    if (problem === null) {
+      connectingSince ??= at;
+      if (at - connectingSince < stillConnectingMs) {
+        return result(
+          "searching",
+          { detail: `Connecting to ${remote.name} over SSH, as ${remote.target}.` },
+          at
+        );
+      }
+      return result(
+        NOT_CONNECTED,
+        {
+          detail: `Still connecting to ${remote.name} over SSH, as ${remote.target}.`,
+          advice: `ssh has not connected yet. If this goes on, check that ssh ${remote.target} connects from a terminal on this computer, and that ${remote.name} is switched on and reachable.`
+        },
+        at
+      );
+    }
+    return result(
+      NOT_CONNECTED,
+      { detail: `${problem.detail} Connecting again.`, advice: problem.advice },
+      at
+    );
+  }
+  function endProblem(end) {
+    const said = end.said === null ? null : sentence(end.said);
+    if (end.connected) {
+      return {
+        detail: `The SSH connection to ${remote.name} dropped${said ? `: ${said}` : "."}`,
+        advice: "It is started again on its own. If it keeps dropping, check the network between the two machines."
+      };
+    }
+    if (said !== null && /could not request local forwarding|cannot listen to port/i.test(said)) {
+      return { detail: `ssh could not forward a port on this computer: ${said}` };
+    }
+    if (said !== null && /permission denied|host key verification failed|authentication|refused|closed by/i.test(said)) {
+      return {
+        detail: `${remote.name} turned the SSH connection away: ${said}`,
+        advice: `Check that ssh ${remote.target} connects without asking for anything. Agent Lookout runs ssh with BatchMode, so it never types a password or answers a question.`
+      };
+    }
+    return {
+      detail: said ? `ssh could not connect to ${remote.target}: ${said}` : `ssh could not connect to ${remote.target}, and ended${end.code === null ? "" : ` with code ${end.code}`}.`,
+      advice: `Check that ssh ${remote.target} connects from a terminal on this computer.`
+    };
+  }
+  function fromRead(done) {
+    const { reading } = done;
+    switch (reading.kind) {
+      case "refused":
+        return connecting(done.at);
+      case "closed":
+        problem = {
+          detail: `ssh is connected to ${remote.name}, but no Agent Lookout answers on its port ${remote.port}.`,
+          advice: `Start it there with npx agent-lookout, and leave it running. If it listens on another port, give it as ${remote.name}=${remote.target}:<port>.`
+        };
+        return result(NOT_CONNECTED, problem, done.at);
+      case "timeout":
+        problem = {
+          detail: `${remote.name} did not answer within ${REMOTE_ANSWER_TIMEOUT_MS / 1e3} seconds.`,
+          advice: "It keeps trying. ssh notices within a minute when the connection has gone."
+        };
+        return result(NOT_CONNECTED, problem, done.at);
+      case "unreadable":
+        problem = {
+          detail: `What listens on ${where} ${reading.why}, so it is not read as Agent Lookout.`,
+          advice: `Check that Agent Lookout is what listens there, or give its port as ${remote.name}=${remote.target}:<port>.`
+        };
+        return result(NOT_CONNECTED, problem, done.at);
+      case "read":
+        if (done.snapshot === null) {
+          problem = {
+            detail: `${remote.name} runs Agent Lookout ${reading.version}, and this computer's, ${version}, cannot read its list of sessions.`,
+            advice: "Run the same version of Agent Lookout on both machines."
+          };
+          return result(NOT_CONNECTED, problem, done.at, null, reading.version);
+        }
+        problem = null;
+        connectingSince = null;
+        return result(
+          "ok",
+          {
+            detail: `Sessions are read from Agent Lookout ${reading.version} on ${remote.name}, through ssh to ${remote.target}. Jump, Stop, Allow and Deny act on this computer only.`
+          },
+          done.at,
+          done.snapshot,
+          reading.version
+        );
+    }
+  }
+  function readThrough(run, port) {
+    if (underWay) return underWay;
+    const current = read(port).catch(() => ({ kind: "closed" })).then((reading) => {
+      const at = now();
+      if (reading.kind !== "refused") tunnel.connected(run);
+      const snapshot = reading.kind === "read" ? readRemoteSnapshot(reading.snapshot, remote.name, at, { waitingText: waitingText2 }) : null;
+      if (snapshot) agents = snapshot.agents;
+      latest = { run, at, reading, snapshot };
+    }).finally(() => {
+      underWay = null;
+    });
+    underWay = current;
+    return current;
+  }
+  async function poll() {
+    const at = now();
+    const state = tunnel.state();
+    switch (state.kind) {
+      case "off":
+        return connecting(at);
+      case "no-ssh":
+        latest = null;
+        problem = {
+          detail: `${state.looked}, so ${remote.name} cannot be reached. Looking again ${inSeconds(state.retryAt, at)}.`,
+          advice: state.named ? `Correct ${SSH_BIN_ENV}, or unset it to use the ssh on your PATH.` : `Install OpenSSH, or name the ssh program with ${SSH_BIN_ENV}.`
+        };
+        return result(NOT_CONNECTED, problem, at);
+      case "ended": {
+        latest = null;
+        problem = endProblem(state.end);
+        return result(
+          NOT_CONNECTED,
+          {
+            detail: `${problem.detail} Trying again ${inSeconds(state.retryAt, at)}.`,
+            advice: problem.advice
+          },
+          at
+        );
+      }
+      case "running": {
+        command = state.command.join(" ");
+        if (latest && latest.run !== state.run) latest = null;
+        await within2(readThrough(state.run, state.port), answerWaitMs);
+        return latest && latest.run === state.run ? fromRead(latest) : connecting(at);
+      }
+    }
+  }
+  return {
+    id,
+    label: label2,
+    lookingIn: `Connecting to ${remote.name} over SSH, as ${remote.target}.`,
+    async poll() {
+      try {
+        return await poll();
+      } catch {
+        return result(
+          "error",
+          { detail: `Something unexpected went wrong while reading ${remote.name}.` },
+          now()
+        );
+      }
+    }
+  };
+}
+
+// src/collector/remotes/remoteSettings.ts
+var REMOTES_ENV = "AGENT_LOOKOUT_REMOTES";
+var DEFAULT_REMOTE_PORT = 4777;
+var MAX_REMOTES = 8;
+var USER = "[A-Za-z0-9_][A-Za-z0-9._-]{0,63}";
+var HOST = "[A-Za-z0-9_][A-Za-z0-9._-]{0,252}";
+var TARGET = new RegExp(`^(?:${USER}@)?${HOST}$`);
+function isSshTarget(value) {
+  return TARGET.test(value);
+}
+function portOf(text4) {
+  if (!/^\d{1,5}$/.test(text4)) return null;
+  const port = Number(text4);
+  return port >= 1 && port <= 65535 ? port : null;
+}
+function ordinal(index) {
+  const n = index + 1;
+  const tens = n % 100;
+  if (tens >= 11 && tens <= 13) return `${n}th`;
+  return `${n}${n % 10 === 1 ? "st" : n % 10 === 2 ? "nd" : n % 10 === 3 ? "rd" : "th"}`;
+}
+var EXAMPLE = "such as devbox=dev@devbox.local";
+function readEntry(entry, index) {
+  const equals = entry.indexOf("=");
+  if (equals < 0) {
+    return `${REMOTES_ENV} has an entry, the ${ordinal(index)}, with no = in it. Write each machine as name=target, ${EXAMPLE}.`;
+  }
+  const name = entry.slice(0, equals).trim();
+  if (!isMachineName(name)) {
+    return `${REMOTES_ENV} gives the ${ordinal(index)} machine a name that is not one: use letters, digits and dashes, up to ${MAX_MACHINE_NAME_LENGTH}, starting with a letter or a digit.`;
+  }
+  let target = entry.slice(equals + 1).trim();
+  let port = DEFAULT_REMOTE_PORT;
+  const colon = target.lastIndexOf(":");
+  if (colon >= 0) {
+    const given = portOf(target.slice(colon + 1));
+    if (given === null) {
+      return `${REMOTES_ENV} gives ${name} a port that is not a number from 1 to 65535.`;
+    }
+    port = given;
+    target = target.slice(0, colon);
+  }
+  if (!isSshTarget(target)) {
+    return `${REMOTES_ENV} gives ${name} a target that Agent Lookout does not hand to ssh. Give a host alias from your ssh config, a host name or user@host, with no spaces, no leading dash and no other punctuation.`;
+  }
+  return { name, target, port };
+}
+function readRemotesSetup(env) {
+  const value = env[REMOTES_ENV]?.trim() ?? "";
+  if (value === "") return { on: false, problem: null };
+  const entries = value.split(",").map((entry) => entry.trim()).filter((entry) => entry !== "");
+  if (entries.length === 0) return { on: false, problem: null };
+  if (entries.length > MAX_REMOTES) {
+    return {
+      on: false,
+      problem: `${REMOTES_ENV} names ${entries.length} machines, and Agent Lookout reads ${MAX_REMOTES} at most.`
+    };
+  }
+  const remotes = [];
+  const names = /* @__PURE__ */ new Set();
+  for (const [index, entry] of entries.entries()) {
+    const read = readEntry(entry, index);
+    if (typeof read === "string") return { on: false, problem: read };
+    const key = read.name.toLowerCase();
+    if (names.has(key)) {
+      return { on: false, problem: `${REMOTES_ENV} names ${read.name} twice.` };
+    }
+    names.add(key);
+    remotes.push(read);
+  }
+  return { on: true, remotes };
+}
+function remotesProblemLine(problem) {
+  return `Other machines are not read: ${problem}`;
+}
+
+// src/collector/remotes/tunnel.ts
+import { spawn as spawn2 } from "node:child_process";
+import { createServer as createServer2 } from "node:net";
+var RESTART_DELAYS_MS = [1e3, 2e3, 5e3, 1e4, 3e4, 6e4];
+var MAX_SAID_BYTES = 4096;
+var MAX_SAID_LENGTH = 200;
+var STOP_WAIT_MS2 = 2e3;
+function freeLoopbackPort() {
+  return new Promise((resolve, reject) => {
+    const server = createServer2();
+    server.unref();
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address();
+      server.close(() => resolve(port));
+    });
+  });
+}
+var spawnSsh = (binary, args, env) => spawn2(binary, [...args], { env, stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
+var live = /* @__PURE__ */ new Set();
+var endedOnExit = false;
+function endOnExit(child) {
+  live.add(child);
+  child.once("exit", () => live.delete(child));
+  if (endedOnExit) return;
+  endedOnExit = true;
+  process.once("exit", () => {
+    for (const running of live) running.kill("SIGTERM");
+  });
+}
+function lastLine(text4) {
+  const lines = text4.split(/\r?\n/).map((line2) => clean(line2)).filter((line2) => line2 !== void 0);
+  const reasons = lines.filter((line2) => !/^warning:/i.test(line2));
+  const line = reasons[reasons.length - 1] ?? lines[lines.length - 1];
+  return line === void 0 ? null : oneLine(line, MAX_SAID_LENGTH);
+}
+function createTunnel(options) {
+  const { remote, env } = options;
+  const find = options.findSsh ?? findSsh;
+  const freePort = options.freePort ?? freeLoopbackPort;
+  const start = options.spawnSsh ?? spawnSsh;
+  const delays = options.restartDelaysMs ?? RESTART_DELAYS_MS;
+  const now = options.now ?? Date.now;
+  let state = { kind: "off" };
+  let on = false;
+  let generation = 0;
+  let run = 0;
+  let unanswered = 0;
+  let connectedRun = null;
+  let child = null;
+  let timer = null;
+  let exited = Promise.resolve();
+  function notStarted(said) {
+    const at = now();
+    return {
+      kind: "ended",
+      run,
+      end: { at, connected: false, code: null, said },
+      retryAt: later(nextDelay(), at)
+    };
+  }
+  function nextDelay() {
+    const delay = delays[Math.min(unanswered, delays.length - 1)] ?? 1e3;
+    unanswered += 1;
+    return delay;
+  }
+  function later(delay, from = now()) {
+    if (timer) clearTimeout(timer);
+    const current = generation;
+    timer = setTimeout(() => {
+      timer = null;
+      void launch(current);
+    }, delay);
+    timer.unref?.();
+    return from + delay;
+  }
+  let launching = false;
+  let again = false;
+  async function launch(current) {
+    if (launching) {
+      again = true;
+      return;
+    }
+    launching = true;
+    try {
+      await prepare(current);
+    } finally {
+      launching = false;
+    }
+    if (again) {
+      again = false;
+      void launch(generation);
+    }
+  }
+  async function prepare(current) {
+    const stale = () => !on || current !== generation;
+    if (stale() || child) return;
+    const search = await find(env);
+    if (stale()) return;
+    if (!search.found) {
+      state = { kind: "no-ssh", looked: search.looked, retryAt: later(nextDelay()) };
+      if (search.named) state.named = true;
+      return;
+    }
+    let port;
+    try {
+      port = await freePort();
+    } catch {
+      state = notStarted("No free port on 127.0.0.1.");
+      return;
+    }
+    if (stale() || child) return;
+    run += 1;
+    const thisRun = run;
+    const args = sshArguments({ localPort: port, remotePort: remote.port, target: remote.target });
+    let ssh;
+    try {
+      ssh = start(search.path, args, env);
+    } catch {
+      state = notStarted("ssh could not be started.");
+      return;
+    }
+    child = ssh;
+    endOnExit(ssh);
+    state = { kind: "running", run: thisRun, port, since: now(), command: [search.path, ...args] };
+    let said = "";
+    ssh.stderr?.setEncoding("utf8");
+    ssh.stderr?.on("data", (chunk) => {
+      said = (said + chunk).slice(-MAX_SAID_BYTES);
+    });
+    ssh.unref();
+    ssh.stderr?.unref?.();
+    let gone = () => {
+    };
+    exited = new Promise((resolve) => gone = resolve);
+    ssh.once("exit", () => {
+      if (child === ssh) child = null;
+      gone();
+      if (current !== generation && on && child === null) {
+        if (state.kind === "running" && state.run === thisRun) state = { kind: "off" };
+        void launch(generation);
+      }
+    });
+    let over = false;
+    const finish = (code, failure2) => {
+      if (over) return;
+      over = true;
+      if (child === ssh) child = null;
+      gone();
+      const connected = connectedRun === thisRun;
+      if (connected) unanswered = 0;
+      if (current !== generation) return;
+      const at = now();
+      const end = { at, connected, code, said: lastLine(said) ?? failure2 };
+      state = { kind: "ended", run: thisRun, end, retryAt: later(nextDelay(), at) };
+    };
+    ssh.once("close", (code) => finish(typeof code === "number" ? code : null, null));
+    ssh.once("error", () => {
+      if (ssh.pid === void 0) finish(null, "ssh could not be started.");
+    });
+  }
+  function ended(gone) {
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => resolve(false), STOP_WAIT_MS2);
+      timeout.unref?.();
+      void gone.then(() => {
+        clearTimeout(timeout);
+        resolve(true);
+      });
+    });
+  }
+  return {
+    start() {
+      if (on) return;
+      on = true;
+      generation += 1;
+      unanswered = 0;
+      void launch(generation);
+    },
+    async stop() {
+      on = false;
+      generation += 1;
+      if (timer) clearTimeout(timer);
+      timer = null;
+      const running = child;
+      const gone = exited;
+      if (running) {
+        running.kill("SIGTERM");
+        if (!await ended(gone)) {
+          running.kill("SIGKILL");
+          await ended(gone);
+        }
+      }
+      if (!on) state = { kind: "off" };
+    },
+    state: () => state,
+    connected(which) {
+      if (state.kind === "running" && state.run === which) connectedRun = which;
     }
   };
 }
 
-// src/collector/history/historySettings.ts
-import { createHash as createHash3 } from "node:crypto";
-import os6 from "node:os";
-import path17 from "node:path";
-var HISTORY_ENV = "AGENT_LOOKOUT_HISTORY";
-var HISTORY_DIR_ENV = "AGENT_LOOKOUT_HISTORY_DIR";
-function readHistorySetup(env, homeDir = os6.homedir()) {
-  if (env[HISTORY_ENV]?.trim().toLowerCase() === "off") return { on: false };
-  const override = env[HISTORY_DIR_ENV]?.trim() || void 0;
-  const dir = path17.resolve(override ?? path17.join(homeDir, ".agent-lookout", "history"));
+// src/collector/remotes/remotes.ts
+var REMOTES_SETTING_SOURCE_ID = remoteSourceId("");
+function settingAdapter(problem, now) {
   return {
-    on: true,
-    dir,
-    folder: tildify(dir, homeDir),
-    sources: sourcesFingerprint(env, homeDir)
+    id: REMOTES_SETTING_SOURCE_ID,
+    label: "Other machines",
+    async poll() {
+      return {
+        health: {
+          id: REMOTES_SETTING_SOURCE_ID,
+          label: "Other machines",
+          state: "not-set-up",
+          detail: problem,
+          advice: `Correct ${REMOTES_ENV}, or unset it, and start Agent Lookout again. Until then no other machine is read and ssh is never run.`,
+          watching: [{ label: "Setting", value: REMOTES_ENV }],
+          checkedAt: now()
+        },
+        sessions: []
+      };
+    }
   };
 }
-function sourcesFingerprint(env, homeDir = os6.homedir()) {
-  const set = (name) => env[name]?.trim() || void 0;
-  const folders = [
-    path17.resolve(set(CLAUDE_HOME_ENV) ?? path17.join(homeDir, ".claude")),
-    path17.resolve(set(CODEX_HOME_ENV) ?? set(CODEX_OWN_HOME_ENV) ?? path17.join(homeDir, ".codex")),
-    path17.resolve(set(STATUS_DIR_ENV) ?? path17.join(homeDir, ".agent-lookout", "sessions"))
-  ];
-  return createHash3("sha256").update(JSON.stringify(folders)).digest("hex").slice(0, 32);
-}
-
-// src/collector/notifications/heldWait.ts
-var HANDOVER_GRACE_MS = 3e3;
-var PAGE_GONE_AFTER_MS = 5e3;
-function noPageReports(on) {
-  return { on, lastOnAt: null, lastOnSessionsAt: null };
-}
-function heldWaitOutcome(since, pages, now) {
-  if (!pages.on) return "drop";
-  if (pages.lastOnSessionsAt !== null && pages.lastOnSessionsAt > since) return "drop";
-  if (pages.lastOnAt === null || now - pages.lastOnAt > PAGE_GONE_AFTER_MS) return "show";
-  return now - since >= HANDOVER_GRACE_MS ? "show" : "hold";
+function createRemotes(options) {
+  const setup = readRemotesSetup(options.env);
+  const remotes = setup.on ? setup.remotes : [];
+  const waitingText2 = !waitingTextOff(options.env);
+  const tunnels = remotes.map(
+    (remote) => createTunnel({ remote, env: options.env, now: options.now, ...options.tunnels })
+  );
+  const adapters = remotes.map(
+    (remote, index) => createRemoteAdapter({
+      remote,
+      tunnel: tunnels[index],
+      version: options.version,
+      read: options.read,
+      now: options.now,
+      pollIntervalMs: options.pollIntervalMs,
+      waitingText: waitingText2
+    })
+  );
+  const problem = setup.on ? null : setup.problem;
+  return {
+    remotes,
+    adapters: problem === null ? adapters : [settingAdapter(problem, options.now ?? Date.now)],
+    problem,
+    start() {
+      for (const tunnel of tunnels) tunnel.start();
+    },
+    async stop() {
+      await Promise.all(tunnels.map((tunnel) => tunnel.stop()));
+    }
+  };
 }
 
-// src/collector/notifications/serverNotifications.ts
-var NOTIFICATIONS_ENV = "AGENT_LOOKOUT_NOTIFICATIONS";
-function notificationsOnAtStart(env) {
-  return env[NOTIFICATIONS_ENV]?.trim().toLowerCase() === "on";
+// src/collector/settings/settingsFile.ts
+import { randomBytes as randomBytes3 } from "node:crypto";
+import {
+  closeSync as closeSync2,
+  constants as constants5,
+  fstatSync as fstatSync2,
+  fsyncSync,
+  lstatSync as lstatSync2,
+  mkdirSync,
+  openSync as openSync2,
+  readSync as readSync2,
+  renameSync,
+  unlinkSync as unlinkSync2,
+  writeSync as writeSync2
+} from "node:fs";
+import os9 from "node:os";
+import path22 from "node:path";
+var SETTINGS_FILE_ENV = "AGENT_LOOKOUT_SETTINGS_FILE";
+var SETTINGS_FILE_MODE = 384;
+var SETTINGS_FOLDER_MODE = 448;
+var MAX_SETTINGS_BYTES = 64 * 1024;
+function readSettingsSetup(env, homeDir = os9.homedir()) {
+  const named = env[SETTINGS_FILE_ENV]?.trim() || void 0;
+  const file = path22.resolve(named ?? path22.join(homeDir, ".agent-lookout", "settings.json"));
+  return { file, shown: tildify(file, homeDir) };
+}
+var NO_FOLLOW2 = (constants5.O_NOFOLLOW ?? 0) | (constants5.O_NONBLOCK ?? 0);
+function codeOf(error) {
+  return error?.code;
 }
-var NOTIFICATIONS_NOT_SHOWN_LINE = `${NOTIFICATIONS_ENV} is on, but Agent Lookout shows notifications itself on macOS only, so it shows none here. A dashboard tab with notifications on still shows them.`;
-function notificationsAtStartLine(env, notifierShows) {
-  return notificationsOnAtStart(env) && !notifierShows ? NOTIFICATIONS_NOT_SHOWN_LINE : null;
+function kindAt(target) {
+  try {
+    const info = lstatSync2(target);
+    if (info.isSymbolicLink()) return "link";
+    if (info.isFile()) return "file";
+    return info.isDirectory() ? "folder" : "other";
+  } catch (error) {
+    if (codeOf(error) === "ENOENT" || codeOf(error) === "ENOTDIR") return null;
+    throw error;
+  }
 }
-function heldKey(event, sessionId) {
-  return `${event} ${sessionId}`;
+function syncFolder(folder) {
+  let fd = null;
+  try {
+    fd = openSync2(folder, constants5.O_RDONLY);
+    fsyncSync(fd);
+  } catch {
+  } finally {
+    if (fd !== null) closeSync2(fd);
+  }
 }
-function createServerNotifications(options) {
-  const { notifier } = options;
-  const now = options.now ?? Date.now;
-  let memory = EMPTY_CHANGE_MEMORY;
-  let pages = noPageReports(options.onAtStart);
-  let chosen = new Set(options.onAtStart ? DEFAULT_NOTICE_EVENTS : []);
-  const held = /* @__PURE__ */ new Map();
-  function show(change) {
-    try {
-      notifier.show(changeNotice(change));
-    } catch {
+function readSettingsText(setup) {
+  const { file, shown } = setup;
+  const folder = path22.dirname(file);
+  try {
+    const folderKind = kindAt(folder);
+    if (folderKind === null) return { kind: "missing" };
+    if (folderKind !== "folder") {
+      return {
+        kind: "refused",
+        problem: `The folder of ${shown} is a link or not a folder, which Agent Lookout does not follow, so the time rules are off.`
+      };
     }
+  } catch {
+    return { kind: "refused", problem: `${shown} could not be read, so the time rules are off.` };
   }
-  return {
-    pageSaid(said, fetchedSessions) {
-      const at = now();
-      chosen = new Set(said);
-      if (said.length === 0) {
-        pages = { ...pages, on: false };
-        return;
-      }
-      pages = {
-        on: true,
-        lastOnAt: at,
-        lastOnSessionsAt: fetchedSessions ? at : pages.lastOnSessionsAt
+  let fd;
+  try {
+    fd = openSync2(file, constants5.O_RDONLY | NO_FOLLOW2);
+  } catch (error) {
+    const code = codeOf(error);
+    if (code === "ENOENT") return { kind: "missing" };
+    if (code === "ELOOP") {
+      return {
+        kind: "refused",
+        problem: `${shown} is a link, which Agent Lookout does not follow, so the time rules are off.`
       };
-    },
-    handle(snapshot) {
-      const at = now();
-      const result = sessionChanges(memory, snapshot);
-      memory = result.memory;
-      for (const id of result.stopped) held.delete(heldKey("needs-you", id));
-      for (const change of result.changes) {
-        if (pages.on && chosen.has(change.event)) {
-          held.set(heldKey(change.event, change.session.id), { change, since: at });
-        }
-      }
-      const listed = new Map(snapshot.sessions.map((session) => [session.id, session]));
-      for (const entry of held.values()) {
-        const current = listed.get(entry.change.session.id);
-        if (entry.change.event === "needs-you" && current?.status === "needs-you") {
-          entry.change = { ...entry.change, session: current };
-        }
-      }
-      for (const [key, { change, since }] of held) {
-        const outcome = chosen.has(change.event) ? heldWaitOutcome(since, pages, at) : "drop";
-        if (outcome === "hold") continue;
-        held.delete(key);
-        if (outcome === "show") show(change);
-      }
     }
-  };
+    return { kind: "refused", problem: `${shown} could not be read, so the time rules are off.` };
+  }
+  try {
+    const info = fstatSync2(fd);
+    if (!info.isFile()) {
+      return {
+        kind: "refused",
+        problem: `${shown} is not an ordinary file, so the time rules are off.`
+      };
+    }
+    if (info.size > MAX_SETTINGS_BYTES) {
+      return {
+        kind: "refused",
+        problem: `${shown} is larger than 64 KB, so it was not read and the time rules are off.`
+      };
+    }
+    const buffer = Buffer.alloc(info.size);
+    let filled = 0;
+    while (filled < buffer.byteLength) {
+      const read = readSync2(fd, buffer, filled, buffer.byteLength - filled, filled);
+      if (read === 0) break;
+      filled += read;
+    }
+    return { kind: "read", text: buffer.toString("utf8", 0, filled) };
+  } catch {
+    return { kind: "refused", problem: `${shown} could not be read, so the time rules are off.` };
+  } finally {
+    closeSync2(fd);
+  }
 }
-
-// src/collector/processes/osascript.ts
-import { execFile as execFile3 } from "node:child_process";
-var OSASCRIPT = "/usr/bin/osascript";
-var MAX_OUTPUT_BYTES4 = 64 * 1024;
-var NOT_RUN2 = { ok: false, stderr: "", timedOut: false };
-function runOsascript(args, options = {}) {
-  return new Promise((resolve) => {
+function writeSettingsText(setup, text4) {
+  const { file, shown } = setup;
+  const folder = path22.dirname(file);
+  const notSaved = {
+    ok: false,
+    problem: `${shown} could not be written, so the change was not saved.`
+  };
+  let temporary = null;
+  try {
+    mkdirSync(folder, { recursive: true, mode: SETTINGS_FOLDER_MODE });
+    if (kindAt(folder) !== "folder") {
+      return {
+        ok: false,
+        problem: `The folder of ${shown} is a link or not a folder, which Agent Lookout does not write through, so the change was not saved.`
+      };
+    }
+    const there = kindAt(file);
+    if (there !== null && there !== "file") {
+      return {
+        ok: false,
+        problem: `${shown} is a link or not an ordinary file, which Agent Lookout does not write through, so the change was not saved.`
+      };
+    }
+    temporary = path22.join(
+      folder,
+      `.${path22.basename(file)}.${process.pid}.${randomBytes3(6).toString("hex")}.tmp`
+    );
+    const fd = openSync2(
+      temporary,
+      constants5.O_WRONLY | constants5.O_CREAT | constants5.O_EXCL | NO_FOLLOW2,
+      SETTINGS_FILE_MODE
+    );
     try {
-      const child = execFile3(
-        OSASCRIPT,
-        [...args],
-        {
-          timeout: options.timeoutMs ?? TERMINAL_JUMP_TIMEOUT_MS,
-          maxBuffer: MAX_OUTPUT_BYTES4,
-          encoding: "utf8",
-          windowsHide: true
-        },
-        (error, stdout, stderr) => {
-          if (!error) {
-            resolve({ ok: true, stdout: String(stdout ?? "") });
-            return;
-          }
-          const timedOut = error.killed === true;
-          resolve({ ok: false, stderr: String(stderr ?? "").trim(), timedOut });
-        }
-      );
-      child.stdin?.end();
-    } catch {
-      resolve(NOT_RUN2);
+      writeSync2(fd, text4);
+      fsyncSync(fd);
+    } finally {
+      closeSync2(fd);
     }
-  });
+    renameSync(temporary, file);
+    temporary = null;
+    syncFolder(folder);
+    return { ok: true };
+  } catch {
+    return notSaved;
+  } finally {
+    if (temporary !== null) {
+      try {
+        unlinkSync2(temporary);
+      } catch {
+      }
+    }
+  }
 }
 
-// src/collector/notifications/systemNotifier.ts
-var OSASCRIPT_TIMEOUT_MS = 5e3;
-var SCRIPT = [
-  "on run argv",
-  "display notification (item 2 of argv) with title (item 1 of argv)",
-  "end run"
-];
-function osascriptArgs(notice) {
-  return [
-    ...SCRIPT.flatMap((line) => ["-e", line]),
-    "--",
-    oneLine(notice.title),
-    oneLine(notice.body, MAX_NOTICE_TEXT_LENGTH)
-  ];
+// src/collector/settings/collectorSettings.ts
+var fileSettingsStore = {
+  read: readSettingsText,
+  write: writeSettingsText
+};
+var RULE_WORDS = {
+  longWait: "the long wait reminder",
+  idle: "the idle rule",
+  quietHours: "the quiet hours"
+};
+function isRecord12(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function systemNotificationsShownOn(platform) {
-  return platform === "darwin";
+function listOf(names) {
+  const words = names.map((name) => RULE_WORDS[name]);
+  return words.length <= 1 ? words[0] ?? "" : `${words.slice(0, -1).join(", ")} and ${words[words.length - 1]}`;
 }
-var runForNotification = (args) => runOsascript(args, { timeoutMs: OSASCRIPT_TIMEOUT_MS });
-function createSystemNotifier(options = {}) {
-  const platform = options.platform ?? process.platform;
-  const run = options.run ?? runForNotification;
+function rulesIn(read, shown) {
+  const off = readTimeRules(void 0).rules;
+  if (read.kind === "missing") {
+    return { rules: off, rest: {}, otherRules: {}, problem: null, writable: true };
+  }
+  if (read.kind === "refused") {
+    return { rules: off, rest: {}, otherRules: {}, problem: read.problem, writable: false };
+  }
+  let value;
+  try {
+    value = JSON.parse(read.text);
+  } catch {
+    value = null;
+  }
+  if (!isRecord12(value)) {
+    return {
+      rules: off,
+      rest: {},
+      otherRules: {},
+      problem: `${shown} is not JSON that Agent Lookout can read, so the time rules are off. Changing one in Settings writes the file again.`,
+      writable: true
+    };
+  }
+  const { timeRules, ...rest } = value;
+  const { rules, unread } = readTimeRules(timeRules);
+  const otherRules = isRecord12(timeRules) ? Object.fromEntries(
+    Object.entries(timeRules).filter(
+      ([name]) => !TIME_RULE_NAMES.includes(name)
+    )
+  ) : {};
+  const problem = unread.length === 0 ? null : `${shown} holds ${listOf(unread)} in a form Agent Lookout cannot read, so ${unread.length === 1 ? "it is" : "they are"} off.`;
+  return { rules, rest, otherRules, problem, writable: true };
+}
+function createCollectorSettings(options) {
+  const { setup } = options;
+  const store = options.store ?? fileSettingsStore;
+  const first = rulesIn(store.read(setup), setup.shown);
+  let rules = first.rules;
+  const { rest, otherRules } = first;
+  let problem = first.problem;
   return {
-    show(notice) {
-      if (!systemNotificationsShownOn(platform)) return;
-      try {
-        run(osascriptArgs(notice)).catch(() => {
-        });
-      } catch {
+    timeRules: () => rules,
+    status: () => ({ timeRules: rules, file: setup.shown, problem }),
+    changeTimeRules(next) {
+      if (!first.writable) {
+        return {
+          ok: false,
+          problem: `${setup.shown} could not be read when Agent Lookout started, so it is not written over and the change was not saved. Mend or remove the file, then start Agent Lookout again.`
+        };
+      }
+      const text4 = `${JSON.stringify({ ...rest, timeRules: { ...otherRules, ...next } }, null, 2)}
+`;
+      const written = store.write(setup, text4);
+      if (!written.ok) {
+        problem = written.problem;
+        return written;
       }
+      rules = next;
+      problem = null;
+      return written;
+    },
+    problemAtStart: first.problem
+  };
+}
+
+// src/collector/settings/timeRulesRoute.ts
+var MAX_TIME_RULES_BODY_BYTES = 2048;
+var failed3 = (status, reason, error) => ({
+  status,
+  body: { error, reason }
+});
+function timeRulesRefusalFor(req) {
+  return actionRefusalFor(req, TIME_RULES_ACTION, MAX_TIME_RULES_BODY_BYTES);
+}
+function createTimeRulesRoute(options) {
+  const { settings } = options;
+  return async function answerTimeRules(req) {
+    const refused = timeRulesRefusalFor(req);
+    if (refused) {
+      req.resume();
+      return refused;
+    }
+    const body = await readRequestBody(req, MAX_TIME_RULES_BODY_BYTES);
+    if (!body.ok) {
+      req.resume();
+      return body.tooLarge ? refusal(413, `The body must be no more than ${MAX_TIME_RULES_BODY_BYTES} bytes.`) : refusal(400, "The body could not be read.");
+    }
+    let value;
+    try {
+      value = JSON.parse(body.text);
+    } catch {
+      return failed3(400, "invalid", "The body must be JSON: the three time rules.");
     }
+    const asked = timeRulesIn(value);
+    if (!asked.ok) return failed3(400, "invalid", asked.problem);
+    const saved = settings.changeTimeRules(asked.rules);
+    if (!saved.ok) return failed3(500, "not-saved", saved.problem);
+    return {
+      status: 200,
+      body: { ok: true, timeRules: asked.rules }
+    };
   };
 }
 
@@ -7126,11 +9584,11 @@ function createOsascriptRunner(options) {
 }
 
 // src/collector/terminal/tabFinder.ts
-import os7 from "node:os";
+import os10 from "node:os";
 var TAB_LOOK_SOONEST_MS = 5e3;
 function createTabFinder(options) {
   const off = terminalJumpOff(options.env);
-  const homeDir = options.homeDir ?? os7.homedir();
+  const homeDir = options.homeDir ?? os10.homedir();
   const readProcesses = options.readProcesses ?? readProcessTableWithPs;
   const now = options.now ?? Date.now;
   const soonestMs = options.soonestMs ?? TAB_LOOK_SOONEST_MS;
@@ -7408,14 +9866,14 @@ function createHttpSender(settings, options) {
   const timeoutMs = options.timeoutMs ?? WEBHOOK_TIMEOUT_MS;
   let client = null;
   const load = () => {
-    client ??= url.protocol === "https:" ? import("node:https").then(({ request }) => request) : import("node:http").then(({ request }) => request);
+    client ??= url.protocol === "https:" ? import("node:https").then(({ request: request2 }) => request2) : import("node:http").then(({ request: request2 }) => request2);
     return client;
   };
   return {
     async send(post) {
-      let request;
+      let request2;
       try {
-        request = await load();
+        request2 = await load();
       } catch {
         return { sent: false, reason: "the post could not be sent" };
       }
@@ -7430,7 +9888,7 @@ function createHttpSender(settings, options) {
         let req;
         try {
           body = JSON.stringify(post);
-          req = request(url, requestOptions(body, options.version));
+          req = request2(url, requestOptions(body, options.version));
         } catch {
           finish({ sent: false, reason: "the post could not be sent" });
           return;
@@ -7515,6 +9973,11 @@ function createCollector(options) {
   const env = options.env ?? process.env;
   const intervalMs = options.intervalMs ?? POLL_INTERVAL_MS;
   const warn = options.warn ?? console.error;
+  const settings = createCollectorSettings({
+    setup: readSettingsSetup(env),
+    store: options.settingsStore
+  });
+  if (settings.problemAtStart !== null) warn(settings.problemAtStart);
   const memoryEvents = createEventStore();
   const memoryHistory = createHistoryStore();
   const historySetup = readHistorySetup(env);
@@ -7585,34 +10048,46 @@ function createCollector(options) {
   if (!webhookSetup.on && webhookSetup.problem !== null) {
     warn(webhookProblemLine(webhookSetup.problem));
   }
-  const createWebhookSender = options.createWebhookSender ?? ((settings) => createHttpSender(settings, { version: options.version }));
+  const createWebhookSender = options.createWebhookSender ?? ((settings2) => createHttpSender(settings2, { version: options.version }));
   const webhook = webhookSetup.on ? createWebhookNotifications({
     settings: webhookSetup.settings,
     sender: createWebhookSender(webhookSetup.settings),
     now
   }) : null;
   const webhookOff = webhookOffStatus(webhookSetup.on ? null : webhookSetup.problem);
+  const remotes = createRemotes({
+    env,
+    version: options.version,
+    now,
+    pollIntervalMs: intervalMs,
+    ...options.remotes
+  });
+  if (remotes.problem !== null) warn(remotesProblemLine(remotes.problem));
+  const localAdapters = options.adapters ?? [
+    createClaudeCodeAdapter({
+      env: options.env,
+      now,
+      pollIntervalMs: intervalMs,
+      panes,
+      terminals: tabs,
+      readProcessStarts: options.readProcessStarts,
+      stops: stopTargets
+    }),
+    createCodexAdapter({ env: options.env, now, pollIntervalMs: intervalMs }),
+    createStatusFileAdapter({ env: options.env, now, pollIntervalMs: intervalMs })
+  ];
   const poller = createPoller({
     // Each adapter is told how often it will be polled so that it can say so.
-    adapters: options.adapters ?? [
-      createClaudeCodeAdapter({
-        env: options.env,
-        now,
-        pollIntervalMs: intervalMs,
-        panes,
-        terminals: tabs,
-        readProcessStarts: options.readProcessStarts,
-        stops: stopTargets
-      }),
-      createCodexAdapter({ env: options.env, now, pollIntervalMs: intervalMs }),
-      createStatusFileAdapter({ env: options.env, now, pollIntervalMs: intervalMs })
-    ],
+    // The other machines come after this one's own sources.
+    adapters: [...localAdapters, ...remotes.adapters],
     events,
     history,
     intervalMs,
     now,
     // Every source's sessions alike are given the branch of their folder, and
     // with pull requests on, the branch's pull request, as last learnt.
+    // Every snapshot carries the time rules in force, and is stale by them.
+    timeRules: () => settings.timeRules(),
     annotate: async (sessions) => {
       const onBranches = await branches.annotate(sessions);
       return pullRequests ? pullRequests.annotate(onBranches) : onBranches;
@@ -7620,12 +10095,15 @@ function createCollector(options) {
     // The poller runs for as long as the app does, with a dashboard open or
     // not, so a wait that begins with no page open is still seen here.
     onSnapshot: (snapshot) => {
+      answering?.observe(snapshot);
       email?.handle(snapshot);
       webhook?.handle(snapshot);
       notifications.handle(snapshot);
       options.onSnapshot?.(snapshot);
     }
   });
+  const answers2 = options.adapters === void 0 || options.answering !== void 0;
+  const answering = answers2 ? createAnswering({ env, poller, events, now, warn, ...options.answering }) : null;
   const stopper = createStopper({
     env,
     now,
@@ -7638,11 +10116,14 @@ function createCollector(options) {
     events,
     targets: stopTargets,
     stopper,
-    limiter: createActionLimiter(now)
+    limiter: createActionLimiter(now),
+    staleAfterMs: () => staleAfterMs(settings.timeRules())
   };
   const handler = createApiHandler({
     version: options.version,
     poller,
+    serveSnapshot: answering ? (snapshot) => answering.serve(snapshot) : void 0,
+    answer: answering?.route,
     events,
     history,
     notifications,
@@ -7652,6 +10133,8 @@ function createCollector(options) {
     jump: createJumpRoute({ poller, panes, run: tmux, tabs, osascript, now }),
     stop: stopRoutes && createStopRoute(stopRoutes),
     cleanUp: stopRoutes && createCleanUpRoute(stopRoutes),
+    settings: () => settings.status(),
+    timeRules: createTimeRulesRoute({ settings }),
     clearHistory: createClearHistoryRoute({
       keeper,
       forget: () => {
@@ -7681,6 +10164,7 @@ function createCollector(options) {
     now
   });
   let running = false;
+  let answerStart = null;
   let restored = keeper === null;
   let restoring = null;
   let restarts = [];
@@ -7699,6 +10183,8 @@ function createCollector(options) {
     start() {
       if (running) return;
       running = true;
+      answerStart ??= answering?.start() ?? Promise.resolve();
+      remotes.start();
       if (restored || keeper === null) {
         begin();
         return;
@@ -7724,13 +10210,24 @@ function createCollector(options) {
       running = false;
       poller.stop();
       keeper?.stop();
+      answerStart = null;
+      void answering?.stop();
+      void remotes.stop();
     },
     handler,
     poller,
     email,
     webhook,
     pullRequests,
-    history: keeper
+    history: keeper,
+    answering: {
+      start: () => answerStart ??= answering?.start() ?? Promise.resolve(),
+      stop: async () => {
+        await answering?.stop();
+      }
+    },
+    remotes,
+    settings
   };
 }
 
@@ -7751,7 +10248,7 @@ async function runStandalone(options) {
   } catch (error) {
     return stopWith(error.message);
   }
-  if (!existsSync(path18.join(distDir, "index.html"))) {
+  if (!existsSync(path23.join(distDir, "index.html"))) {
     return stopWith(
       "The dashboard has not been built yet. Run `npm run build`, then start it again."
     );
@@ -7793,7 +10290,7 @@ async function runStandalone(options) {
 }
 
 // src/cli/start/openBrowser.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 var OPEN_WAIT_MS = 1e4;
 function openCommand(platform, url) {
   const address = loopbackAddress(url);
@@ -7810,7 +10307,7 @@ function runProgram2(file, args, waitMs = OPEN_WAIT_MS) {
       resolve(opened);
     };
     try {
-      const child = spawn2(file, [...args], { stdio: "ignore", detached: true });
+      const child = spawn3(file, [...args], { stdio: "ignore", detached: true });
       child.once("error", () => settle(false));
       child.once("exit", (code) => settle(code === 0));
       child.unref();