agent-lookout 0.2.6 → 0.2.8

package/dist/cli/{startCommand-PR5JPWCT.js → startCommand-ANC7NVAO.js}

@@ -217,6 +217,9 @@ var MAX_HOST_LENGTH = 253;
 function isWebhookHost(host) {
   return host.length <= MAX_HOST_LENGTH && WEBHOOK_HOST.test(host);
 }
+var PHONE_CHANNELS = ["ntfy", "pushover"];
+var PHONE_TEST_PATH = "/api/phone/test";
+var PHONE_TEST_ACTION = "phone-test";
 
 // src/core/history.ts
 var DEFAULT_HISTORY_WINDOW_MS = 15 * 60 * 1e3;
@@ -254,10 +257,30 @@ function createQuietHold() {
       const last = lastWaitOf(session.id);
       if (last?.begunAt === begunAt) {
         last.endedAt = null;
+        last.reminderOnly = false;
         return;
       }
       if (last && last.endedAt === null) last.endedAt = begunAt;
-      waits.push({ session: withoutWaitingText(session), begunAt, endedAt: null });
+      waits.push({
+        session: withoutWaitingText(session),
+        begunAt,
+        endedAt: null,
+        reminderOnly: false
+      });
+    },
+    holdReminder(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,
+        reminderOnly: true
+      });
     },
     holdOver(event, session, at) {
       over.push({ event, session: withoutWaitingText(session), at });
@@ -279,6 +302,7 @@ function createQuietHold() {
       }
       const open2 = [];
       for (const [id, wait] of stillOpen) {
+        if (wait.reminderOnly) continue;
         open2.push({ session: listed.get(id), begunAt: wait.begunAt });
       }
       const answered = /* @__PURE__ */ new Map();
@@ -336,6 +360,7 @@ var DAY_MS = 24 * HOUR_MS;
 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 REPEAT_MINUTES = { min: 5, max: 1440, default: 30 };
 var IDLE_HOURS = { min: 1, max: 720, default: 48 };
 var DEFAULT_TIME_RULES = {
   longWait: { on: false, minutes: LONG_WAIT_MINUTES.default },
@@ -365,12 +390,22 @@ function holds(value, keys, exact2) {
 function wholeNumberIn(value, range) {
   return Number.isSafeInteger(value) && value >= range.min && value <= range.max;
 }
-function readLongWait(value, exact2) {
+function readRepeat(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;
+  if (typeof on !== "boolean" || !wholeNumberIn(minutes, REPEAT_MINUTES)) return null;
   return { on, minutes };
 }
+function readLongWait(value, exact2) {
+  if (!isRecord(value)) return null;
+  const keys = value.repeat === void 0 ? ["on", "minutes"] : ["on", "minutes", "repeat"];
+  if (!holds(value, keys, exact2)) return null;
+  const { on, minutes } = value;
+  if (typeof on !== "boolean" || !wholeNumberIn(minutes, LONG_WAIT_MINUTES)) return null;
+  if (value.repeat === void 0) return { on, minutes };
+  const repeat = readRepeat(value.repeat, exact2);
+  return repeat === null ? null : { on, minutes, repeat };
+}
 function readIdle(value, exact2) {
   if (!isRecord(value) || !holds(value, ["on", "hours"], exact2)) return null;
   const { on, hours } = value;
@@ -402,7 +437,7 @@ var READERS = {
   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}.`,
+  longWait: `longWait must be {"on", "minutes"}, with minutes a whole number from ${LONG_WAIT_MINUTES.min} to ${LONG_WAIT_MINUTES.max}, and may have "repeat", {"on", "minutes"} with minutes a whole number from ${REPEAT_MINUTES.min} to ${REPEAT_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.'
 };
@@ -467,6 +502,18 @@ function quietOf(snapshot) {
 }
 
 // src/core/time-rules/reminders.ts
+var MINUTE_MS = 6e4;
+function reminderSchedule(rule) {
+  return {
+    thresholdMs: rule.minutes * MINUTE_MS,
+    everyMs: rule.repeat?.on ? rule.repeat.minutes * MINUTE_MS : null
+  };
+}
+function reminderNumber(waitedMs, schedule) {
+  if (waitedMs < schedule.thresholdMs) return -1;
+  if (schedule.everyMs === null) return 0;
+  return Math.floor((waitedMs - schedule.thresholdMs) / schedule.everyMs);
+}
 function readable(snapshot) {
   return new Set(
     snapshot.sources.filter((source) => source.state === "ok" || source.state === "not-set-up").map((source) => source.id)
@@ -485,29 +532,33 @@ function createReminderWatch() {
         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()
+          seenAfterMs: since === null ? 0 : at - since,
+          toldAfterMs: null
         });
       }
     },
-    due(snapshot, at, thresholdMs, eligible = () => true) {
+    due(snapshot, at, schedule, eligible = () => true) {
       const found = [];
       for (const session of snapshot.sessions) {
         if (!needsYou(session)) continue;
         const wait = watched.get(session.id);
-        if (!wait || wait.reminded.has(thresholdMs) || !eligible(session.id)) continue;
+        if (!wait || !eligible(session.id)) continue;
         const waitedMs = at - wait.begunAt;
-        if (waitedMs < thresholdMs || wait.firstSeenAfterMs >= thresholdMs) continue;
-        found.push({ session, begunAt: wait.begunAt, waitedMs });
+        const repeat = reminderNumber(waitedMs, schedule);
+        if (repeat < 0 || repeat <= reminderNumber(wait.seenAfterMs, schedule)) continue;
+        const told = wait.toldAfterMs;
+        if (told !== null && repeat <= reminderNumber(told, schedule)) continue;
+        const { thresholdMs, everyMs } = schedule;
+        if (told !== null && everyMs !== null && repeat > 0) {
+          if (thresholdMs + repeat * everyMs - told < everyMs / 2) continue;
+        }
+        found.push({ session, begunAt: wait.begunAt, waitedMs, repeat });
       }
       return found;
     },
-    reminded(sessionId, thresholdMs) {
-      watched.get(sessionId)?.reminded.add(thresholdMs);
-    },
-    toldLate(sessionId, at, thresholdMs) {
+    told(sessionId, at) {
       const wait = watched.get(sessionId);
-      if (wait && at - wait.begunAt >= thresholdMs) wait.reminded.add(thresholdMs);
+      if (wait) wait.toldAfterMs = Math.max(wait.toldAfterMs ?? 0, at - wait.begunAt);
     },
     clear() {
       watched.clear();
@@ -535,7 +586,7 @@ function waitBegan(statusSince, seenAt) {
 
 // src/collector/outbound/outboundChannel.ts
 function createOutboundChannel(options) {
-  const { afterMs, asking, waitMessage, overMessage, reminderMessage, summaryMessage, failure: failure2 } = options;
+  const { afterMs, asking, waitMessage: waitMessage2, overMessage: overMessage2, reminderMessage: reminderMessage2, summaryMessage: summaryMessage2, failure: failure2 } = options;
   const now = options.now ?? Date.now;
   const wanted = new Set(options.events);
   let memory = EMPTY_CHANGE_MEMORY;
@@ -547,15 +598,26 @@ function createOutboundChannel(options) {
   const hold = createQuietHold();
   let last = null;
   let queue = Promise.resolve();
-  function send2(content) {
-    queue = queue.then(() => options.send(content)).then(
-      (outcome) => {
-        last = outcome.sent ? { at: now(), sent: true } : { at: now(), sent: false, reason: outcome.reason };
-      },
-      () => {
-        last = { at: now(), sent: false, reason: failure2 };
-      }
+  function tryInTurn(content, after = () => {
+  }) {
+    const tried = queue.then(() => options.send(content)).then(
+      (outcome) => outcome,
+      // A sender should not reject. One that does is a failure like any other.
+      () => ({ sent: false, reason: failure2 })
+    ).then((outcome) => {
+      after(outcome);
+      return outcome;
+    });
+    queue = tried.then(
+      () => void 0,
+      () => void 0
     );
+    return tried;
+  }
+  function send2(content) {
+    void tryInTurn(content, (outcome) => {
+      last = outcome.sent ? { at: now(), sent: true } : { at: now(), sent: false, reason: outcome.reason };
+    });
   }
   return {
     handle(snapshot) {
@@ -578,7 +640,7 @@ function createOutboundChannel(options) {
               ...item,
               agent: agentName(item.session, snapshot.sources)
             }));
-            ready.push((sentNow) => summaryMessage({ ...summary, items, now: sentNow }));
+            ready.push((sentNow) => summaryMessage2({ ...summary, items, now: sentNow }));
           }
           for (const { session, begunAt } of end.open) open2.set(session.id, begunAt);
         }
@@ -596,7 +658,7 @@ function createOutboundChannel(options) {
               agent: agentName(session, snapshot.sources),
               seenAt: at
             };
-            ready.push((sentNow) => overMessage({ ...facts, now: sentNow }));
+            ready.push((sentNow) => overMessage2({ ...facts, now: sentNow }));
             continue;
           }
           const since = session.statusSince;
@@ -609,7 +671,7 @@ function createOutboundChannel(options) {
           sentAt.push(at);
           send2(write(at));
         }
-        const thresholdMs = rules.longWait.minutes * 6e4;
+        const schedule = reminderSchedule(rules.longWait);
         for (const [id, begunAt] of open2) {
           const session = snapshot.sessions.find(
             (candidate) => candidate.id === id && needsYou(candidate)
@@ -626,7 +688,7 @@ function createOutboundChannel(options) {
           open2.delete(id);
           sentAt.push(at);
           send2(
-            waitMessage({
+            waitMessage2({
               session: withoutWaitingText(session),
               agent: agentName(session, snapshot.sources),
               // Read now, from this poll's snapshot, and only when it is to go.
@@ -635,21 +697,27 @@ function createOutboundChannel(options) {
               now: at
             })
           );
-          if (rules.longWait.on) reminders.toldLate(id, at, thresholdMs);
+          if (rules.longWait.on) reminders.told(id, at);
         }
-        if (!quiet && rules.longWait.on && wanted.has("needs-you")) {
-          for (const due of reminders.due(snapshot, at, thresholdMs, (id) => !open2.has(id))) {
+        if (rules.longWait.on && wanted.has("needs-you")) {
+          for (const due of reminders.due(snapshot, at, schedule, (id) => !open2.has(id))) {
+            if (quiet) {
+              hold.holdReminder(due.session, due.begunAt);
+              continue;
+            }
             if (limitLiftsAt(sentAt, at) !== null) break;
             sentAt.push(at);
-            reminders.reminded(due.session.id, thresholdMs);
+            reminders.told(due.session.id, at);
             send2(
-              reminderMessage({
+              reminderMessage2({
                 session: withoutWaitingText(due.session),
                 agent: agentName(due.session, snapshot.sources),
                 asking: asking ? waitingText(due.session.waitingText) ?? null : null,
                 begunAt: due.begunAt,
                 now: at,
-                thresholdMs
+                thresholdMs: schedule.thresholdMs,
+                everyMs: schedule.everyMs,
+                repeat: due.repeat
               })
             );
           }
@@ -664,14 +732,22 @@ function createOutboundChannel(options) {
     },
     last: () => last,
     limitedUntil: () => limitLiftsAt(sentAt, now()),
-    settled: () => queue
+    settled: () => queue,
+    async test(content) {
+      const at = now();
+      sentAt = sendsInLastHour(sentAt, at);
+      const limitedUntil = limitLiftsAt(sentAt, at);
+      if (limitedUntil !== null) return { tried: false, limitedUntil };
+      sentAt.push(at);
+      return { tried: true, at, outcome: await tryInTurn(content) };
+    }
   };
 }
 
 // src/core/time-rules/timeRulesWords.ts
-var MINUTE_MS = 6e4;
+var MINUTE_MS2 = 6e4;
 function waitedInWords(ms) {
-  if (ms < MINUTE_MS) return "under a minute";
+  if (ms < MINUTE_MS2) return "under a minute";
   return partsInWords(durationParts(ms).filter((part) => part.unit !== "s"));
 }
 var WAITED_FOR = {
@@ -873,9 +949,10 @@ function waitEmail(facts) {
 }
 function reminderEmail(facts) {
   const { session, begunAt, now } = facts;
+  const again = facts.everyMs === null ? "" : `, and again every ${waitedInWords(facts.everyMs)} while it goes on`;
   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.`,
+    `It has waited since ${clockAt(begunAt, now)}. Agent Lookout reminds you once a wait lasts ${waitedInWords(facts.thresholdMs)}${again}, as Time rules in Settings says.`,
     session,
     facts.agent,
     facts.asking
@@ -1231,6 +1308,116 @@ function pullRequestsOffStatus(problem) {
   return { on: false, problem, gh: null, last: null };
 }
 
+// src/collector/outbound/phoneMessage.ts
+var MAX_PHONE_TITLE = 250;
+var MAX_PHONE_MESSAGE = 1024;
+function isWaitKind(kind) {
+  return kind === "needs-you" || kind === "reminder" || kind === "test";
+}
+function cutTo(text4, max) {
+  const characters = Array.from(text4);
+  if (characters.length <= max) return text4;
+  return `${characters.slice(0, max - 1).join("").trimEnd()}\u2026`;
+}
+function phoneMessage(kind, title, lines) {
+  const said = lines.filter((line) => line !== "");
+  return {
+    kind,
+    title: cutTo(title, MAX_PHONE_TITLE),
+    message: cutTo(said.length > 0 ? said.join("\n") : title, MAX_PHONE_MESSAGE)
+  };
+}
+function factsLine(first, session, agent) {
+  const facts = [
+    first,
+    session.project ? oneLine(session.project) : "",
+    surfaceLabel(session.surface) ?? "",
+    agent ? oneLine(agent) : ""
+  ];
+  return facts.filter((fact) => fact !== "").join(" \xB7 ");
+}
+function askingLine(asking) {
+  const said = waitingText(asking);
+  return said ? `Asking: ${said}` : "";
+}
+function waitMessage(facts) {
+  const { session, begunAt, now } = facts;
+  return phoneMessage("needs-you", `${oneLine(sessionTitle(session))} ${waitingPhrase(session)}`, [
+    askingLine(facts.asking),
+    factsLine(formatDuration(Math.max(0, now - begunAt)), session, facts.agent)
+  ]);
+}
+function reminderMessage(facts) {
+  const { session, begunAt, now } = facts;
+  return phoneMessage("reminder", reminderSentence(session, now - begunAt), [
+    askingLine(facts.asking),
+    factsLine(`Since ${clockAt(begunAt, now)}`, session, facts.agent)
+  ]);
+}
+function summaryMessage(facts) {
+  return phoneMessage("quiet-summary", WHILE_QUIET, [summaryLine(facts.items)]);
+}
+function overMessage(facts) {
+  const { session, seenAt, now } = facts;
+  return phoneMessage(facts.event, `${oneLine(sessionTitle(session))} ${overPhrase(facts.event)}`, [
+    factsLine(`Seen at ${clockAt(seenAt, now)}`, session, facts.agent)
+  ]);
+}
+function testMessage() {
+  return phoneMessage("test", "Agent Lookout test", [
+    "Pushes from Agent Lookout reach this device."
+  ]);
+}
+
+// src/collector/ntfy/ntfyNotifications.ts
+function ntfyOffStatus(problem) {
+  return {
+    on: false,
+    host: null,
+    tokenSet: null,
+    events: null,
+    afterMs: null,
+    asking: null,
+    problem,
+    last: null,
+    limitedUntil: null
+  };
+}
+function createNtfyNotifications(options) {
+  const { settings, sender } = options;
+  const channel = createOutboundChannel({
+    events: settings.events,
+    afterMs: settings.afterMs,
+    asking: settings.asking,
+    waitMessage,
+    overMessage,
+    reminderMessage,
+    summaryMessage,
+    send: (message) => sender.send(message),
+    failure: "the push could not be sent",
+    now: options.now
+  });
+  return {
+    handle: (snapshot) => channel.handle(snapshot),
+    status() {
+      return {
+        on: true,
+        // The host alone. The topic is the secret anyone could read the pushes with.
+        host: settings.server.hostname,
+        tokenSet: settings.token !== null,
+        events: [...settings.events],
+        afterMs: settings.afterMs,
+        asking: settings.asking,
+        problem: null,
+        last: channel.last(),
+        limitedUntil: channel.limitedUntil()
+      };
+    },
+    test: () => channel.test(testMessage()),
+    settled: () => channel.settled()
+  };
+}
+
 // src/core/sessions/diff.ts
 function severityFor(to) {
   if (to === "needs-you") return "warning";
@@ -1583,6 +1770,50 @@ function createPoller(options) {
   };
 }
 
+// src/collector/pushover/pushoverNotifications.ts
+function pushoverOffStatus(problem) {
+  return {
+    on: false,
+    events: null,
+    afterMs: null,
+    asking: null,
+    problem,
+    last: null,
+    limitedUntil: null
+  };
+}
+function createPushoverNotifications(options) {
+  const { settings, sender } = options;
+  const channel = createOutboundChannel({
+    events: settings.events,
+    afterMs: settings.afterMs,
+    asking: settings.asking,
+    waitMessage,
+    overMessage,
+    reminderMessage,
+    summaryMessage,
+    send: (message) => sender.send(message),
+    failure: "the push could not be sent",
+    now: options.now
+  });
+  return {
+    handle: (snapshot) => channel.handle(snapshot),
+    status() {
+      return {
+        on: true,
+        events: [...settings.events],
+        afterMs: settings.afterMs,
+        asking: settings.asking,
+        problem: null,
+        last: channel.last(),
+        limitedUntil: channel.limitedUntil()
+      };
+    },
+    test: () => channel.test(testMessage()),
+    settled: () => channel.settled()
+  };
+}
+
 // src/collector/webhook/webhookMessage.ts
 var MAX_SUMMARY_ITEMS = 100;
 function slackSafe(text4) {
@@ -1634,7 +1865,9 @@ function reminderPost(facts) {
       post.session.app,
       post.session.agent
     ]),
-    reminder: true
+    reminder: true,
+    // Left out on the first, so its post is the post it always was.
+    ...facts.repeat > 0 && { repeat: facts.repeat }
   };
 }
 function summaryPost(facts) {
@@ -1856,6 +2089,7 @@ function createApiHandler(options) {
   if (options.answer) actions.set(ANSWER_PATH, options.answer);
   if (options.timeRules) actions.set(TIME_RULES_PATH, options.timeRules);
   if (options.permissionRules) actions.set(PERMISSION_RULES_PATH, options.permissionRules);
+  if (options.phoneTest) actions.set(PHONE_TEST_PATH, options.phoneTest);
   const serveSnapshot = options.serveSnapshot ?? ((snapshot) => snapshot);
   function route(req, res) {
     const refusal3 = refusalFor(req);
@@ -1918,6 +2152,22 @@ function createApiHandler(options) {
         );
         return;
       }
+      case "/api/ntfy": {
+        send(
+          res,
+          200,
+          options.ntfy ? options.ntfy() : ntfyOffStatus(null)
+        );
+        return;
+      }
+      case "/api/pushover": {
+        send(
+          res,
+          200,
+          options.pushover ? options.pushover() : pushoverOffStatus(null)
+        );
+        return;
+      }
       case "/api/pull-requests": {
         send(
           res,
@@ -2201,7 +2451,7 @@ function urlFor(address) {
 
 // src/collector/hosts/standalone.ts
 import { existsSync } from "node:fs";
-import path21 from "node:path";
+import path25 from "node:path";
 
 // src/core/mapping/claudeCodeMapping.ts
 var LIVE_STATUS = /* @__PURE__ */ new Map([
@@ -3057,6 +3307,9 @@ function lstartMs(value) {
   const [day, hours, minutes, seconds, year] = match.slice(2).map(Number);
   return Date.UTC(year, month, day, hours, minutes, seconds);
 }
+function processStartTime(value) {
+  return lstartMs(collapse(value)) ?? null;
+}
 function compareProcessStart(recorded, actual, withinMs = SAME_START_WITHIN_MS) {
   if (recorded === void 0 || actual === void 0) return "unknown";
   const before = collapse(recorded);
@@ -3694,11 +3947,11 @@ async function readTranscriptTail(file, io, known, maxBytes = TRANSCRIPT_TAIL_BY
     const stamp = stampOf(open2.info);
     if (known !== null && sameStamp(known, stamp)) return { unchanged: true, stamp };
     const start = Math.max(0, stamp.size - maxBytes);
-    const bytes2 = await open2.read(start, stamp.size - start);
+    const bytes3 = await open2.read(start, stamp.size - start);
     return {
       unchanged: false,
       stamp,
-      tail: new TextDecoder("utf-8").decode(bytes2),
+      tail: new TextDecoder("utf-8").decode(bytes3),
       fromStart: start === 0
     };
   } finally {
@@ -4602,9 +4855,21 @@ async function pollAfterAnswer(poller, sessionId) {
 function answerRefusalFor(req) {
   return actionRefusalFor(req, ANSWER_ACTION, MAX_ANSWER_BODY_BYTES);
 }
-function createAnswerRoute(options) {
+function createAnswerer(options) {
   const { poller, events, asks } = options;
   const now = options.now ?? Date.now;
+  return async (sessionId, requestId, decision) => {
+    const session = poller.getSnapshot().sessions.find((listed) => listed.id === sessionId);
+    if (!session) return "no-ask";
+    const outcome = await asks.answer(sessionId, requestId, decision);
+    if (outcome !== "answered") return outcome;
+    events.add([answeredEvent(session, decision, now())]);
+    await pollAfterAnswer(poller, sessionId);
+    return "answered";
+  };
+}
+function createAnswerRoute(options) {
+  const answer = createAnswerer(options);
   return async function answerPermission(req) {
     const refused = answerRefusalFor(req);
     if (refused) {
@@ -4623,12 +4888,8 @@ function createAnswerRoute(options) {
         '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);
+    const outcome = await answer(asked.sessionId, asked.requestId, asked.decision);
     if (outcome !== "answered") return answerFailed(outcome);
-    events.add([answeredEvent(session, asked.decision, now())]);
-    await pollAfterAnswer(poller, asked.sessionId);
     return {
       status: 200,
       body: { ok: true, decision: asked.decision }
@@ -5564,18 +5825,18 @@ function namesOwnFiles(words, ownPaths = [], folder) {
       (part) => from !== void 0 && !part.startsWith("/") && !part.startsWith("-") ? [part, `${from}/${part}`] : [part]
     );
     return read.some((part) => {
-      const path23 = plainPath(part);
-      if (path23 === BY_NUMBER || path23.startsWith(`${BY_NUMBER}/`)) return true;
-      if (own.some((name) => path23 === name || path23.startsWith(`${name}/`))) return true;
-      if (above.has(path23)) return true;
-      return ownNames.some((name) => path23 === name || path23.endsWith(`/${name}`));
+      const path27 = plainPath(part);
+      if (path27 === BY_NUMBER || path27.startsWith(`${BY_NUMBER}/`)) return true;
+      if (own.some((name) => path27 === name || path27.startsWith(`${name}/`))) return true;
+      if (above.has(path27)) return true;
+      return ownNames.some((name) => path27 === name || path27.endsWith(`/${name}`));
     });
   });
 }
 function folderReachesOwnFiles(folder, ownPaths = []) {
   const own = ownPaths.filter((name) => name.startsWith("/")).map(plainPath);
-  const path23 = plainPath(folder);
-  return own.some((name) => name === path23 || name.startsWith(`${path23 === "/" ? "" : path23}/`));
+  const path27 = plainPath(folder);
+  return own.some((name) => name === path27 || name.startsWith(`${path27 === "/" ? "" : path27}/`));
 }
 var PLAIN_WORD = /^[A-Za-z0-9_\-.,/:=+@%]+$/;
 var ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
@@ -5928,6 +6189,8 @@ function createAnswering(options) {
       observe: () => {
       },
       answeredIn: () => /* @__PURE__ */ new Set(),
+      check: async () => {
+      },
       ruleAnswers: () => []
     };
   }
@@ -5955,6 +6218,7 @@ function createAnswering(options) {
   let problem = null;
   let listening = false;
   const answerRoute = createAnswerRoute({ poller, events, asks, now: options.now });
+  const answer = createAnswerer({ poller, events, asks, now: options.now });
   return {
     async start() {
       const started = await socket.start();
@@ -5987,6 +6251,9 @@ function createAnswering(options) {
       req.resume();
       return answerRefusalFor(req) ?? refusal(405, "This address only answers GET requests.", { Allow: "GET" });
     },
+    // The same answer, from the host's own process. With no socket nothing is held.
+    answer: async (sessionId, requestId, decision) => problem === null ? answer(sessionId, requestId, decision) : "unavailable",
+    check: () => asks.check(),
     ruleAnswers: () => ruleAnswers.recent()
   };
 }
@@ -6214,120 +6481,1482 @@ function waitTotals(input) {
   };
 }
 
-// src/collector/adapters/codex/index.ts
+// src/collector/adapters/antigravity/index.ts
 import os5 from "node:os";
-import path12 from "node:path";
+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: live2 } = fields;
-  let open2;
-  if (lastTurn === null) {
-    open2 = "idle";
-  } else if (typeof lastTurn !== "string") {
-    return "unknown";
-  } else if (TURN_UNDER_WAY.has(lastTurn)) {
-    open2 = "working";
-  } else if (TURN_OVER.has(lastTurn)) {
-    open2 = "idle";
-  } else {
-    return "unknown";
+// src/core/mapping/antigravityLiveness.ts
+function holdConversations(processes, conversations, listedAt = null) {
+  const held = /* @__PURE__ */ new Set();
+  let complete = true;
+  for (const { startedAt, conversation } of processes) {
+    if (conversation !== void 0) held.add(conversation);
+    if (startedAt === null) {
+      complete = false;
+      continue;
+    }
+    let wrote = false;
+    for (const { id, writtenAt } of conversations) {
+      if (writtenAt === null || writtenAt < startedAt) continue;
+      held.add(id);
+      wrote = true;
+    }
+    if (!wrote && conversation === void 0) complete = false;
   }
-  return live2 === false ? "finished" : open2;
-}
-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})?$/;
-function keepsWriterLocks(cliVersion) {
-  if (typeof cliVersion !== "string") return false;
-  const match = VERSION.exec(cliVersion);
-  if (!match) return false;
-  const parts = [Number(match[1]), Number(match[2]), Number(match[3])];
-  for (const [index, since] of WRITER_LOCKS_SINCE.entries()) {
-    const part = parts[index];
-    if (part !== since) return part > since;
+  if (listedAt !== null) {
+    for (const { id, writtenAt } of conversations) {
+      if (writtenAt !== null && writtenAt > listedAt) held.add(id);
+    }
   }
-  return match[4] === void 0;
+  return { held, complete };
 }
-function codexLiveness(fields) {
-  if (!fields.lockFolder) return "unknown";
-  if (fields.locked) return true;
-  return keepsWriterLocks(fields.cliVersion) ? false : "unknown";
+function antigravityLiveness(id, holding) {
+  if (holding === null) return "unknown";
+  if (holding.held.has(id)) return true;
+  return holding.complete ? false : "unknown";
 }
-var IMPORTED_TURN_ID = /^external-import-turn-\d{1,9}$/;
-function isImportedCodexTurn(turnId) {
-  return typeof turnId === "string" && IMPORTED_TURN_ID.test(turnId);
+
+// src/core/mapping/antigravityLog.ts
+var GLOG_LINE = /^[IWEF](\d{2})(\d{2}) (\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))? +\d+ ([\w.-]+):\d+\] (.*)$/;
+var SOURCE2 = {
+  backend: "server.go",
+  created: "server.go",
+  streaming: "conversation_manager.go",
+  confirmation: "tool_confirmation_manager.go"
+};
+var UUID = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}";
+var OPENED = new RegExp(`^(Created|Streaming) conversation (${UUID})$`);
+var BACKEND = /^Creating CLI server backend: (?:.* )?workspaceDirs=\[([^\]\s]+)\](?: |$)/;
+var ASKING = /^Surfacing tool confirmation: "([A-Za-z]{1,64})" at step (\d{1,9})$/;
+var ANSWERED = new RegExp(
+  `^Responding to tool confirmation: convID=(${UUID}), stepIdx=(\\d{1,9}), approved=(?:true|false)$`
+);
+var ABSOLUTE = /^(?:\/|[A-Za-z]:[\\/])/;
+var UNPRINTABLE = /[\p{Cc}\p{Cf}]/u;
+function readAgyLogLine(line) {
+  const glog = GLOG_LINE.exec(line);
+  if (glog === null) return null;
+  const source = glog[7];
+  const message = glog[8];
+  const opened = OPENED.exec(message);
+  if (opened !== null) {
+    const from = opened[1] === "Created" ? SOURCE2.created : SOURCE2.streaming;
+    return source === from ? { kind: "opened", conversation: opened[2].toLowerCase() } : null;
+  }
+  if (source === SOURCE2.backend) {
+    const backend = BACKEND.exec(message);
+    return backend !== null && ABSOLUTE.test(backend[1]) && !UNPRINTABLE.test(backend[1]) ? { kind: "folder", folder: backend[1] } : null;
+  }
+  if (source !== SOURCE2.confirmation) return null;
+  const asking = ASKING.exec(message);
+  if (asking !== null) {
+    const fraction = (glog[6] ?? "0").padEnd(3, "0").slice(0, 3);
+    return {
+      kind: "asking",
+      tool: asking[1],
+      step: Number(asking[2]),
+      at: {
+        month: Number(glog[1]),
+        day: Number(glog[2]),
+        hour: Number(glog[3]),
+        minute: Number(glog[4]),
+        second: Number(glog[5]),
+        millisecond: Number(fraction)
+      }
+    };
+  }
+  const answered = ANSWERED.exec(message);
+  if (answered !== null) {
+    return { kind: "answered", conversation: answered[1].toLowerCase(), step: Number(answered[2]) };
+  }
+  return null;
 }
-function isRecord8(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function emptyAgyLogState() {
+  return { folder: null, folderNamed: false, opened: /* @__PURE__ */ new Set(), current: null, ask: null };
 }
-var CODEX_DESKTOP_ORIGINATOR = "Codex Desktop";
-function mapCodexSurface(source, originator) {
-  if (originator === CODEX_DESKTOP_ORIGINATOR) return "desktop";
-  if (source === "cli" || source === "exec") return "terminal";
-  if (source === "vscode") return "vscode";
-  if (isRecord8(source) && source.custom === "chatgpt") return "desktop";
-  return "unknown";
+function addAgyLogLine(state, line) {
+  switch (line.kind) {
+    case "folder":
+      if (!state.folderNamed) state.folder = line.folder;
+      state.folderNamed = true;
+      return;
+    case "opened":
+      state.opened.add(line.conversation);
+      if (state.current !== line.conversation) state.ask = null;
+      state.current = line.conversation;
+      return;
+    case "asking":
+      state.ask = state.current === null ? null : { conversation: state.current, step: line.step, tool: line.tool, at: line.at };
+      return;
+    case "answered":
+      if (state.ask?.conversation === line.conversation && state.ask.step === line.step) {
+        state.ask = null;
+      }
+      return;
+  }
 }
-var NOT_A_SESSION_SOURCE = /* @__PURE__ */ new Set(["subagent", "internal", "mcp"]);
-var NOT_A_SESSION_THREAD = /* @__PURE__ */ new Set(["subagent", "guardian_review", "memory_consolidation"]);
-function isCodexSessionSource(source, meta = {}) {
-  if (typeof meta.parentThreadId === "string" && meta.parentThreadId !== "") return false;
-  if (typeof meta.threadSource === "string" && NOT_A_SESSION_THREAD.has(meta.threadSource)) {
-    return false;
+var ASK_STEPS_AHEAD = 2;
+function waitsForApproval(ask, conversation, lastIndex) {
+  if (ask === null || ask.conversation !== conversation || lastIndex === null) return false;
+  return ask.step > lastIndex && ask.step <= lastIndex + ASK_STEPS_AHEAD;
+}
+function agyLogTimeAt(time, near) {
+  const year = new Date(near).getFullYear();
+  let best = null;
+  for (const y of [year - 1, year, year + 1]) {
+    const at = new Date(
+      y,
+      time.month - 1,
+      time.day,
+      time.hour,
+      time.minute,
+      time.second,
+      time.millisecond
+    );
+    if (at.getMonth() !== time.month - 1 || at.getDate() !== time.day) continue;
+    const ms = at.getTime();
+    if (best === null || Math.abs(ms - near) < Math.abs(best - near)) best = ms;
   }
-  if (typeof source === "string") return !NOT_A_SESSION_SOURCE.has(source);
-  if (isRecord8(source)) return !Object.keys(source).some((kind) => NOT_A_SESSION_SOURCE.has(kind));
-  return true;
+  return best;
 }
 
-// src/collector/adapters/codex/rolloutFile.ts
-var HEAD_LIMIT_BYTES = 2 * 1024 * 1024;
-var TAIL_LIMIT_BYTES = 8 * 1024 * 1024;
-var FIRST_HEAD_BYTES = 256 * 1024;
-var TAIL_CHUNK_BYTES = 256 * 1024;
+// src/collector/adapters/antigravity/agyLogs.ts
+import path11 from "node:path";
+var LOG_DIR = "log";
+var LOG_LIMIT_BYTES = 4 * 1024 * 1024;
+var LINE_LIMIT_BYTES = 64 * 1024;
+var LOG_NAMED_WITHIN_MS = 1e4;
+var PS_LATE_MS = 2e3;
+var RELIST_MS = 1e4;
+var LOG_NAME = /^cli-(\d{4})(\d{2})(\d{2})_(\d{2})(\d{2})(\d{2})\.log$/;
 var NEWLINE = 10;
-var CODEX_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/;
-function parseCodexTime(value) {
-  if (typeof value !== "string" || !CODEX_TIME.test(value)) return null;
-  const at = Date.parse(value);
-  return Number.isSafeInteger(at) ? at : null;
-}
-var LINE_TIME = /^\{"timestamp":"([^"]{1,64})"/;
-var TURN_HINT = /"type":"(?:task|turn)_/;
-var TURN_TYPE = /^(?:task|turn)_/;
-function isRecord9(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function text3(value) {
-  return typeof value === "string" && value !== "" ? value : void 0;
-}
-function label(value) {
-  return typeof value === "string" && value !== "" && value.length <= 64 ? value : void 0;
-}
-function compactSource(value) {
-  if (typeof value === "string") return text3(value);
-  if (!isRecord9(value)) return void 0;
-  return Object.fromEntries(
-    Object.entries(value).map(([kind, detail]) => [
-      kind,
-      typeof detail === "string" ? detail : true
-    ])
+function logStartOf(name) {
+  const match = LOG_NAME.exec(name);
+  if (match === null) return null;
+  const [year, month, day, hour, minute, second] = match.slice(1).map(Number);
+  const at = new Date(year, month - 1, day, hour, minute, second);
+  if (at.getMonth() !== month - 1 || at.getDate() !== day || at.getHours() !== hour) return null;
+  return at.getTime();
+}
+function matchLogs(processes, logs) {
+  const candidates = (startedAt) => startedAt === null ? [] : [...logs].filter(
+    ([, at]) => at >= startedAt - PS_LATE_MS && at - startedAt <= LOG_NAMED_WITHIN_MS
   );
+  const owners = /* @__PURE__ */ new Map();
+  for (const { startedAt } of processes) {
+    for (const [name] of candidates(startedAt)) owners.set(name, (owners.get(name) ?? 0) + 1);
+  }
+  return processes.map(({ startedAt }) => {
+    const found = candidates(startedAt);
+    if (found.length !== 1) return null;
+    const [name] = found[0];
+    return owners.get(name) === 1 ? name : null;
+  });
+}
+function createAgyLogReader(options) {
+  const { io } = options;
+  const now = options.now ?? Date.now;
+  const logDir = path11.join(options.home, LOG_DIR);
+  const cursors = /* @__PURE__ */ new Map();
+  let listed = /* @__PURE__ */ new Map();
+  let listedFor = "";
+  let listedAt = -Infinity;
+  async function list(processes) {
+    const key = processes.map((p) => p.startedAt ?? "?").join(",");
+    const since = now() - listedAt;
+    if (key === listedFor && since >= 0 && since < RELIST_MS) return;
+    listedFor = key;
+    listedAt = now();
+    let names;
+    try {
+      names = await io.readdir(logDir);
+    } catch {
+      listed = /* @__PURE__ */ new Map();
+      return;
+    }
+    const next = /* @__PURE__ */ new Map();
+    for (const name of names) {
+      const at = logStartOf(name);
+      if (at !== null) next.set(name, at);
+    }
+    listed = next;
+  }
+  function addLines(cursor, data) {
+    let buffer = cursor.pending.byteLength > 0 ? Buffer.concat([cursor.pending, data]) : data;
+    if (cursor.skipping) {
+      const end = buffer.indexOf(NEWLINE);
+      if (end === -1) return;
+      buffer = buffer.subarray(end + 1);
+      cursor.skipping = false;
+    }
+    let start = 0;
+    let newline = buffer.indexOf(NEWLINE);
+    while (newline !== -1) {
+      const line = readAgyLogLine(buffer.toString("utf8", start, newline));
+      if (line !== null) addAgyLogLine(cursor.state, line);
+      start = newline + 1;
+      newline = buffer.indexOf(NEWLINE, start);
+    }
+    const rest = buffer.subarray(start);
+    cursor.skipping = rest.byteLength > LINE_LIMIT_BYTES;
+    cursor.pending = cursor.skipping ? Buffer.alloc(0) : Buffer.from(rest);
+  }
+  async function readLog(file, info) {
+    const known = cursors.get(file);
+    if (known && known.ino === info.ino && known.size === info.size && known.mtimeMs === info.mtimeMs) {
+      return known.state;
+    }
+    const handle = await io.openRegular(file);
+    try {
+      const opened = handle.info;
+      const onward = known !== void 0 && known.ino === opened.ino && opened.size >= known.offset;
+      const cursor = onward ? { ...known, state: known.state } : {
+        ino: opened.ino,
+        size: 0,
+        mtimeMs: 0,
+        offset: 0,
+        pending: Buffer.alloc(0),
+        skipping: false,
+        state: emptyAgyLogState()
+      };
+      let from = cursor.offset;
+      if (opened.size - from > LOG_LIMIT_BYTES) {
+        from = opened.size - LOG_LIMIT_BYTES;
+        cursor.state.ask = null;
+        cursor.pending = Buffer.alloc(0);
+        cursor.skipping = true;
+        addLines(cursor, Buffer.from(await handle.read(from, opened.size - from)));
+      } else if (opened.size > from) {
+        addLines(cursor, Buffer.from(await handle.read(from, opened.size - from)));
+      }
+      cursor.offset = opened.size;
+      cursor.size = opened.size;
+      cursor.mtimeMs = opened.mtimeMs;
+      cursor.ino = opened.ino;
+      cursors.set(file, cursor);
+      return cursor.state;
+    } finally {
+      await handle.close();
+    }
+  }
+  async function read(processes) {
+    if (processes.length === 0) {
+      cursors.clear();
+      return [];
+    }
+    await list(processes);
+    const names = matchLogs(processes, listed);
+    const kept = /* @__PURE__ */ new Set();
+    const states = [];
+    for (const name of names) {
+      if (name === null) {
+        states.push(null);
+        continue;
+      }
+      const file = path11.join(logDir, name);
+      kept.add(file);
+      try {
+        const info = await io.lstat(file);
+        states.push(info.kind === "file" ? await readLog(file, info) : null);
+      } catch {
+        states.push(null);
+      }
+    }
+    for (const file of cursors.keys()) {
+      if (!kept.has(file)) cursors.delete(file);
+    }
+    return states;
+  }
+  return {
+    async read(processes) {
+      try {
+        return await read(processes);
+      } catch {
+        return processes.map(() => null);
+      }
+    }
+  };
+}
+
+// src/collector/adapters/antigravity/agyProcesses.ts
+var AGY_TABLE_ARGS = ["-A", "-o", "pid=,ppid=,lstart=,comm="];
+function agyCommandLineArgs(pids) {
+  return ["-o", "pid=,args=", "-p", pids.join(",")];
+}
+var AGY_COMMANDS = /* @__PURE__ */ new Set([
+  "agent",
+  "agents",
+  "changelog",
+  "help",
+  "install",
+  "mcp",
+  "mic-serve",
+  "models",
+  "plugin",
+  "plugins",
+  "remote-control",
+  "update"
+]);
+var NOT_A_SESSION_OPTIONS = /* @__PURE__ */ new Set([
+  "-h",
+  "-help",
+  "--help",
+  "-version",
+  "--version"
+]);
+var UUID2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var TABLE_LINE = /^\s*(\d+)\s+(\d+)\s+([A-Z][a-z]{2}\s+[A-Z][a-z]{2}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}\s+\d{4})\s+(\S.*?)\s*$/;
+function isAgyProgram(program) {
+  const name = program.split(/[\\/]/).pop()?.toLowerCase();
+  return name === "agy" || name === "agy.exe";
+}
+function parseAgyTable(stdout) {
+  const rows = [];
+  for (const line of stdout.split("\n")) {
+    const match = TABLE_LINE.exec(line);
+    if (!match || !isAgyProgram(match[4])) continue;
+    const start = match[3].replace(/\s+/g, " ");
+    rows.push({
+      pid: Number(match[1]),
+      ppid: Number(match[2]),
+      start,
+      startedAt: processStartTime(start)
+    });
+  }
+  return rows;
+}
+var PROGRAM_IN_LINE = /(?:^|[\\/])agy(?:\.exe)?(?=\s|$)/i;
+function readAgyCommandLine(line) {
+  const program = PROGRAM_IN_LINE.exec(line);
+  if (!program) return { session: true };
+  const words = line.slice(program.index + program[0].length).split(/\s+/).filter((word2) => word2 !== "");
+  const first = words[0];
+  if (first !== void 0 && (AGY_COMMANDS.has(first) || NOT_A_SESSION_OPTIONS.has(first))) {
+    return { session: false };
+  }
+  for (const [index, word2] of words.entries()) {
+    let value;
+    if (word2 === "--conversation" || word2 === "-conversation") value = words[index + 1];
+    else if (word2.startsWith("--conversation=")) value = word2.slice("--conversation=".length);
+    else if (word2.startsWith("-conversation=")) value = word2.slice("-conversation=".length);
+    else continue;
+    if (value !== void 0 && UUID2.test(value)) {
+      return { session: true, conversation: value.toLowerCase() };
+    }
+  }
+  return { session: true };
+}
+function parseCommandLines(stdout) {
+  const lines = /* @__PURE__ */ new Map();
+  for (const line of stdout.split("\n")) {
+    const match = /^\s*(\d+)\s(.*)$/.exec(line);
+    if (match) lines.set(Number(match[1]), match[2]);
+  }
+  return lines;
+}
+function createAgyProcessReader(options = {}) {
+  const run = options.run ?? runPs;
+  const platform = options.platform ?? process.platform;
+  const known = /* @__PURE__ */ new Map();
+  async function read() {
+    if (platform === "win32") return { ok: false };
+    const table = await run(AGY_TABLE_ARGS, { utc: true });
+    if (!table.ok) return { ok: false };
+    const rows = parseAgyTable(table.stdout);
+    const keyOf = (row) => `${row.pid} ${row.start}`;
+    const current = new Set(rows.map(keyOf));
+    for (const key of known.keys()) {
+      if (!current.has(key)) known.delete(key);
+    }
+    const unseen = rows.filter((row) => !known.has(keyOf(row)));
+    const ended = /* @__PURE__ */ new Set();
+    if (unseen.length > 0) {
+      const answer = await run(agyCommandLineArgs(unseen.map((row) => row.pid)));
+      const lines = parseCommandLines(answer.stdout);
+      for (const row of unseen) {
+        const line = lines.get(row.pid);
+        if (line !== void 0) known.set(keyOf(row), readAgyCommandLine(line));
+        else if (answer.ok || lines.size > 0) ended.add(row.pid);
+      }
+    }
+    const running = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      if (!ended.has(row.pid)) running.set(row.pid, row);
+    }
+    const lineOf2 = (row) => known.get(keyOf(row)) ?? { session: true };
+    const underSession = (row) => {
+      const seen = /* @__PURE__ */ new Set([row.pid]);
+      let parent = running.get(row.ppid);
+      while (parent !== void 0 && !seen.has(parent.pid)) {
+        if (lineOf2(parent).session) return true;
+        seen.add(parent.pid);
+        parent = running.get(parent.ppid);
+      }
+      return false;
+    };
+    const sessions = [];
+    for (const row of running.values()) {
+      const line = lineOf2(row);
+      if (!line.session || underSession(row)) continue;
+      sessions.push(
+        line.conversation === void 0 ? { startedAt: row.startedAt } : { startedAt: row.startedAt, conversation: line.conversation }
+      );
+    }
+    return { ok: true, sessions };
+  }
+  return {
+    async read() {
+      try {
+        return await read();
+      } catch {
+        return { ok: false };
+      }
+    }
+  };
+}
+
+// src/collector/adapters/antigravity/conversations.ts
+import path12 from "node:path";
+var BRAIN_DIR = "brain";
+var CONVERSATIONS_DIR = "conversations";
+var TRANSCRIPT_IN_FOLDER = [".system_generated", "logs", "transcript.jsonl"];
+var OLD_REFRESH_MS = 3e4;
+var UUID3 = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+var FOLDER_NAME = new RegExp(`^(${UUID3})$`, "i");
+var DATABASE_NAME = new RegExp(`^(${UUID3})\\.db(?:-wal)?$`, "i");
+function conversationIdOfFolder(name) {
+  return FOLDER_NAME.exec(name)?.[1]?.toLowerCase() ?? null;
+}
+function conversationIdOfDatabase(name) {
+  return DATABASE_NAME.exec(name)?.[1]?.toLowerCase() ?? null;
+}
+function createConversationFinder(options) {
+  const { io } = options;
+  const brainDir = path12.join(options.home, BRAIN_DIR);
+  const databaseDir = path12.join(options.home, CONVERSATIONS_DIR);
+  const oldRefreshMs = options.oldRefreshMs ?? OLD_REFRESH_MS;
+  const known = /* @__PURE__ */ new Map();
+  let oldCheckedAt = null;
+  async function lookAt(id) {
+    const transcript = path12.join(brainDir, id, ...TRANSCRIPT_IN_FOLDER);
+    const infos = await Promise.all(
+      [transcript, path12.join(databaseDir, `${id}.db`), path12.join(databaseDir, `${id}.db-wal`)].map(
+        (file) => io.lstat(file).catch(() => null)
+      )
+    );
+    const transcriptInfo = infos[0]?.kind === "file" ? infos[0] : null;
+    const writtenAt = transcriptInfo === null ? null : Math.floor(transcriptInfo.mtimeMs);
+    let lastWriteAt = null;
+    for (const info of infos) {
+      if (info?.kind !== "file") continue;
+      const at = Math.floor(info.mtimeMs);
+      lastWriteAt = lastWriteAt === null ? at : Math.max(lastWriteAt, at);
+    }
+    return { id, transcript, transcriptInfo, writtenAt, lastWriteAt };
+  }
+  return {
+    async list(checkedAt, mayBeOpen) {
+      let folders;
+      try {
+        folders = await io.readdir(brainDir);
+      } catch (error) {
+        return { state: isMissing2(error) ? "missing" : "unreadable" };
+      }
+      const databases = await io.readdir(databaseDir).catch(() => []);
+      const ids = /* @__PURE__ */ new Set();
+      for (const name of folders) {
+        const id = conversationIdOfFolder(name);
+        if (id !== null) ids.add(id);
+      }
+      for (const name of databases) {
+        const id = conversationIdOfDatabase(name);
+        if (id !== null) ids.add(id);
+      }
+      for (const id of known.keys()) {
+        if (!ids.has(id)) known.delete(id);
+      }
+      const since = oldCheckedAt === null ? Infinity : checkedAt - oldCheckedAt;
+      const refreshOld = since < 0 || since >= oldRefreshMs;
+      if (refreshOld) oldCheckedAt = checkedAt;
+      const cutoff = checkedAt - FINISHED_RETENTION_MS;
+      await Promise.all(
+        [...ids].map(async (id) => {
+          const before = known.get(id);
+          const recent = before === void 0 || before.lastWriteAt !== null && before.lastWriteAt >= cutoff || mayBeOpen(id);
+          if (recent || refreshOld) known.set(id, await lookAt(id));
+        })
+      );
+      const conversations = [...known.values()].sort((a, b) => a.id < b.id ? -1 : 1);
+      return { state: "ok", conversations };
+    }
+  };
+}
+function writtenRecently(files, now) {
+  return files.writtenAt !== null && isWithinRetention(files.writtenAt, now);
+}
+
+// src/collector/adapters/antigravity/annotations.ts
+import path13 from "node:path";
+var ANNOTATIONS_DIR = "annotations";
+var ANNOTATION_LIMIT_BYTES = 4 * 1024;
+var TITLE_FIELD = /^title[ \t]*:[ \t]*"((?:[^"\\\n]|\\.)*)"[ \t]*$/m;
+var SIMPLE_ESCAPES = {
+  n: 10,
+  r: 13,
+  t: 9,
+  '"': 34,
+  "'": 39,
+  "\\": 92,
+  "?": 63,
+  a: 7,
+  b: 8,
+  f: 12,
+  v: 11
+};
+function unescapeTextFormat(body) {
+  const chars = Array.from(body);
+  const bytes3 = [];
+  for (let i = 0; i < chars.length; i += 1) {
+    const char = chars[i];
+    if (char !== "\\") {
+      bytes3.push(...Buffer.from(char, "utf8"));
+      continue;
+    }
+    const next = chars[i + 1];
+    if (next === void 0) return null;
+    const octal = /^[0-7]{1,3}/.exec(chars.slice(i + 1, i + 4).join(""));
+    if (octal !== null) {
+      const value = parseInt(octal[0], 8);
+      if (value > 255) return null;
+      bytes3.push(value);
+      i += octal[0].length;
+      continue;
+    }
+    if (next === "u" || next === "U") {
+      const digits = next === "u" ? 4 : 8;
+      const hex = chars.slice(i + 2, i + 2 + digits).join("");
+      if (!new RegExp(`^[0-9a-fA-F]{${digits}}$`).test(hex)) return null;
+      const point = parseInt(hex, 16);
+      if (point > 1114111 || point >= 55296 && point <= 57343) return null;
+      bytes3.push(...Buffer.from(String.fromCodePoint(point), "utf8"));
+      i += 1 + digits;
+      continue;
+    }
+    if (next === "x" || next === "X") {
+      const hex = /^[0-9a-fA-F]{1,2}/.exec(chars.slice(i + 2, i + 4).join(""));
+      if (hex === null) return null;
+      bytes3.push(parseInt(hex[0], 16));
+      i += 1 + hex[0].length;
+      continue;
+    }
+    const simple = SIMPLE_ESCAPES[next];
+    if (simple === void 0) return null;
+    bytes3.push(simple);
+    i += 1;
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(bytes3));
+  } catch {
+    return null;
+  }
+}
+function readTitle(content) {
+  const field2 = TITLE_FIELD.exec(content);
+  if (field2 === null) return null;
+  const title = unescapeTextFormat(field2[1]);
+  return title === null ? null : sessionName(title) ?? null;
+}
+function createTitleReader(options) {
+  const { io } = options;
+  const dir = path13.join(options.home, ANNOTATIONS_DIR);
+  const cache = /* @__PURE__ */ new Map();
+  async function read(id) {
+    const file = path13.join(dir, `${id}.pbtxt`);
+    const info = await io.lstat(file);
+    const known = cache.get(id);
+    if (known && known.ino === info.ino && known.size === info.size && known.mtimeMs === info.mtimeMs) {
+      return known.title;
+    }
+    let title = null;
+    if (info.kind === "file" && info.size <= ANNOTATION_LIMIT_BYTES) {
+      const handle = await io.openRegular(file);
+      try {
+        if (handle.info.size <= ANNOTATION_LIMIT_BYTES) {
+          const data = await handle.read(0, handle.info.size);
+          title = readTitle(Buffer.from(data).toString("utf8"));
+        }
+      } finally {
+        await handle.close();
+      }
+    }
+    cache.set(id, { ino: info.ino, size: info.size, mtimeMs: info.mtimeMs, title });
+    return title;
+  }
+  return {
+    async read(id) {
+      try {
+        return await read(id);
+      } catch {
+        cache.delete(id);
+        return null;
+      }
+    },
+    keepOnly(ids) {
+      for (const id of cache.keys()) {
+        if (!ids.has(id)) cache.delete(id);
+      }
+    }
+  };
+}
+
+// src/core/mapping/antigravityMapping.ts
+var ANTIGRAVITY_STEP_TYPES = [
+  "UNSPECIFIED",
+  "DUMMY",
+  "FINISH",
+  "PLAN_INPUT",
+  "MQUERY",
+  "CODE_ACTION",
+  "GIT_COMMIT",
+  "GREP_SEARCH",
+  "VIEW_FILE",
+  "LIST_DIRECTORY",
+  "COMPILE",
+  "VIEW_CODE_ITEM",
+  "USER_INPUT",
+  "PLANNER_RESPONSE",
+  "ERROR_MESSAGE",
+  "RUN_COMMAND",
+  "CHECKPOINT",
+  "PROPOSE_CODE",
+  "FIND",
+  "SUGGESTED_RESPONSES",
+  "COMMAND_STATUS",
+  "MEMORY",
+  "READ_URL_CONTENT",
+  "VIEW_CONTENT_CHUNK",
+  "SEARCH_WEB",
+  "RETRIEVE_MEMORY",
+  "MCP_TOOL",
+  "MANAGER_FEEDBACK",
+  "TOOL_CALL_PROPOSAL",
+  "TOOL_CALL_CHOICE",
+  "TRAJECTORY_CHOICE",
+  "CLIPBOARD",
+  "VIEW_FILE_OUTLINE",
+  "POST_PR_REVIEW",
+  "LIST_RESOURCES",
+  "READ_RESOURCE",
+  "LINT_DIFF",
+  "FIND_ALL_REFERENCES",
+  "BRAIN_UPDATE",
+  "OPEN_BROWSER_URL",
+  "RUN_EXTENSION_CODE",
+  "PROPOSAL_FEEDBACK",
+  "TRAJECTORY_SEARCH",
+  "EXECUTE_BROWSER_JAVASCRIPT",
+  "LIST_BROWSER_PAGES",
+  "CAPTURE_BROWSER_SCREENSHOT",
+  "CLICK_BROWSER_PIXEL",
+  "READ_TERMINAL",
+  "CAPTURE_BROWSER_CONSOLE_LOGS",
+  "READ_BROWSER_PAGE",
+  "BROWSER_GET_DOM",
+  "CODE_SEARCH",
+  "BROWSER_INPUT",
+  "BROWSER_MOVE_MOUSE",
+  "BROWSER_SELECT_OPTION",
+  "BROWSER_SCROLL_UP",
+  "BROWSER_SCROLL_DOWN",
+  "BROWSER_CLICK_ELEMENT",
+  "BROWSER_PRESS_KEY",
+  "TASK_BOUNDARY",
+  "NOTIFY_USER",
+  "CODE_ACKNOWLEDGEMENT",
+  "INTERNAL_SEARCH",
+  "BROWSER_SUBAGENT",
+  "FILE_CHANGE",
+  "MOVE",
+  "BROWSER_SCROLL",
+  "KNOWLEDGE_GENERATION",
+  "EPHEMERAL_MESSAGE",
+  "GENERATE_IMAGE",
+  "DELETE_DIRECTORY",
+  "COMPILE_APPLET",
+  "INSTALL_APPLET_DEPENDENCIES",
+  "INSTALL_APPLET_PACKAGE",
+  "BROWSER_RESIZE_WINDOW",
+  "BROWSER_DRAG_PIXEL_TO_PIXEL",
+  "CONVERSATION_HISTORY",
+  "KNOWLEDGE_ARTIFACTS",
+  "SEND_COMMAND_INPUT",
+  "SYSTEM_MESSAGE",
+  "WAIT",
+  "AGENCY_TOOL_CALL",
+  "CIDER_AGENT_DUMMY",
+  "BUILD_CLEANER",
+  "BLAZE_BUILD_TARGETS",
+  "BLAZE_TEST_TARGETS",
+  "SET_UP_FIREBASE",
+  "MOMA",
+  "RESTART_DEV_SERVER",
+  "DEPLOY_FIREBASE",
+  "SHELL_EXEC",
+  "BROWSER_MOUSE_WHEEL",
+  "LINT_APPLET",
+  "KI_INSERTION",
+  "RETRIEVE_CONTENT",
+  "CRITIQUE",
+  "FINDINGS",
+  "BROWSER_MOUSE_UP",
+  "BROWSER_MOUSE_DOWN",
+  "WORKSPACE_API",
+  "BROWSER_LIST_NETWORK_REQUESTS",
+  "BROWSER_GET_NETWORK_REQUEST",
+  "BROWSER_REFRESH_PAGE",
+  "EDIT_NOTEBOOK",
+  "INVOKE_SUBAGENT",
+  "WRITE_BLOB",
+  "READ_NOTEBOOK",
+  "PROPOSE_AI_COMMENTS",
+  "START_CODE_REVIEW",
+  "GENERIC",
+  "SET_UP_CLOUD_SQL",
+  "EXECUTE_NOTEBOOK",
+  "CLOUD_SQL_UPDATE_SCHEMA",
+  "RPC_ACTION",
+  "CLOUD_SQL_EXECUTE_SQL",
+  "ASK_QUESTION",
+  "DIRECTORY_RULES",
+  "TOOL_SEARCH"
+];
+var ANTIGRAVITY_STEP_STATUSES = [
+  "UNSPECIFIED",
+  "PENDING",
+  "RUNNING",
+  "DONE",
+  "INVALID",
+  "CLEARED",
+  "CANCELED",
+  "ERROR",
+  "GENERATING",
+  "WAITING",
+  "QUEUED",
+  "INTERRUPTED"
+];
+var KNOWN_TYPES = new Set(ANTIGRAVITY_STEP_TYPES);
+var KNOWN_STATUSES = new Set(ANTIGRAVITY_STEP_STATUSES);
+var TYPE_PREFIX = "CORTEX_STEP_TYPE_";
+var STATUS_PREFIX = "CORTEX_STEP_STATUS_";
+var NAME = /^[A-Z][A-Z0-9_]{0,63}$/;
+function nameOf(value, prefix) {
+  if (typeof value !== "string") return null;
+  const upper = value.trim().toUpperCase();
+  const name = upper.startsWith(prefix) ? upper.slice(prefix.length) : upper;
+  return NAME.test(name) ? name : null;
+}
+function stepTypeName(value) {
+  return nameOf(value, TYPE_PREFIX);
+}
+function stepStatusName(value) {
+  return nameOf(value, STATUS_PREFIX);
+}
+var ASIDE_TYPES = /* @__PURE__ */ new Set([
+  "DUMMY",
+  "CIDER_AGENT_DUMMY",
+  "CHECKPOINT",
+  "EPHEMERAL_MESSAGE",
+  "CONVERSATION_HISTORY",
+  "SYSTEM_MESSAGE",
+  "SUGGESTED_RESPONSES",
+  "KNOWLEDGE_ARTIFACTS",
+  "KNOWLEDGE_GENERATION",
+  "KI_INSERTION",
+  "DIRECTORY_RULES",
+  "BRAIN_UPDATE"
+]);
+var GONE_STATUSES = /* @__PURE__ */ new Set(["CLEARED", "INVALID"]);
+var UNDER_WAY = /* @__PURE__ */ new Set([
+  "PENDING",
+  "RUNNING",
+  "GENERATING",
+  "QUEUED",
+  "WAITING"
+]);
+var STOPPED = /* @__PURE__ */ new Set(["CANCELED", "INTERRUPTED"]);
+var TURN_OVER = /* @__PURE__ */ new Set(["FINISH"]);
+function isAsideStep(step) {
+  return step.type !== null && ASIDE_TYPES.has(step.type) || step.status !== null && GONE_STATUSES.has(step.status);
+}
+function openStatusOf(step) {
+  const { type, status } = step;
+  if (type === "ERROR_MESSAGE") return "failed";
+  if (status === null || !KNOWN_STATUSES.has(status)) return "unknown";
+  if (UNDER_WAY.has(status)) return "working";
+  if (STOPPED.has(status)) return "idle";
+  if (type === null || !KNOWN_TYPES.has(type) || type === "UNSPECIFIED") return "unknown";
+  if (status === "ERROR") return type === "PLANNER_RESPONSE" ? "failed" : "working";
+  if (status !== "DONE") return "unknown";
+  if (type === "PLANNER_RESPONSE") return step.toolCalls ? "working" : "idle";
+  if (TURN_OVER.has(type)) return "idle";
+  return "working";
+}
+function mapAntigravityStatus(fields) {
+  const { last, live: live2 } = fields;
+  if (last === void 0) return "unknown";
+  const open2 = last === null ? "idle" : openStatusOf(last);
+  if (open2 === "failed" || open2 === "unknown") return open2;
+  if (live2 === false) return "finished";
+  return fields.asking === true ? "needs-you" : open2;
+}
+
+// src/collector/adapters/antigravity/toSession.ts
+var SOURCE_ID2 = "antigravity-cli";
+var WRITE_ORDER_SLACK_MS2 = 1e3;
+function antigravitySession(input) {
+  const { conversationId, state, live: live2, now } = input;
+  const id = `${SOURCE_ID2}:${conversationId}`;
+  const waiting = input.waiting ?? null;
+  const status = mapAntigravityStatus({ last: state.last, live: live2, asking: waiting !== null });
+  const startedAt = plausibleTime(state.firstAt, now);
+  let statusSince = null;
+  if (status === "working" || status === "idle" || status === "failed") {
+    statusSince = plausibleTime(state.since, now);
+  } else if (status === "needs-you") {
+    statusSince = plausibleTime(waiting?.since ?? null, now) ?? plausibleTime(state.lastAt, now);
+  } else if (status === "finished") {
+    statusSince = plausibleTime(state.lastAt, now);
+  }
+  if (statusSince !== null && startedAt !== null && statusSince < startedAt - WRITE_ORDER_SLACK_MS2) {
+    statusSince = null;
+  }
+  const cwd = input.folder ?? null;
+  const project = projectOf(cwd);
+  const session = {
+    id,
+    source: SOURCE_ID2,
+    surface: "terminal",
+    name: input.title ?? project ?? sessionName(conversationId) ?? id,
+    cwd,
+    project,
+    status,
+    startedAt,
+    statusSince,
+    links: {},
+    stale: isStale({ status, statusSince }, now)
+  };
+  if (status === "needs-you" && waiting !== null) {
+    session.waitingReason = "permission";
+    session.waitingDetail = waiting.tool;
+  }
+  const writtenAt = plausibleTime(input.writtenAt, now);
+  const beforeStart = writtenAt !== null && startedAt !== null && writtenAt < startedAt - WRITE_ORDER_SLACK_MS2;
+  if (writtenAt !== null && !beforeStart) session.lastWriteAt = writtenAt;
+  return session;
+}
+
+// src/collector/adapters/antigravity/transcriptFile.ts
+import { createHash as createHash2 } from "node:crypto";
+var HEAD_LIMIT_BYTES = 256 * 1024;
+var TAIL_LIMIT_BYTES = 2 * 1024 * 1024;
+var TAIL_CHUNK_BYTES = 64 * 1024;
+var HEAD_HASH_BYTES = 4 * 1024;
+var NEWLINE2 = 10;
+var ISO_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/;
+function parseStepTime(value) {
+  if (typeof value !== "string" || !ISO_TIME.test(value)) return null;
+  const at = Date.parse(value);
+  return Number.isSafeInteger(at) ? at : null;
+}
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readStepLine(line) {
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isRecord8(value)) return null;
+  const type = stepTypeName(value.type);
+  const status = stepStatusName(value.status);
+  if (type === null && status === null) return null;
+  const index = value.step_index;
+  return {
+    index: Number.isSafeInteger(index) && index >= 0 ? index : null,
+    type,
+    status,
+    toolCalls: Array.isArray(value.tool_calls) && value.tool_calls.length > 0,
+    at: parseStepTime(value.created_at)
+  };
+}
+function emptyState() {
+  return { firstAt: null, last: void 0, since: null, lastAt: null, lastIndex: null };
+}
+function countsForIndex(step) {
+  return step.index !== null && step.status !== "CLEARED" && step.status !== "INVALID";
+}
+function addStep(state, step) {
+  if (step.at !== null) state.lastAt = step.at;
+  if (countsForIndex(step)) state.lastIndex = step.index;
+  if (isAsideStep(step)) return;
+  const was = state.last ? openStatusOf(state.last) : null;
+  if (was !== openStatusOf(step)) state.since = step.at;
+  state.last = step;
+}
+function bytes(data) {
+  return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+}
+async function readExactly(file, position, length) {
+  const data = bytes(await file.read(position, length));
+  if (data.byteLength !== length) throw new Error("The file changed while it was read.");
+  return data;
+}
+async function headHash(file, size) {
+  const head = await readExactly(file, 0, Math.min(HEAD_HASH_BYTES, size));
+  return createHash2("sha256").update(head).digest("hex");
+}
+async function readFirstAt(file, size) {
+  const head = await readExactly(file, 0, Math.min(HEAD_LIMIT_BYTES, size));
+  const end = head.indexOf(NEWLINE2);
+  if (end === -1 && head.byteLength < size) return null;
+  const step = readStepLine(head.toString("utf8", 0, end === -1 ? head.byteLength : end));
+  return step?.index === 0 ? step.at : null;
+}
+async function scanTail(file, size) {
+  const state = emptyState();
+  let position = size;
+  let budget2 = TAIL_LIMIT_BYTES;
+  let fragment = Buffer.alloc(0);
+  let end = null;
+  let settled = false;
+  const take = (step) => {
+    if (step === null) return false;
+    if (state.lastAt === null && step.at !== null) state.lastAt = step.at;
+    if (state.lastIndex === null && countsForIndex(step)) state.lastIndex = step.index;
+    if (isAsideStep(step)) return false;
+    if (state.last === void 0 || state.last === null) {
+      state.last = step;
+      state.since = step.at;
+      return false;
+    }
+    if (openStatusOf(step) !== openStatusOf(state.last)) return true;
+    if (step.at !== null) state.since = step.at;
+    return false;
+  };
+  while (position > 0 && budget2 > 0 && !settled) {
+    const length = Math.min(TAIL_CHUNK_BYTES, position, budget2);
+    const start = position - length;
+    const chunk = await readExactly(file, start, length);
+    budget2 -= length;
+    position = start;
+    const buffer = fragment.byteLength > 0 ? Buffer.concat([chunk, fragment]) : chunk;
+    let cut2 = buffer.byteLength;
+    if (end === null) {
+      const last = buffer.lastIndexOf(NEWLINE2);
+      if (last === -1) {
+        fragment = buffer;
+        continue;
+      }
+      end = start + last + 1;
+      cut2 = last;
+      if (last + 1 < buffer.byteLength) {
+        settled = take(readStepLine(buffer.toString("utf8", last + 1)));
+      }
+    }
+    let newline = cut2 > 0 ? buffer.lastIndexOf(NEWLINE2, cut2 - 1) : -1;
+    while (newline !== -1 && !settled) {
+      settled = take(readStepLine(buffer.toString("utf8", newline + 1, cut2)));
+      cut2 = newline;
+      newline = cut2 > 0 ? buffer.lastIndexOf(NEWLINE2, cut2 - 1) : -1;
+    }
+    if (settled) break;
+    if (start === 0) {
+      take(readStepLine(buffer.toString("utf8", 0, cut2)));
+      if (state.last === void 0) state.last = null;
+      return { state, end };
+    }
+    fragment = buffer.subarray(0, cut2);
+  }
+  if (!settled && position === 0) {
+    if (end === null) {
+      take(readStepLine(fragment.toString("utf8")));
+      end = 0;
+    }
+    if (state.last === void 0) state.last = null;
+    return { state, end };
+  }
+  if (!settled && state.last) state.since = null;
+  return { state, end };
+}
+function stateOf(cached) {
+  return {
+    firstAt: cached.firstAt,
+    last: cached.last,
+    since: cached.since,
+    lastAt: cached.lastAt,
+    lastIndex: cached.lastIndex
+  };
+}
+function createTranscriptReader(io) {
+  const cache = /* @__PURE__ */ new Map();
+  async function readFresh(file, earlier) {
+    const handle = await io.openRegular(file);
+    try {
+      const { info } = handle;
+      const firstAt = await readFirstAt(handle, info.size);
+      const tail = await scanTail(handle, info.size);
+      return {
+        ...tail.state,
+        // A compacted file may begin later than the conversation did: the earliest seen stands.
+        firstAt: earlier?.firstAt != null && (firstAt === null || earlier.firstAt < firstAt) ? earlier.firstAt : firstAt,
+        ino: info.ino,
+        size: info.size,
+        mtimeMs: info.mtimeMs,
+        headHash: await headHash(handle, info.size),
+        offset: tail.end
+      };
+    } finally {
+      await handle.close();
+    }
+  }
+  async function readOnward(file, cached, info) {
+    const offset = cached.offset;
+    if (offset === null) return null;
+    if (info.ino !== cached.ino || info.size <= cached.size || info.size < offset) return null;
+    if (info.size - offset > TAIL_LIMIT_BYTES) return null;
+    const handle = await io.openRegular(file);
+    try {
+      const opened = handle.info;
+      if (opened.ino !== cached.ino || opened.size < offset || opened.size < cached.size) {
+        return null;
+      }
+      if (opened.size - offset > TAIL_LIMIT_BYTES) return null;
+      if (await headHash(handle, cached.size) !== cached.headHash) return null;
+      const from = offset > 0 ? offset - 1 : 0;
+      const read = await readExactly(handle, from, opened.size - from);
+      if (offset > 0 && read[0] !== NEWLINE2) return null;
+      const added = offset > 0 ? read.subarray(1) : read;
+      const next = {
+        ...cached,
+        ino: opened.ino,
+        size: opened.size,
+        mtimeMs: opened.mtimeMs,
+        headHash: await headHash(handle, opened.size)
+      };
+      let start = 0;
+      let newline = added.indexOf(NEWLINE2);
+      while (newline !== -1) {
+        const step = readStepLine(added.toString("utf8", start, newline));
+        if (step) addStep(next, step);
+        start = newline + 1;
+        newline = added.indexOf(NEWLINE2, start);
+      }
+      if (start < added.byteLength) {
+        const step = readStepLine(added.toString("utf8", start));
+        if (step) addStep(next, step);
+      }
+      next.offset = offset + start;
+      if (next.firstAt === null && offset === 0) {
+        next.firstAt = await readFirstAt(handle, opened.size);
+      }
+      return next;
+    } finally {
+      await handle.close();
+    }
+  }
+  return {
+    async read(file, info) {
+      const cached = cache.get(file);
+      if (cached && cached.ino === info.ino && cached.size === info.size && cached.mtimeMs === info.mtimeMs) {
+        return stateOf(cached);
+      }
+      const next = cached && await readOnward(file, cached, info) || await readFresh(file, cached);
+      cache.set(file, next);
+      return stateOf(next);
+    },
+    keepOnly(files) {
+      for (const file of cache.keys()) {
+        if (!files.has(file)) cache.delete(file);
+      }
+    }
+  };
+}
+
+// src/collector/adapters/antigravity/index.ts
+var ANTIGRAVITY_HOME_ENV = "AGENT_LOOKOUT_ANTIGRAVITY_HOME";
+var DEFAULT_HOME = [".gemini", "antigravity-cli"];
+var RECHECK_MS = 6e4;
+var PROCESS_CHECK_MS = 1e4;
+var PROMPT_PROCESS_CHECK_MS = 2e3;
+var BASIS = "files";
+var BASIS_WITHOUT_PROCESSES = "files-without-processes";
+var BASIS_UNMATCHED = "files-unmatched";
+var LABEL2 = "Antigravity CLI";
+var NEEDS_YOU_NOTE = "A session needs you while agy asks you to approve a tool, which its own log records. A question it asks you is not known to be recorded, so it shows as working.";
+var UNCHECKED_NOTE = "This was checked against one agy 1.3.1 conversation, and parts of it, such as /resume, are not yet checked, so a status can be wrong.";
+var ALWAYS_NOTES = `${NEEDS_YOU_NOTE} ${UNCHECKED_NOTE}`;
+var UNKNOWN_STEP_NOTE = "Some conversations end with a step Agent Lookout does not know, perhaps from a newer agy, so they show as unknown.";
+var UNMATCHED_NOTE = "An agy program is running that has not written to a conversation since it started, so none is shown as finished until it does.";
+var ANTIGRAVITY_CAPABILITIES = {
+  "working-and-idle": { level: "yes" },
+  "needs-you": {
+    level: "partly",
+    reason: "While agy asks you to approve a tool, from its own log. A question it asks you shows as working."
+  },
+  finished: {
+    level: "partly",
+    reason: "Once ps shows no agy program running that could have the conversation open. Not on Windows."
+  },
+  failed: {
+    level: "partly",
+    reason: "Only when agy records an error of its own or a failed reply. A tool that fails shows as working."
+  },
+  names: {
+    level: "partly",
+    reason: "The title agy gives a conversation once it has one, and the folder its program's log names. Until then, its conversation ID."
+  },
+  jump: {
+    level: "no",
+    reason: "The transcripts name no terminal, and agy documents no link that opens a conversation."
+  },
+  "quiet-for": { level: "yes" },
+  stop: {
+    level: "no",
+    reason: "No agy program is tied to one conversation surely enough for Agent Lookout to confirm it and stop it."
+  },
+  answer: {
+    level: "no",
+    reason: "Its approval prompt takes an answer only in the terminal agy runs in."
+  }
+};
+function withLoggedConversations(programs, logStates) {
+  return programs.map((program, index) => {
+    const current = logStates[index]?.current ?? null;
+    return current === null ? program : { ...program, conversation: current };
+  });
+}
+function folderOf(id, logs) {
+  const open2 = logs.find((log) => log.current === id && log.folder !== null);
+  if (open2) return open2.folder;
+  return logs.find((log) => log.opened.has(id) && log.folder !== null)?.folder ?? null;
+}
+function createAntigravityAdapter(options = {}) {
+  const env = options.env ?? process.env;
+  const homeDir = options.homeDir ?? os5.homedir();
+  const now = options.now ?? Date.now;
+  const io = options.io ?? nodeIo2;
+  const platform = options.platform ?? process.platform;
+  const pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS;
+  const recheckMs = options.recheckMs ?? RECHECK_MS;
+  const processCheckMs = options.processCheckMs ?? PROCESS_CHECK_MS;
+  const processes = options.processes ?? createAgyProcessReader({ platform });
+  const override = env[ANTIGRAVITY_HOME_ENV]?.trim() || void 0;
+  const homeFrom = override ? "agent-lookout" : "default";
+  const home = path14.resolve(override ?? path14.join(homeDir, ...DEFAULT_HOME));
+  const brainDir = path14.join(home, BRAIN_DIR);
+  const homeName = tildify(home, homeDir);
+  const brainName = tildify(brainDir, homeDir);
+  const finder = createConversationFinder({ home, io, oldRefreshMs: options.oldRefreshMs });
+  const reader = createTranscriptReader(io);
+  const logs = createAgyLogReader({ home, io, now });
+  const titles = createTitleReader({ home, io });
+  let absentAt = null;
+  let homeSeen = false;
+  let lastProcesses = null;
+  let processesAt = null;
+  let lastHolding = null;
+  const commandRun = platform === "win32" ? "not run on Windows" : `${every(processCheckMs)} at most`;
+  function watching(read) {
+    return [
+      { label: "Conversations folder", value: brainName },
+      { label: "Read", value: read },
+      { label: "Command", value: `ps ${AGY_TABLE_ARGS.join(" ")}` },
+      { label: "Command run", value: commandRun }
+    ];
+  }
+  function result(state, detail, read, checkedAt, basis = BASIS) {
+    const health = {
+      id: SOURCE_ID2,
+      label: LABEL2,
+      state,
+      detail,
+      watching: watching(read),
+      checkedAt
+    };
+    return state === "ok" ? { health, sessions: [], basis } : { health, sessions: [] };
+  }
+  function notFound(checkedAt) {
+    lastProcesses = null;
+    processesAt = null;
+    lastHolding = null;
+    return result(
+      "unavailable",
+      `The Antigravity CLI was not found: there is no ${homeName} folder. Agent Lookout looks again ${every(recheckMs)}.`,
+      "not found",
+      checkedAt
+    );
+  }
+  async function homeIsThere() {
+    try {
+      return (await io.stat(home)).kind === "directory";
+    } catch (error) {
+      return !isMissing2(error);
+    }
+  }
+  async function processesFor(conversations, checkedAt) {
+    const shown = conversations.some(
+      (files) => writtenRecently(files, checkedAt) || lastHolding?.held.has(files.id)
+    );
+    if (!shown) return null;
+    const since = processesAt === null ? Infinity : checkedAt - processesAt;
+    let due = since < 0 || since >= processCheckMs;
+    if (!due && since >= PROMPT_PROCESS_CHECK_MS && lastProcesses?.ok) {
+      const holding = holdConversations(lastProcesses.sessions, conversations);
+      due = conversations.some(
+        (files) => files.writtenAt !== null && files.writtenAt > processesAt && !holding.held.has(files.id)
+      );
+    }
+    if (due) {
+      lastProcesses = await processes.read();
+      processesAt = checkedAt;
+    }
+    return lastProcesses;
+  }
+  async function poll() {
+    const checkedAt = now();
+    if (homeFrom !== "agent-lookout") {
+      if (absentAt !== null) {
+        const since = checkedAt - absentAt;
+        if (since >= 0 && since < recheckMs) return notFound(checkedAt);
+      }
+      if (!homeSeen) {
+        if (!await homeIsThere()) {
+          absentAt = checkedAt;
+          return notFound(checkedAt);
+        }
+        absentAt = null;
+        homeSeen = true;
+      }
+    }
+    const listing = await finder.list(checkedAt, (id) => lastHolding?.held.has(id) ?? false);
+    if (listing.state === "unreadable") {
+      return result(
+        "error",
+        `Antigravity CLI conversations could not be read: the folder ${brainName} could not be listed.`,
+        "cannot be read",
+        checkedAt
+      );
+    }
+    if (listing.state === "missing") {
+      lastHolding = null;
+      if (homeFrom === "agent-lookout") {
+        return result(
+          "ok",
+          `${ANTIGRAVITY_HOME_ENV} is set to ${homeName}, which has no ${BRAIN_DIR} folder, so no Antigravity CLI sessions are listed. ${ALWAYS_NOTES}`,
+          "not found",
+          checkedAt
+        );
+      }
+      homeSeen = false;
+      if (!await homeIsThere()) {
+        absentAt = checkedAt;
+        return notFound(checkedAt);
+      }
+      homeSeen = true;
+      return result(
+        "ok",
+        `The Antigravity CLI has not saved any conversations in ${brainName} yet. ${ALWAYS_NOTES}`,
+        "not found",
+        checkedAt
+      );
+    }
+    const { conversations } = listing;
+    const list = await processesFor(conversations, checkedAt);
+    const logStates = list?.ok ? await logs.read(list.sessions) : [];
+    const programs = list?.ok ? withLoggedConversations(list.sessions, logStates) : [];
+    const holding = list?.ok ? holdConversations(programs, conversations, processesAt) : null;
+    lastHolding = holding;
+    const logged = logStates.filter((state) => state !== null);
+    const read = /* @__PURE__ */ new Set();
+    const sessions = [];
+    let unknownStep = false;
+    for (const files of conversations) {
+      const open2 = holding?.held.has(files.id) ?? false;
+      if (files.transcriptInfo === null || !(open2 || writtenRecently(files, checkedAt))) continue;
+      let state;
+      try {
+        state = await reader.read(files.transcript, files.transcriptInfo);
+      } catch {
+        read.add(files.transcript);
+        continue;
+      }
+      read.add(files.transcript);
+      const ask = logged.find((log) => log.ask?.conversation === files.id)?.ask ?? null;
+      const waiting = ask !== null && waitsForApproval(ask, files.id, state.lastIndex) ? { tool: ask.tool, since: agyLogTimeAt(ask.at, checkedAt) } : null;
+      const session = antigravitySession({
+        conversationId: files.id,
+        state,
+        live: antigravityLiveness(files.id, holding),
+        waiting,
+        title: await titles.read(files.id),
+        folder: folderOf(files.id, logged),
+        writtenAt: files.lastWriteAt,
+        now: checkedAt
+      });
+      if (session.status === "unknown") unknownStep = true;
+      sessions.push(session);
+    }
+    reader.keepOnly(read);
+    titles.keepOnly(new Set(sessions.map((session) => session.id.slice(SOURCE_ID2.length + 1))));
+    let detail = `Sessions are read from the transcripts the Antigravity CLI keeps in ${brainName}. ${ALWAYS_NOTES}`;
+    let basis = BASIS;
+    if (list !== null && !list.ok) {
+      detail += platform === "win32" ? " Windows has no ps to tell which conversations agy has open, so none is shown as finished." : " ps could not be run to tell which conversations agy has open, so none is shown as finished.";
+      basis = BASIS_WITHOUT_PROCESSES;
+    } else if (holding !== null && !holding.complete) {
+      detail += ` ${UNMATCHED_NOTE}`;
+      basis = BASIS_UNMATCHED;
+    }
+    if (unknownStep) detail += ` ${UNKNOWN_STEP_NOTE}`;
+    const answer = result("ok", detail, every(pollIntervalMs), checkedAt, basis);
+    return { ...answer, sessions };
+  }
+  return {
+    id: SOURCE_ID2,
+    label: LABEL2,
+    capabilities: ANTIGRAVITY_CAPABILITIES,
+    lookingIn: `Looking for Antigravity CLI sessions in ${brainName}.`,
+    async poll() {
+      try {
+        return await poll();
+      } catch {
+        return result(
+          "error",
+          "Something unexpected went wrong while reading Antigravity CLI sessions.",
+          every(pollIntervalMs),
+          now()
+        );
+      }
+    }
+  };
+}
+
+// src/collector/adapters/codex/index.ts
+import os6 from "node:os";
+import path16 from "node:path";
+
+// src/core/mapping/codexMapping.ts
+var TURN_UNDER_WAY = /* @__PURE__ */ new Set(["task_started", "turn_started"]);
+var TURN_OVER2 = /* @__PURE__ */ new Set(["task_complete", "turn_complete", "turn_aborted"]);
+function mapCodexStatus(fields) {
+  const { lastTurn, live: live2 } = fields;
+  let open2;
+  if (lastTurn === null) {
+    open2 = "idle";
+  } else if (typeof lastTurn !== "string") {
+    return "unknown";
+  } else if (TURN_UNDER_WAY.has(lastTurn)) {
+    open2 = "working";
+  } else if (TURN_OVER2.has(lastTurn)) {
+    open2 = "idle";
+  } else {
+    return "unknown";
+  }
+  return live2 === false ? "finished" : open2;
+}
+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})?$/;
+function keepsWriterLocks(cliVersion) {
+  if (typeof cliVersion !== "string") return false;
+  const match = VERSION.exec(cliVersion);
+  if (!match) return false;
+  const parts = [Number(match[1]), Number(match[2]), Number(match[3])];
+  for (const [index, since] of WRITER_LOCKS_SINCE.entries()) {
+    const part = parts[index];
+    if (part !== since) return part > since;
+  }
+  return match[4] === void 0;
+}
+function codexLiveness(fields) {
+  if (!fields.lockFolder) return "unknown";
+  if (fields.locked) return true;
+  return keepsWriterLocks(fields.cliVersion) ? false : "unknown";
+}
+var IMPORTED_TURN_ID = /^external-import-turn-\d{1,9}$/;
+function isImportedCodexTurn(turnId) {
+  return typeof turnId === "string" && IMPORTED_TURN_ID.test(turnId);
+}
+function isRecord9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var CODEX_DESKTOP_ORIGINATOR = "Codex Desktop";
+function mapCodexSurface(source, originator) {
+  if (originator === CODEX_DESKTOP_ORIGINATOR) return "desktop";
+  if (source === "cli" || source === "exec") return "terminal";
+  if (source === "vscode") return "vscode";
+  if (isRecord9(source) && source.custom === "chatgpt") return "desktop";
+  return "unknown";
+}
+var NOT_A_SESSION_SOURCE = /* @__PURE__ */ new Set(["subagent", "internal", "mcp"]);
+var NOT_A_SESSION_THREAD = /* @__PURE__ */ new Set(["subagent", "guardian_review", "memory_consolidation"]);
+function isCodexSessionSource(source, meta = {}) {
+  if (typeof meta.parentThreadId === "string" && meta.parentThreadId !== "") return false;
+  if (typeof meta.threadSource === "string" && NOT_A_SESSION_THREAD.has(meta.threadSource)) {
+    return false;
+  }
+  if (typeof source === "string") return !NOT_A_SESSION_SOURCE.has(source);
+  if (isRecord9(source)) return !Object.keys(source).some((kind) => NOT_A_SESSION_SOURCE.has(kind));
+  return true;
+}
+
+// src/collector/adapters/codex/rolloutFile.ts
+var HEAD_LIMIT_BYTES2 = 2 * 1024 * 1024;
+var TAIL_LIMIT_BYTES2 = 8 * 1024 * 1024;
+var FIRST_HEAD_BYTES = 256 * 1024;
+var TAIL_CHUNK_BYTES2 = 256 * 1024;
+var NEWLINE3 = 10;
+var CODEX_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/;
+function parseCodexTime(value) {
+  if (typeof value !== "string" || !CODEX_TIME.test(value)) return null;
+  const at = Date.parse(value);
+  return Number.isSafeInteger(at) ? at : null;
+}
+var LINE_TIME = /^\{"timestamp":"([^"]{1,64})"/;
+var TURN_HINT = /"type":"(?:task|turn)_/;
+var TURN_TYPE = /^(?:task|turn)_/;
+function isRecord10(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function text3(value) {
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function label(value) {
+  return typeof value === "string" && value !== "" && value.length <= 64 ? value : void 0;
+}
+function compactSource(value) {
+  if (typeof value === "string") return text3(value);
+  if (!isRecord10(value)) return void 0;
+  return Object.fromEntries(
+    Object.entries(value).map(([kind, detail]) => [
+      kind,
+      typeof detail === "string" ? detail : true
+    ])
+  );
+}
+function parse(line) {
+  try {
+    const value = JSON.parse(line);
+    return isRecord10(value) ? value : null;
+  } catch {
+    return null;
+  }
 }
-function parse(line) {
-  try {
-    const value = JSON.parse(line);
-    return isRecord9(value) ? value : null;
-  } catch {
-    return null;
-  }
-}
 function readMetaLine(line) {
   if (!line.includes('"session_meta"')) return null;
   const value = parse(line);
-  if (!value || value.type !== "session_meta" || !isRecord9(value.payload)) return null;
+  if (!value || value.type !== "session_meta" || !isRecord10(value.payload)) return null;
   const payload = value.payload;
   const meta = {
     id: text3(payload.id),
@@ -6347,7 +7976,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" || !isRecord9(value.payload)) return null;
+  if (!value || value.type !== "event_msg" || !isRecord10(value.payload)) return null;
   const turn = value.payload.type;
   if (typeof turn !== "string" || !TURN_TYPE.test(turn)) return null;
   return {
@@ -6360,23 +7989,23 @@ function lineTime(line) {
   const match = LINE_TIME.exec(line);
   return match ? parseCodexTime(match[1]) : null;
 }
-function bytes(data) {
+function bytes2(data) {
   return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
 }
-async function readExactly(file, position, length) {
-  const data = bytes(await file.read(position, length));
+async function readExactly2(file, position, length) {
+  const data = bytes2(await file.read(position, length));
   if (data.byteLength !== length) throw new Error("The file changed while it was read.");
   return data;
 }
 async function readHead(file, size) {
-  for (const limit of [FIRST_HEAD_BYTES, HEAD_LIMIT_BYTES]) {
+  for (const limit of [FIRST_HEAD_BYTES, HEAD_LIMIT_BYTES2]) {
     const length = Math.min(limit, size);
-    const head = await readExactly(file, 0, length);
+    const head = await readExactly2(file, 0, length);
     let named = head.indexOf('"session_meta"');
     while (named !== -1) {
-      const end = head.indexOf(NEWLINE, named);
+      const end = head.indexOf(NEWLINE3, named);
       if (end === -1) break;
-      const start = named > 0 ? head.lastIndexOf(NEWLINE, named - 1) + 1 : 0;
+      const start = named > 0 ? head.lastIndexOf(NEWLINE3, named - 1) + 1 : 0;
       const meta = readMetaLine(head.toString("utf8", start, end));
       if (meta) return meta;
       named = head.indexOf('"session_meta"', end + 1);
@@ -6385,9 +8014,9 @@ async function readHead(file, size) {
   }
   return null;
 }
-async function scanTail(file, size) {
+async function scanTail2(file, size) {
   let position = size;
-  let budget2 = TAIL_LIMIT_BYTES;
+  let budget2 = TAIL_LIMIT_BYTES2;
   let fragment = Buffer.alloc(0);
   let end = null;
   let lastLineAt = null;
@@ -6405,15 +8034,15 @@ async function scanTail(file, size) {
     end
   });
   while (position > 0 && budget2 > 0) {
-    const length = Math.min(TAIL_CHUNK_BYTES, position, budget2);
+    const length = Math.min(TAIL_CHUNK_BYTES2, position, budget2);
     const start = position - length;
-    const chunk = await readExactly(file, start, length);
+    const chunk = await readExactly2(file, start, length);
     budget2 -= length;
     position = start;
     const buffer = fragment.byteLength > 0 ? Buffer.concat([chunk, fragment]) : chunk;
     let cut2 = buffer.byteLength;
     if (end === null) {
-      const last = buffer.lastIndexOf(NEWLINE);
+      const last = buffer.lastIndexOf(NEWLINE3);
       if (last === -1) {
         fragment = buffer;
         continue;
@@ -6421,12 +8050,12 @@ async function scanTail(file, size) {
       end = start + last + 1;
       cut2 = last;
     }
-    let newline = cut2 > 0 ? buffer.lastIndexOf(NEWLINE, cut2 - 1) : -1;
+    let newline = cut2 > 0 ? buffer.lastIndexOf(NEWLINE3, cut2 - 1) : -1;
     while (newline !== -1) {
       const turn = take(buffer.toString("utf8", newline + 1, cut2));
       if (turn) return found(turn);
       cut2 = newline;
-      newline = cut2 > 0 ? buffer.lastIndexOf(NEWLINE, cut2 - 1) : -1;
+      newline = cut2 > 0 ? buffer.lastIndexOf(NEWLINE3, cut2 - 1) : -1;
     }
     if (start === 0) {
       const turn = take(buffer.toString("utf8", 0, cut2));
@@ -6440,7 +8069,7 @@ async function scanTail(file, size) {
   }
   return { lastTurn: void 0, lastTurnAt: null, lastTurnImported: false, lastLineAt, end };
 }
-function stateOf(cached) {
+function stateOf2(cached) {
   return {
     meta: cached.meta,
     lastTurn: cached.lastTurn,
@@ -6456,7 +8085,7 @@ function createRolloutReader(io) {
     try {
       const { info } = handle;
       const meta = await readHead(handle, info.size);
-      const tail = await scanTail(handle, info.size);
+      const tail = await scanTail2(handle, info.size);
       return {
         meta,
         lastTurn: tail.lastTurn,
@@ -6476,14 +8105,14 @@ function createRolloutReader(io) {
     const offset = cached.offset;
     if (cached.meta === null || offset === null) return null;
     if (info.ino !== cached.ino || info.size <= cached.size || info.size < offset) return null;
-    if (info.size - offset > TAIL_LIMIT_BYTES) return null;
+    if (info.size - offset > TAIL_LIMIT_BYTES2) return null;
     const handle = await io.openRegular(file);
     try {
       const opened = handle.info;
       if (opened.ino !== cached.ino || opened.size < offset) return null;
       const from = offset > 0 ? offset - 1 : 0;
-      const read = await readExactly(handle, from, opened.size - from);
-      if (offset > 0 && read[0] !== NEWLINE) return null;
+      const read = await readExactly2(handle, from, opened.size - from);
+      if (offset > 0 && read[0] !== NEWLINE3) return null;
       const added = offset > 0 ? read.subarray(1) : read;
       const next = {
         ...cached,
@@ -6492,7 +8121,7 @@ function createRolloutReader(io) {
         mtimeMs: opened.mtimeMs
       };
       let start = 0;
-      let newline = added.indexOf(NEWLINE);
+      let newline = added.indexOf(NEWLINE3);
       while (newline !== -1) {
         const line = added.toString("utf8", start, newline);
         if (line.trim() !== "") {
@@ -6506,7 +8135,7 @@ function createRolloutReader(io) {
           }
         }
         start = newline + 1;
-        newline = added.indexOf(NEWLINE, start);
+        newline = added.indexOf(NEWLINE3, start);
       }
       next.offset = offset + start;
       return next;
@@ -6518,11 +8147,11 @@ function createRolloutReader(io) {
     async read(file, info) {
       const cached = cache.get(file);
       if (cached && cached.ino === info.ino && cached.size === info.size && cached.mtimeMs === info.mtimeMs) {
-        return stateOf(cached);
+        return stateOf2(cached);
       }
       const next = cached && await readOnward(file, cached, info) || await readFresh(file);
       cache.set(file, next);
-      return stateOf(next);
+      return stateOf2(next);
     },
     keepOnly(files) {
       for (const file of cache.keys()) {
@@ -6533,10 +8162,10 @@ function createRolloutReader(io) {
 }
 
 // src/collector/adapters/codex/rollouts.ts
-import path11 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}";
+import path15 from "node:path";
+var UUID4 = "[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$`,
+  `^rollout-\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2}-\\d{2}-(${UUID4})(?:_(${UUID4}))?\\.jsonl$`,
   "i"
 );
 var INDEX_REFRESH_MS = 3e4;
@@ -6551,7 +8180,7 @@ function twoDigits(value) {
 function recentDayFolders(sessionsDir, now) {
   const folders = [now, now - 24 * 60 * 60 * 1e3].map((at) => {
     const date = new Date(at);
-    return path11.join(
+    return path15.join(
       sessionsDir,
       String(date.getFullYear()),
       twoDigits(date.getMonth() + 1),
@@ -6580,12 +8209,12 @@ function createRolloutFinder(options) {
     const refs = [];
     for (const name of (await names(dir)).sort()) {
       const threadId = threadIdOfRollout(name);
-      if (threadId !== null) refs.push({ path: path11.join(dir, name), threadId });
+      if (threadId !== null) refs.push({ path: path15.join(dir, name), threadId });
     }
     return refs;
   }
   async function subfolders(dir, pattern) {
-    return (await names(dir)).filter((name) => pattern.test(name)).sort().map((name) => path11.join(dir, name));
+    return (await names(dir)).filter((name) => pattern.test(name)).sort().map((name) => path15.join(dir, name));
   }
   async function buildIndex() {
     const years = await subfolders(sessionsDir, YEAR);
@@ -6629,7 +8258,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 isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseSessionIndex(content) {
@@ -6642,7 +8271,7 @@ function parseSessionIndex(content) {
     } catch {
       continue;
     }
-    if (!isRecord10(value)) continue;
+    if (!isRecord11(value)) continue;
     const { id, thread_name: name } = value;
     if (typeof id !== "string" || id === "" || typeof name !== "string") continue;
     const trimmed = name.trim();
@@ -6693,14 +8322,14 @@ function createSessionIndexReader(file, io) {
 }
 
 // src/collector/adapters/codex/toSession.ts
-var SOURCE_ID2 = "codex";
-var WRITE_ORDER_SLACK_MS2 = 1e3;
+var SOURCE_ID3 = "codex";
+var WRITE_ORDER_SLACK_MS3 = 1e3;
 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: live2, now } = input;
-  const id = `${SOURCE_ID2}:${threadId}`;
+  const id = `${SOURCE_ID3}:${threadId}`;
   const cwd = state.meta?.cwd ?? null;
   const project = projectOf(cwd);
   const status = mapCodexStatus({ lastTurn: state.lastTurn, live: live2 });
@@ -6711,12 +8340,12 @@ function codexSession(input) {
   } else if (status === "idle" || status === "finished") {
     statusSince = plausibleTime(state.lastLineAt, now);
   }
-  if (statusSince !== null && startedAt !== null && statusSince < startedAt - WRITE_ORDER_SLACK_MS2) {
+  if (statusSince !== null && startedAt !== null && statusSince < startedAt - WRITE_ORDER_SLACK_MS3) {
     statusSince = null;
   }
   const session = {
     id,
-    source: SOURCE_ID2,
+    source: SOURCE_ID3,
     surface: mapCodexSurface(state.meta?.source, state.meta?.originator),
     // A name made only of spaces is no name. It is cleaned and cut as every other agent's is.
     name: sessionName(input.name ?? "") || project || id,
@@ -6729,7 +8358,7 @@ function codexSession(input) {
     stale: isStale({ status, statusSince }, now)
   };
   const writtenAt = input.writtenAt === void 0 ? null : plausibleTime(Math.floor(input.writtenAt), now);
-  const beforeStart = writtenAt !== null && startedAt !== null && writtenAt < startedAt - WRITE_ORDER_SLACK_MS2;
+  const beforeStart = writtenAt !== null && startedAt !== null && writtenAt < startedAt - WRITE_ORDER_SLACK_MS3;
   if (writtenAt !== null && !beforeStart) session.lastWriteAt = writtenAt;
   return session;
 }
@@ -6759,11 +8388,11 @@ async function readWriterLocks(dir, io) {
 // src/collector/adapters/codex/index.ts
 var CODEX_HOME_ENV = "AGENT_LOOKOUT_CODEX_HOME";
 var CODEX_OWN_HOME_ENV = "CODEX_HOME";
-var RECHECK_MS = 6e4;
-var BASIS = "files";
+var RECHECK_MS2 = 6e4;
+var BASIS2 = "files";
 var BASIS_WITHOUT_LOCKS = "files-without-locks";
-var LABEL2 = "Codex";
-var NEEDS_YOU_NOTE = "Codex's session files do not record when it is waiting for your approval, so a Codex session that is waiting for you shows as working.";
+var LABEL3 = "Codex";
+var NEEDS_YOU_NOTE2 = "Codex's session files do not record when it is waiting for your approval, so a Codex session that is waiting for you shows as working.";
 var OLDER_CODEX_NOTE = "Some sessions were started by a Codex older than 0.155, which does not record which sessions are open, so those are never shown as finished.";
 var CODEX_CAPABILITIES = {
   "working-and-idle": { level: "yes" },
@@ -6796,18 +8425,18 @@ var CODEX_CAPABILITIES = {
 };
 function createCodexAdapter(options = {}) {
   const env = options.env ?? process.env;
-  const homeDir = options.homeDir ?? os5.homedir();
+  const homeDir = options.homeDir ?? os6.homedir();
   const now = options.now ?? Date.now;
   const io = options.io ?? nodeIo2;
   const pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS;
-  const recheckMs = options.recheckMs ?? RECHECK_MS;
+  const recheckMs = options.recheckMs ?? RECHECK_MS2;
   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 = path12.resolve(ownOverride ?? codexOverride ?? path12.join(homeDir, ".codex"));
-  const sessionsDir = path12.join(codexHome, "sessions");
-  const locksDir = path12.join(codexHome, WRITER_LOCK_DIR);
-  const indexFile = path12.join(codexHome, SESSION_INDEX_FILE);
+  const codexHome = path16.resolve(ownOverride ?? codexOverride ?? path16.join(homeDir, ".codex"));
+  const sessionsDir = path16.join(codexHome, "sessions");
+  const locksDir = path16.join(codexHome, WRITER_LOCK_DIR);
+  const indexFile = path16.join(codexHome, SESSION_INDEX_FILE);
   const homeName = tildify(codexHome, homeDir);
   const sessionsName = tildify(sessionsDir, homeDir);
   const locksName = tildify(locksDir, homeDir);
@@ -6833,14 +8462,14 @@ function createCodexAdapter(options = {}) {
   }
   function result(state, detail, read, checkedAt) {
     const health = {
-      id: SOURCE_ID2,
-      label: LABEL2,
+      id: SOURCE_ID3,
+      label: LABEL3,
       state,
       detail,
       watching: watching(read),
       checkedAt
     };
-    return state === "ok" ? { health, sessions: [], basis: BASIS } : { health, sessions: [] };
+    return state === "ok" ? { health, sessions: [], basis: BASIS2 } : { health, sessions: [] };
   }
   function notFound(checkedAt) {
     const where = homeFrom === "codex" ? `${CODEX_OWN_HOME_ENV} is set to ${homeName}, and there is no folder there` : `there is no ${homeName} folder`;
@@ -6888,7 +8517,7 @@ function createCodexAdapter(options = {}) {
       if (homeFrom === "agent-lookout") {
         return result(
           "ok",
-          `${CODEX_HOME_ENV} is set to ${homeName}, which has no sessions folder, so no Codex sessions are listed. ${NEEDS_YOU_NOTE}`,
+          `${CODEX_HOME_ENV} is set to ${homeName}, which has no sessions folder, so no Codex sessions are listed. ${NEEDS_YOU_NOTE2}`,
           "not found",
           checkedAt
         );
@@ -6901,7 +8530,7 @@ function createCodexAdapter(options = {}) {
       homeSeen = true;
       return result(
         "ok",
-        `Codex has not saved any sessions in ${sessionsName} yet. ${NEEDS_YOU_NOTE}`,
+        `Codex has not saved any sessions in ${sessionsName} yet. ${NEEDS_YOU_NOTE2}`,
         "not found",
         checkedAt
       );
@@ -6983,7 +8612,7 @@ function createCodexAdapter(options = {}) {
         now: checkedAt
       });
     });
-    let detail = `Sessions are read from the files Codex saves in ${sessionsName}. ${NEEDS_YOU_NOTE}`;
+    let detail = `Sessions are read from the files Codex saves in ${sessionsName}. ${NEEDS_YOU_NOTE2}`;
     if (!locks.supported) {
       const why = locks.missing ? `There is no list of open sessions at ${locksName}, which Codex keeps from version 0.155 on` : `The list of open sessions at ${locksName} could not be read`;
       detail += ` ${why}, so a session that has ended cannot be told from one that is idle, and none is shown as finished.`;
@@ -6991,11 +8620,11 @@ function createCodexAdapter(options = {}) {
       detail += ` ${OLDER_CODEX_NOTE}`;
     }
     const answer = result("ok", detail, every(pollIntervalMs), checkedAt);
-    return { ...answer, sessions, basis: locks.supported ? BASIS : BASIS_WITHOUT_LOCKS };
+    return { ...answer, sessions, basis: locks.supported ? BASIS2 : BASIS_WITHOUT_LOCKS };
   }
   return {
-    id: SOURCE_ID2,
-    label: LABEL2,
+    id: SOURCE_ID3,
+    label: LABEL3,
     capabilities: CODEX_CAPABILITIES,
     lookingIn: `Looking for Codex sessions in ${sessionsName}.`,
     async poll() {
@@ -7014,8 +8643,8 @@ function createCodexAdapter(options = {}) {
 }
 
 // src/collector/adapters/status-files/index.ts
-import os6 from "node:os";
-import path13 from "node:path";
+import os7 from "node:os";
+import path17 from "node:path";
 
 // src/core/mapping/statusFileMapping.ts
 var STATUS = /* @__PURE__ */ new Map([
@@ -7095,16 +8724,16 @@ function parseStatusFile(content) {
 }
 
 // src/collector/adapters/status-files/toSession.ts
-var SOURCE_ID3 = "status-files";
-var WRITE_ORDER_SLACK_MS3 = 1e3;
+var SOURCE_ID4 = "status-files";
+var WRITE_ORDER_SLACK_MS4 = 1e3;
 function statusFileSession(input) {
   const { fileName: fileName2, file, statusSince, now } = input;
   const cwd = file.cwd ?? null;
   const project = projectOf(cwd);
   const mapped = mapStatusFileStatus(file);
   const session = {
-    id: `${SOURCE_ID3}:${fileName2}`,
-    source: SOURCE_ID3,
+    id: `${SOURCE_ID4}:${fileName2}`,
+    source: SOURCE_ID4,
     agent: file.agent,
     surface: mapStatusFileApp(file.app),
     // The file's name is as untrusted as its contents, so it is cleaned and cut
@@ -7124,15 +8753,15 @@ function statusFileSession(input) {
   }
   const writtenAt = input.writtenAt === void 0 ? null : plausibleTime(Math.floor(input.writtenAt), now);
   const given = plausibleTime(file.since, now);
-  const beforeSince = writtenAt !== null && given !== null && writtenAt < given - WRITE_ORDER_SLACK_MS3;
+  const beforeSince = writtenAt !== null && given !== null && writtenAt < given - WRITE_ORDER_SLACK_MS4;
   if (writtenAt !== null && !beforeSince) session.lastWriteAt = writtenAt;
   return session;
 }
 
 // src/collector/adapters/status-files/index.ts
 var STATUS_DIR_ENV = "AGENT_LOOKOUT_STATUS_DIR";
-var BASIS2 = "files";
-var LABEL3 = "Status files";
+var BASIS3 = "files";
+var LABEL4 = "Status files";
 var STATUS_FILE_CAPABILITIES = {
   "working-and-idle": { level: "partly", reason: "If the agent writes working and idle." },
   "needs-you": { level: "partly", reason: "If the agent writes waiting." },
@@ -7158,13 +8787,13 @@ function counted(count2, one, many) {
 }
 function createStatusFileAdapter(options = {}) {
   const env = options.env ?? process.env;
-  const homeDir = options.homeDir ?? os6.homedir();
+  const homeDir = options.homeDir ?? os7.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 = path13.resolve(override ?? path13.join(homeDir, ".agent-lookout", "sessions"));
+  const dir = path17.resolve(override ?? path17.join(homeDir, ".agent-lookout", "sessions"));
   const dirName = tildify(dir, homeDir);
   const decoder2 = new TextDecoder();
   let lastRead = /* @__PURE__ */ new Map();
@@ -7185,15 +8814,15 @@ function createStatusFileAdapter(options = {}) {
   }
   function result(state, detail, facts, checkedAt, sessions = []) {
     const health = {
-      id: SOURCE_ID3,
-      label: LABEL3,
+      id: SOURCE_ID4,
+      label: LABEL4,
       state,
       detail,
       watching: facts,
       checkedAt
     };
-    if (state === "ok") return { health, sessions, basis: BASIS2 };
-    if (state === "not-set-up") return { health, sessions: [], basis: BASIS2 };
+    if (state === "ok") return { health, sessions, basis: BASIS3 };
+    if (state === "not-set-up") return { health, sessions: [], basis: BASIS3 };
     return { health, sessions: [] };
   }
   async function readOne(file) {
@@ -7209,9 +8838,9 @@ function createStatusFileAdapter(options = {}) {
     const tooLarge = { kind: "refused", why: "is over 16 KB" };
     try {
       if (open2.info.size > MAX_FILE_BYTES) return tooLarge;
-      const bytes2 = await open2.read(0, MAX_FILE_BYTES + 1);
-      if (bytes2.byteLength > MAX_FILE_BYTES) return tooLarge;
-      const parsed = parseStatusFile(decoder2.decode(bytes2));
+      const bytes3 = await open2.read(0, MAX_FILE_BYTES + 1);
+      if (bytes3.byteLength > MAX_FILE_BYTES) return tooLarge;
+      const parsed = parseStatusFile(decoder2.decode(bytes3));
       return parsed ? { kind: "read", file: parsed, mtimeMs: open2.info.mtimeMs } : { kind: "invalid" };
     } catch {
       return { kind: "refused", why: "could not be read" };
@@ -7224,7 +8853,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(path13.join(dir, name)).catch(() => null);
+        const info = await io.lstat(path17.join(dir, name)).catch(() => null);
         return { name, mtimeMs: info?.mtimeMs ?? -Infinity };
       })
     );
@@ -7274,7 +8903,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(path13.join(dir, fileName2));
+      const reading = await readOne(path17.join(dir, fileName2));
       let kept;
       if (reading.kind === "read") {
         kept = reading;
@@ -7340,8 +8969,8 @@ function createStatusFileAdapter(options = {}) {
     );
   }
   return {
-    id: SOURCE_ID3,
-    label: LABEL3,
+    id: SOURCE_ID4,
+    label: LABEL4,
     capabilities: STATUS_FILE_CAPABILITIES,
     lookingIn: `Looking for status files in ${dirName}.`,
     async poll() {
@@ -7500,8 +9129,8 @@ function createEventStore(capacity = EVENT_CAPACITY) {
 }
 
 // src/collector/git/branchFinder.ts
-import os7 from "node:os";
-import path15 from "node:path";
+import os8 from "node:os";
+import path19 from "node:path";
 
 // src/collector/git/gitHead.ts
 var MAX_GIT_FILE_BYTES = 4 * 1024;
@@ -7540,19 +9169,19 @@ function parseCommonDir(content) {
 }
 
 // src/collector/git/repository.ts
-import { createHash as createHash2 } from "node:crypto";
-import path14 from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import path18 from "node:path";
 var REPOSITORY_ID_LENGTH = 16;
 function repositoryId(gitFolder) {
-  return createHash2("sha256").update(gitFolder).digest("hex").slice(0, REPOSITORY_ID_LENGTH);
+  return createHash3("sha256").update(gitFolder).digest("hex").slice(0, REPOSITORY_ID_LENGTH);
 }
 function sharedName(common) {
-  const base = path14.basename(common);
-  if (base.startsWith(".")) return path14.basename(path14.dirname(common));
+  const base = path18.basename(common);
+  if (base.startsWith(".")) return path18.basename(path18.dirname(common));
   return base.endsWith(".git") ? base.slice(0, -".git".length) : base;
 }
 function repositoryOf({ dir, gitDir, commonDir }) {
-  const name = sessionName(commonDir === null ? path14.basename(dir) : sharedName(commonDir));
+  const name = sessionName(commonDir === null ? path18.basename(dir) : sharedName(commonDir));
   return name === void 0 ? null : { id: repositoryId(commonDir ?? gitDir), name };
 }
 
@@ -7570,9 +9199,9 @@ async function readGitFile(io, file, maxBytes = MAX_GIT_FILE_BYTES) {
   }
   try {
     if (open2.info.size > maxBytes) return null;
-    const bytes2 = await open2.read(0, maxBytes + 1);
-    if (bytes2.byteLength > maxBytes) return null;
-    return decoder.decode(bytes2);
+    const bytes3 = await open2.read(0, maxBytes + 1);
+    if (bytes3.byteLength > maxBytes) return null;
+    return decoder.decode(bytes3);
   } catch {
     return null;
   } finally {
@@ -7581,13 +9210,13 @@ async function readGitFile(io, file, maxBytes = MAX_GIT_FILE_BYTES) {
   }
 }
 async function commonDirOf(io, gitDir) {
-  const content = await readGitFile(io, path15.join(gitDir, "commondir"));
+  const content = await readGitFile(io, path19.join(gitDir, "commondir"));
   if (content === void 0) return null;
   const target = content === null ? null : parseCommonDir(content);
-  return target === null ? void 0 : path15.resolve(gitDir, target);
+  return target === null ? void 0 : path19.resolve(gitDir, target);
 }
 async function headIn(dir, kind, io) {
-  const marker = path15.join(dir, ".git");
+  const marker = path19.join(dir, ".git");
   let gitDir;
   if (kind === "directory") {
     gitDir = marker;
@@ -7595,11 +9224,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 = path15.resolve(dir, target);
+    gitDir = path19.resolve(dir, target);
   } else {
     return null;
   }
-  const content = await readGitFile(io, path15.join(gitDir, "HEAD"));
+  const content = await readGitFile(io, path19.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;
@@ -7608,20 +9237,20 @@ async function headIn(dir, kind, io) {
   return { head: { ...head, repository }, gitFolder: commonDir ?? gitDir };
 }
 async function findHead(cwd, { io, homeDir }) {
-  if (!path15.isAbsolute(cwd)) return null;
-  const home = path15.resolve(homeDir);
-  let dir = path15.resolve(cwd);
+  if (!path19.isAbsolute(cwd)) return null;
+  const home = path19.resolve(homeDir);
+  let dir = path19.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 = path15.dirname(dir);
+    const parent = path19.dirname(dir);
     if (dir === home || dir === parent) return null;
     let kind;
     try {
-      kind = (await io.lstat(path15.join(dir, ".git"))).kind;
+      kind = (await io.lstat(path19.join(dir, ".git"))).kind;
     } catch (error) {
       if (!isMissing2(error)) return null;
       dir = parent;
@@ -7642,7 +9271,7 @@ function within(work, ms) {
   });
 }
 function createBranchFinder(options = {}) {
-  const where = { io: options.io ?? nodeIo2, homeDir: options.homeDir ?? os7.homedir() };
+  const where = { io: options.io ?? nodeIo2, homeDir: options.homeDir ?? os8.homedir() };
   const now = options.now ?? Date.now;
   const waitMs = options.waitMs ?? READ_WAIT_MS;
   const known = /* @__PURE__ */ new Map();
@@ -7704,14 +9333,14 @@ var STATUS_STATE = {
   PENDING: "pending",
   EXPECTED: "pending"
 };
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function textOf(value) {
   return typeof value === "string" ? value : "";
 }
 function checkOf(value) {
-  if (!isRecord11(value)) return null;
+  if (!isRecord12(value)) return null;
   const startedAt = Date.parse(textOf(value.startedAt));
   const at = Number.isNaN(startedAt) ? -Infinity : startedAt;
   if (value.__typename === "CheckRun") {
@@ -7747,7 +9376,7 @@ function checksOf(rollup) {
   for (const { state } of latest.values()) counts[state] += 1;
   return { state: checksStateOf(counts), ...counts };
 }
-function stateOf2(state, isDraft) {
+function stateOf3(state, isDraft) {
   if (state === "OPEN") return isDraft === true ? "draft" : "open";
   if (state === "MERGED") return "merged";
   if (state === "CLOSED") return "closed";
@@ -7760,9 +9389,9 @@ function readGhAnswer(stdout, repository) {
   } catch {
     return null;
   }
-  if (!isRecord11(data)) return null;
+  if (!isRecord12(data)) return null;
   const { number } = data;
-  const state = stateOf2(data.state, data.isDraft);
+  const state = stateOf3(data.state, data.isDraft);
   const title = typeof data.title === "string" ? sessionName(data.title) : void 0;
   if (!isPullRequestNumber(number) || state === null || title === void 0) return null;
   return {
@@ -7899,7 +9528,7 @@ function createGhAsker(options) {
 }
 
 // src/collector/git/pullRequestTarget.ts
-import path16 from "node:path";
+import path20 from "node:path";
 
 // src/collector/git/gitConfig.ts
 var MAX_CONFIG_BYTES = 64 * 1024;
@@ -8157,7 +9786,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, path16.join(gitFolder, "config"), MAX_CONFIG_BYTES);
+    const text4 = await readGitFile(io, path20.join(gitFolder, "config"), MAX_CONFIG_BYTES);
     if (typeof text4 !== "string") return null;
     const config = parseGitConfig(text4);
     const base = config === null ? null : baseRemoteOf(config);
@@ -8166,7 +9795,7 @@ async function readPullRequestTarget(gitFolder, branch, io = nodeIo2) {
     if (base.name !== null && isSafeRemoteName(base.name)) {
       const head = await readGitFile(
         io,
-        path16.join(gitFolder, "refs", "remotes", base.name, "HEAD")
+        path20.join(gitFolder, "refs", "remotes", base.name, "HEAD")
       );
       if (typeof head === "string") defaultBranch = parseRemoteHead(head, base.name);
     }
@@ -8337,7 +9966,7 @@ function createClearHistoryRoute(options) {
 }
 
 // src/collector/history/historyKeeper.ts
-import path17 from "node:path";
+import path21 from "node:path";
 
 // src/collector/history/historyFiles.ts
 import {
@@ -8637,7 +10266,7 @@ function createHistoryKeeper(options) {
   });
   const lock = createWriterLock({
     fs,
-    file: path17.join(dir, LOCK_FILE),
+    file: path21.join(dir, LOCK_FILE),
     pid: options.pid,
     now,
     isAlive: options.isAlive,
@@ -8663,7 +10292,7 @@ function createHistoryKeeper(options) {
     });
     return next;
   }
-  const full = (name) => path17.join(dir, name);
+  const full = (name) => path21.join(dir, name);
   function hold(record) {
     if (unusable !== null || !running) return;
     const line = encodeRecord(record);
@@ -8830,13 +10459,13 @@ function createHistoryKeeper(options) {
         continue;
       }
       let text4 = lead;
-      let bytes2 = lead.length;
+      let bytes3 = lead.length;
       let end = index;
       while (end < lines.length) {
         const lineBytes = byteLength(lines[end]);
-        if (bytes2 - lead.length + lineBytes > room) break;
+        if (bytes3 - lead.length + lineBytes > room) break;
         text4 += lines[end];
-        bytes2 += lineBytes;
+        bytes3 += lineBytes;
         end += 1;
       }
       const outcome = yield { name, text: text4 };
@@ -8849,7 +10478,7 @@ function createHistoryKeeper(options) {
       const parsed = readHistoryFileName(name);
       files.set(name, {
         ...parsed,
-        size: size + bytes2,
+        size: size + bytes3,
         first: known?.first ?? (record && { at: recordAt(record), kind: record.kind })
       });
       touched.add(name);
@@ -9077,8 +10706,8 @@ function createHistoryKeeper(options) {
       return { at: oldest.first.at, by: BEGINNING[oldest.first.kind] };
     },
     status() {
-      let bytes2 = 0;
-      for (const file of files.values()) bytes2 += file.size;
+      let bytes3 = 0;
+      for (const file of files.values()) bytes3 += file.size;
       let problem = unusable ?? failing;
       if (problem === null && writer === false) {
         problem = lock.heldByOtherSources ? "Another copy of Agent Lookout on this computer is writing the history, and it reads sessions from other folders than this one. This one keeps what it sees in memory, and takes over when that one stops." : "Another copy of Agent Lookout on this computer is writing the history. This one keeps what it sees in memory, and takes over when that one stops.";
@@ -9086,7 +10715,7 @@ function createHistoryKeeper(options) {
       return {
         where: "disk",
         folder,
-        bytes: bytes2,
+        bytes: bytes3,
         maxBytes,
         maxAgeMs,
         canClear: unusable === null && writer === true && lock.held,
@@ -9123,15 +10752,15 @@ function keptHistoryStore(store, keeper) {
 }
 
 // src/collector/history/historySettings.ts
-import { createHash as createHash3 } from "node:crypto";
-import os8 from "node:os";
-import path18 from "node:path";
+import { createHash as createHash4 } from "node:crypto";
+import os9 from "node:os";
+import path22 from "node:path";
 var HISTORY_ENV = "AGENT_LOOKOUT_HISTORY";
 var HISTORY_DIR_ENV = "AGENT_LOOKOUT_HISTORY_DIR";
-function readHistorySetup(env, homeDir = os8.homedir()) {
+function readHistorySetup(env, homeDir = os9.homedir()) {
   if (env[HISTORY_ENV]?.trim().toLowerCase() === "off") return { on: false };
   const override = env[HISTORY_DIR_ENV]?.trim() || void 0;
-  const dir = path18.resolve(override ?? path18.join(homeDir, ".agent-lookout", "history"));
+  const dir = path22.resolve(override ?? path22.join(homeDir, ".agent-lookout", "history"));
   return {
     on: true,
     dir,
@@ -9139,14 +10768,15 @@ function readHistorySetup(env, homeDir = os8.homedir()) {
     sources: sourcesFingerprint(env, homeDir)
   };
 }
-function sourcesFingerprint(env, homeDir = os8.homedir()) {
+function sourcesFingerprint(env, homeDir = os9.homedir()) {
   const set = (name) => env[name]?.trim() || void 0;
   const folders = [
-    path18.resolve(set(CLAUDE_HOME_ENV) ?? path18.join(homeDir, ".claude")),
-    path18.resolve(set(CODEX_HOME_ENV) ?? set(CODEX_OWN_HOME_ENV) ?? path18.join(homeDir, ".codex")),
-    path18.resolve(set(STATUS_DIR_ENV) ?? path18.join(homeDir, ".agent-lookout", "sessions"))
+    path22.resolve(set(CLAUDE_HOME_ENV) ?? path22.join(homeDir, ".claude")),
+    path22.resolve(set(CODEX_HOME_ENV) ?? set(CODEX_OWN_HOME_ENV) ?? path22.join(homeDir, ".codex")),
+    path22.resolve(set(STATUS_DIR_ENV) ?? path22.join(homeDir, ".agent-lookout", "sessions")),
+    path22.resolve(set(ANTIGRAVITY_HOME_ENV) ?? path22.join(homeDir, ...DEFAULT_HOME))
   ];
-  return createHash3("sha256").update(JSON.stringify(folders)).digest("hex").slice(0, 32);
+  return createHash4("sha256").update(JSON.stringify(folders)).digest("hex").slice(0, 32);
 }
 
 // src/collector/notifications/heldWait.ts
@@ -9187,9 +10817,9 @@ function createServerNotifications(options) {
   const held = /* @__PURE__ */ new Map();
   const reminders = createReminderWatch();
   const quiet = createQuietHold();
-  function show(notice) {
+  function show(notice, about) {
     try {
-      notifier.show(notice);
+      notifier.show(notice, about);
     } catch {
     }
   }
@@ -9217,7 +10847,7 @@ function createServerNotifications(options) {
       const at = now();
       const rules = rulesOf(snapshot);
       const quietNow = quietOf(snapshot);
-      const thresholdMs = rules.longWait.minutes * 6e4;
+      const schedule = reminderSchedule(rules.longWait);
       const result = sessionChanges(memory, snapshot);
       memory = result.memory;
       for (const id of result.stopped) {
@@ -9243,7 +10873,7 @@ function createServerNotifications(options) {
             change: { event: "needs-you", session },
             since: at
           });
-          if (rules.longWait.on) reminders.toldLate(session.id, at, thresholdMs);
+          if (rules.longWait.on) reminders.told(session.id, at);
         }
       }
       if (quietNow) quiet.begin(at);
@@ -9253,9 +10883,13 @@ function createServerNotifications(options) {
         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);
+      if (rules.longWait.on && wants("needs-you")) {
+        for (const reminder of reminders.due(snapshot, at, schedule)) {
+          if (quietNow) {
+            quiet.holdReminder(reminder.session, reminder.begunAt);
+            continue;
+          }
+          reminders.told(reminder.session.id, at);
           held.set(reminderKey(reminder.session.id), { kind: "reminder", reminder, since: at });
         }
       }
@@ -9282,82 +10916,505 @@ function createServerNotifications(options) {
           }
           continue;
         }
-        if (entry.kind === "change") show(changeNotice(entry.change));
-        else if (entry.kind === "reminder") {
-          show(reminderNotice(entry.reminder.session, at - entry.reminder.begunAt));
+        if (entry.kind === "change") {
+          const { change } = entry;
+          show(
+            changeNotice(change),
+            change.event === "needs-you" ? { sessionId: change.session.id } : void 0
+          );
+        } else if (entry.kind === "reminder") {
+          const { session, begunAt } = entry.reminder;
+          const waitedMs = at - begunAt;
+          show(reminderNotice(session, waitedMs), { sessionId: session.id, waitedMs });
         } 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) => {
+// 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/outbound/httpPost.ts
+var POST_TIMEOUT_MS = 1e4;
+function jsonHeaders(body, version, extra = {}) {
+  return {
+    "Content-Type": "application/json",
+    "Content-Length": String(Buffer.byteLength(body)),
+    "User-Agent": `Agent Lookout/${version}`,
+    ...extra
+  };
+}
+function postOptions(body, version, extra = {}) {
+  return {
+    method: "POST",
+    headers: jsonHeaders(body, version, extra),
+    // A connection of its own, closed after the answer.
+    agent: false,
+    rejectUnauthorized: true
+  };
+}
+function createJsonPoster(url, options) {
+  const timeoutMs = options.timeoutMs ?? POST_TIMEOUT_MS;
+  const extra = options.headers ?? {};
+  let client = null;
+  const load = () => {
+    client ??= url.protocol === "https:" ? import("node:https").then(({ request: request2 }) => request2) : import("node:http").then(({ request: request2 }) => request2);
+    return client;
+  };
+  return {
+    async post(body) {
+      let request2;
+      try {
+        request2 = await load();
+      } catch {
+        return { kind: "unsent" };
+      }
+      return new Promise((resolve) => {
+        let finished = false;
+        const finish = (result) => {
+          if (finished) return;
+          finished = true;
+          resolve(result);
+        };
+        let req;
+        try {
+          req = request2(url, postOptions(body, options.version, extra));
+        } catch {
+          finish({ kind: "unsent" });
+          return;
+        }
+        const timer = setTimeout(() => {
+          finish({ kind: "timeout" });
+          req.destroy();
+        }, timeoutMs);
+        timer.unref();
+        req.on("response", (res) => {
+          finish({ kind: "status", status: res.statusCode ?? 0 });
+          res.on("close", () => clearTimeout(timer));
+          res.resume();
+        });
+        req.on("error", (error) => {
+          clearTimeout(timer);
+          const { code } = error ?? {};
+          finish({ kind: "error", code: typeof code === "string" ? code : null });
+        });
+        req.end(body);
+      });
+    }
+  };
+}
+function connectionReason(code, words) {
+  if (code === null) return words.notSent;
+  if (code === "ECONNREFUSED") return `nothing answered at ${words.where}`;
+  if (code === "ENOTFOUND" || code === "EAI_AGAIN") return `${words.whose} host could not be found`;
+  if (code === "ETIMEDOUT") return `${words.where} did not answer in time`;
+  if (/CERT|SELF_SIGNED|UNABLE_TO|^ERR_TLS|^ERR_SSL|^EPROTO$/.test(code)) {
+    return `the secure connection to ${words.where} failed`;
+  }
+  return `the connection to ${words.where} failed`;
+}
+function outcomeOfPost(result, words) {
+  switch (result.kind) {
+    case "unsent":
+      return { sent: false, reason: words.notSent };
+    case "timeout":
+      return { sent: false, reason: `${words.where} did not answer in time` };
+    case "error":
+      return { sent: false, reason: connectionReason(result.code, words) };
+    case "status": {
+      const { status } = result;
+      if (status >= 200 && status < 300) return { sent: true };
+      if (status >= 300 && status < 400) {
+        return {
+          sent: false,
+          reason: `${words.where} answered with a redirect, which is not followed`
+        };
+      }
+      if (status >= 400 && status < 500) return { sent: false, reason: words.refused(status) };
+      if (status >= 500 && status < 600) return { sent: false, reason: words.troubled(status) };
+      return { sent: false, reason: `${words.whose} answer could not be understood` };
+    }
+  }
+}
+
+// src/collector/ntfy/ntfyMessage.ts
+var TAG = {
+  "needs-you": "hourglass",
+  reminder: "hourglass",
+  test: "hourglass",
+  finished: "white_check_mark",
+  failed: "x",
+  ended: "stop_sign",
+  "quiet-summary": null
+};
+function ntfyBody(topic, message) {
+  const tag = TAG[message.kind];
+  return {
+    topic,
+    title: message.title,
+    message: message.message,
+    // A test sounds as a wait would, so it shows how one will arrive.
+    priority: isWaitKind(message.kind) ? 4 : 3,
+    ...tag !== null && { tags: [tag] }
+  };
+}
+
+// src/collector/ntfy/ntfySender.ts
+var NTFY_WORDS = {
+  where: "the ntfy server",
+  whose: "the ntfy server's",
+  notSent: "the push could not be sent",
+  refused(status) {
+    if (status === 401 || status === 403) {
+      return `the ntfy server refused the access token or the topic (status ${status})`;
+    }
+    if (status === 413) return `the ntfy server refused the push as too large (status ${status})`;
+    if (status === 429) return `the ntfy server's rate limit was reached (status ${status})`;
+    return `the ntfy server refused the push (status ${status})`;
+  },
+  troubled: (status) => `the ntfy server had a problem (status ${status})`
+};
+function ntfyHeaders(settings) {
+  return settings.token === null ? {} : { Authorization: `Bearer ${settings.token}` };
+}
+function createNtfySender(settings, options) {
+  const poster = createJsonPoster(settings.server, { ...options, headers: ntfyHeaders(settings) });
+  return {
+    async send(message) {
+      let body;
+      try {
+        body = JSON.stringify(ntfyBody(settings.topic, message));
+      } catch {
+        return { sent: false, reason: NTFY_WORDS.notSent };
+      }
+      return outcomeOfPost(await poster.post(body), NTFY_WORDS);
+    }
+  };
+}
+
+// src/collector/ntfy/ntfySettings.ts
+var NTFY_URL_ENV = "AGENT_LOOKOUT_NTFY_URL";
+var NTFY_TOKEN_ENV = "AGENT_LOOKOUT_NTFY_TOKEN";
+var NTFY_EVENTS_ENV = "AGENT_LOOKOUT_NTFY_EVENTS";
+var NTFY_AFTER_ENV = "AGENT_LOOKOUT_NTFY_AFTER";
+var NTFY_ASKING_ENV = "AGENT_LOOKOUT_NTFY_ASKING";
+var MAX_URL_LENGTH = 2048;
+var TOPIC = /^[-_A-Za-z0-9]{1,64}$/;
+var PATH_PART = /^[-_.~A-Za-z0-9]+$/;
+var TOKEN = /^[-A-Za-z0-9._~+/=]{1,128}$/;
+var URL_UNREADABLE2 = `${NTFY_URL_ENV} could not be read. Copy the topic's whole address, beginning https://.`;
+function readTopicUrl(value) {
+  let url;
+  try {
+    if (value.length > MAX_URL_LENGTH) throw new Error();
+    url = new URL(value);
+  } catch {
+    throw new SettingProblem(URL_UNREADABLE2);
+  }
+  const local = LOCAL_HOSTS.has(url.hostname);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && local)) {
+    throw new SettingProblem(
+      `${NTFY_URL_ENV} must begin with https://, or with http:// for a server on this computer, 127.0.0.1 or localhost.`
+    );
+  }
+  if (url.hostname === "") throw new SettingProblem(URL_UNREADABLE2);
+  if (!isWebhookHost(url.hostname)) {
+    throw new SettingProblem(
+      `${NTFY_URL_ENV} must name its host in letters, digits, dots and dashes, such as ntfy.sh.`
+    );
+  }
+  if (url.username !== "" || url.password !== "") {
+    throw new SettingProblem(
+      `${NTFY_URL_ENV} must not hold a user name or a password. Put an access token in ${NTFY_TOKEN_ENV}.`
+    );
+  }
+  if (url.search !== "" || url.hash !== "" || value.includes("?") || value.includes("#")) {
+    throw new SettingProblem(
+      `${NTFY_URL_ENV} must end with the topic, with no ? or # after it. Put an access token in ${NTFY_TOKEN_ENV}.`
+    );
+  }
+  const parts = url.pathname.split("/").filter((part) => part !== "");
+  const topic = parts.pop();
+  if (topic === void 0 || !TOPIC.test(topic) || !parts.every((part) => PATH_PART.test(part))) {
+    throw new SettingProblem(
+      `${NTFY_URL_ENV} must end with the topic, up to 64 letters, digits, dashes and underscores, as in https://ntfy.sh/your-topic.`
+    );
+  }
+  const server = new URL(url.origin);
+  server.pathname = `/${parts.map((part) => `${part}/`).join("")}`;
+  return { server, topic };
+}
+function readToken(value) {
+  if (value === void 0) return null;
+  if (!TOKEN.test(value)) {
+    throw new SettingProblem(
+      `${NTFY_TOKEN_ENV} must be an access token of letters, digits and . _ ~ + / = -, such as one that begins tk_.`
+    );
+  }
+  return value;
+}
+function readNtfySetup(env) {
+  const url = valueOf(env, NTFY_URL_ENV);
+  if (url === void 0) return { on: false, problem: null };
+  try {
+    return {
+      on: true,
+      settings: {
+        ...readTopicUrl(url),
+        token: readToken(valueOf(env, NTFY_TOKEN_ENV)),
+        events: readEvents(NTFY_EVENTS_ENV, valueOf(env, NTFY_EVENTS_ENV)),
+        afterMs: readAfter(NTFY_AFTER_ENV, valueOf(env, NTFY_AFTER_ENV)),
+        asking: readAsking(NTFY_ASKING_ENV, valueOf(env, NTFY_ASKING_ENV))
+      }
+    };
+  } catch (error) {
+    if (error instanceof SettingProblem) return { on: false, problem: error.message };
+    return { on: false, problem: URL_UNREADABLE2 };
+  }
+}
+function ntfyProblemLine(problem) {
+  return `ntfy pushes are off: ${problem}`;
+}
+
+// src/collector/outbound/testSendRoute.ts
+var MAX_TEST_BODY_BYTES = 64;
+var NAMED = {
+  ntfy: { name: "ntfy", setting: "AGENT_LOOKOUT_NTFY_URL" },
+  pushover: {
+    name: "Pushover",
+    setting: "AGENT_LOOKOUT_PUSHOVER_TOKEN and AGENT_LOOKOUT_PUSHOVER_USER"
+  }
+};
+function channelIn(body) {
+  let value;
+  try {
+    value = JSON.parse(body);
+  } catch {
+    return null;
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const keys = Object.keys(value);
+  if (keys.length !== 1 || keys[0] !== "channel") return null;
+  const { channel } = value;
+  return PHONE_CHANNELS.find((known) => known === channel) ?? null;
+}
+function asSentence(reason) {
+  return `${reason.charAt(0).toUpperCase()}${reason.slice(1)}.`;
+}
+var failed3 = (status, reason, error, more = {}) => ({
+  status,
+  body: {
+    error,
+    reason,
+    ...more.limitedUntil !== void 0 && { limitedUntil: more.limitedUntil }
+  },
+  ...more.retryAfter !== void 0 && {
+    headers: { "Retry-After": String(more.retryAfter) }
+  }
+});
+function createTestSendRoute(options) {
+  const { channels, limiter } = options;
+  const now = options.now ?? Date.now;
+  return async function answerTest(req) {
+    const refused = actionRefusalFor(req, PHONE_TEST_ACTION, MAX_TEST_BODY_BYTES);
+    if (refused) {
+      req.resume();
+      return refused;
+    }
+    const body = await readRequestBody(req, MAX_TEST_BODY_BYTES);
+    if (!body.ok) {
+      req.resume();
+      return body.tooLarge ? refusal(413, `The body must be no more than ${MAX_TEST_BODY_BYTES} bytes.`) : refusal(400, "The body could not be read.");
+    }
+    const channel = channelIn(body.text);
+    if (channel === null) {
+      return refusal(400, 'The body must be {"channel": "ntfy"} or {"channel": "pushover"}.');
+    }
+    const { name, setting } = NAMED[channel];
+    const tester = channels[channel];
+    if (tester === null) {
+      return failed3(
+        409,
+        "off",
+        `${name} is not set up. Set ${setting} and start Agent Lookout again.`
+      );
+    }
+    if (!limiter.begin()) {
+      return failed3(429, "too-soon", "One test is sent a second. Try again in a moment.", {
+        retryAfter: 1
+      });
+    }
     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 result = await tester.test();
+      if (!result.tried) {
+        return failed3(
+          429,
+          "limited",
+          `${SENDS_PER_HOUR} ${name} pushes were tried in the last hour, the most it tries.`,
+          {
+            limitedUntil: result.limitedUntil,
+            retryAfter: Math.max(1, Math.ceil((result.limitedUntil - now()) / 1e3))
           }
-          const timedOut = error.killed === true;
-          resolve({ ok: false, stderr: String(stderr ?? "").trim(), timedOut });
-        }
-      );
-      child.stdin?.end();
-    } catch {
-      resolve(NOT_RUN2);
+        );
+      }
+      if (!result.outcome.sent) {
+        return failed3(502, "not-sent", asSentence(result.outcome.reason));
+      }
+      return {
+        status: 200,
+        body: { ok: true, channel, sentAt: result.at }
+      };
+    } finally {
+      limiter.end();
     }
-  });
+  };
 }
 
-// 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";
+// src/collector/pushover/pushoverMessage.ts
+function pushoverBody(token, user, message) {
+  return {
+    token,
+    user,
+    title: message.title,
+    message: message.message,
+    // A test sounds as a wait would, so it shows how one will arrive.
+    priority: isWaitKind(message.kind) ? 0 : -1
+  };
 }
-var runForNotification = (args) => runOsascript(args, { timeoutMs: OSASCRIPT_TIMEOUT_MS });
-function createSystemNotifier(options = {}) {
-  const platform = options.platform ?? process.platform;
-  const run = options.run ?? runForNotification;
+
+// src/collector/pushover/pushoverSender.ts
+var PUSHOVER_ENDPOINT = "https://api.pushover.net/1/messages.json";
+var PUSHOVER_WORDS = {
+  where: "Pushover",
+  whose: "Pushover's",
+  notSent: "the push could not be sent",
+  refused(status) {
+    if (status === 400) {
+      return `Pushover refused the push: check the application's token and the user key (status ${status})`;
+    }
+    if (status === 429)
+      return `Pushover's monthly limit for your account was reached (status ${status})`;
+    return `Pushover refused the push (status ${status})`;
+  },
+  troubled: (status) => `Pushover had a problem (status ${status})`
+};
+function createPushoverSender(settings, options) {
+  const poster = createJsonPoster(options.endpoint ?? new URL(PUSHOVER_ENDPOINT), options);
   return {
-    show(notice) {
-      if (!systemNotificationsShownOn(platform)) return;
+    async send(message) {
+      let body;
       try {
-        run(osascriptArgs(notice)).catch(() => {
-        });
+        body = JSON.stringify(pushoverBody(settings.token, settings.user, message));
       } catch {
+        return { sent: false, reason: PUSHOVER_WORDS.notSent };
       }
+      return outcomeOfPost(await poster.post(body), PUSHOVER_WORDS);
     }
   };
 }
 
+// src/collector/pushover/pushoverSettings.ts
+var PUSHOVER_TOKEN_ENV = "AGENT_LOOKOUT_PUSHOVER_TOKEN";
+var PUSHOVER_USER_ENV = "AGENT_LOOKOUT_PUSHOVER_USER";
+var PUSHOVER_EVENTS_ENV = "AGENT_LOOKOUT_PUSHOVER_EVENTS";
+var PUSHOVER_AFTER_ENV = "AGENT_LOOKOUT_PUSHOVER_AFTER";
+var PUSHOVER_ASKING_ENV = "AGENT_LOOKOUT_PUSHOVER_ASKING";
+var KEY = /^[A-Za-z0-9]{30}$/;
+function readKey(name, value, what) {
+  if (!KEY.test(value)) throw new SettingProblem(`${name} must be ${what}: 30 letters and digits.`);
+  return value;
+}
+function readPushoverSetup(env) {
+  const token = valueOf(env, PUSHOVER_TOKEN_ENV);
+  const user = valueOf(env, PUSHOVER_USER_ENV);
+  if (token === void 0 && user === void 0) return { on: false, problem: null };
+  if (token === void 0) return { on: false, problem: `${PUSHOVER_TOKEN_ENV} is not set.` };
+  if (user === void 0) return { on: false, problem: `${PUSHOVER_USER_ENV} is not set.` };
+  try {
+    return {
+      on: true,
+      settings: {
+        token: readKey(PUSHOVER_TOKEN_ENV, token, "the API token of your Pushover application"),
+        user: readKey(PUSHOVER_USER_ENV, user, "your Pushover user key, or a group key"),
+        events: readEvents(PUSHOVER_EVENTS_ENV, valueOf(env, PUSHOVER_EVENTS_ENV)),
+        afterMs: readAfter(PUSHOVER_AFTER_ENV, valueOf(env, PUSHOVER_AFTER_ENV)),
+        asking: readAsking(PUSHOVER_ASKING_ENV, valueOf(env, PUSHOVER_ASKING_ENV))
+      }
+    };
+  } catch (error) {
+    if (error instanceof SettingProblem) return { on: false, problem: error.message };
+    return { on: false, problem: `${PUSHOVER_TOKEN_ENV} could not be read.` };
+  }
+}
+function pushoverProblemLine(problem) {
+  return `Pushover pushes are off: ${problem}`;
+}
+
 // src/collector/remotes/remoteReader.ts
 import { request } from "node:http";
 var REMOTE_ANSWER_TIMEOUT_MS = 6e3;
@@ -9434,7 +11491,7 @@ var MAX_REMOTE_SOURCES = 20;
 var MAX_ID_LENGTH = 512;
 var MAX_PATH_LENGTH = 4096;
 var MAX_WORD_LENGTH2 = 200;
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function oneOf2(allowed, value) {
@@ -9448,7 +11505,7 @@ function exact(value, max) {
 var COMMIT_ID2 = /^[0-9a-f]{7,64}$/;
 var REPOSITORY_ID = /^[0-9a-f]{16,64}$/;
 function readGit(value, machine) {
-  if (!isRecord12(value)) return void 0;
+  if (!isRecord13(value)) return void 0;
   let head;
   if (value.commit !== void 0) {
     if (value.branch !== void 0 || typeof value.commit !== "string") return void 0;
@@ -9460,7 +11517,7 @@ function readGit(value, machine) {
     head = { branch };
   }
   const repository = value.repository;
-  if (isRecord12(repository) && typeof repository.id === "string") {
+  if (isRecord13(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}
@@ -9470,7 +11527,7 @@ ${repository.id}`), name };
   return head;
 }
 function readSession(value, machine, sources, now, keepWaitingText) {
-  if (!isRecord12(value)) return null;
+  if (!isRecord13(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;
@@ -9510,7 +11567,7 @@ function readSession(value, machine, sources, now, keepWaitingText) {
   return session;
 }
 function readCell(value) {
-  if (!isRecord12(value)) return null;
+  if (!isRecord13(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);
@@ -9518,7 +11575,7 @@ function readCell(value) {
 }
 var ACTS_HERE = ["jump", "stop", "answer"];
 function readCapabilities(value, machine) {
-  if (!isRecord12(value)) return null;
+  if (!isRecord13(value)) return null;
   const read = {};
   for (const capability of CAPABILITIES) {
     if (ACTS_HERE.includes(capability)) continue;
@@ -9534,7 +11591,7 @@ function readCapabilities(value, machine) {
   };
 }
 function readRemoteSnapshot(value, machine, now, options = {}) {
-  if (!isRecord12(value) || !Array.isArray(value.sessions) || !Array.isArray(value.sources)) {
+  if (!isRecord13(value) || !Array.isArray(value.sessions) || !Array.isArray(value.sources)) {
     return null;
   }
   const named = /* @__PURE__ */ new Map();
@@ -9542,7 +11599,7 @@ function readRemoteSnapshot(value, machine, now, options = {}) {
   const agents = [];
   for (const item of value.sources) {
     if (sources.length >= MAX_REMOTE_SOURCES) break;
-    if (!isRecord12(item)) continue;
+    if (!isRecord13(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;
@@ -9567,7 +11624,7 @@ function readRemoteSnapshot(value, machine, now, options = {}) {
 }
 
 // src/collector/remotes/sshProgram.ts
-import path19 from "node:path";
+import path23 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;
@@ -9589,7 +11646,7 @@ async function findSsh(env, isExecutable, platform = process.platform) {
   }
   return {
     found: false,
-    looked: `The ssh command was not found on PATH or in ${SSH_LOCATIONS.map((at) => path19.dirname(at)).join(", ")}`
+    looked: `The ssh command was not found on PATH or in ${SSH_LOCATIONS.map((at) => path23.dirname(at)).join(", ")}`
   };
 }
 function sshArguments(forward) {
@@ -9613,7 +11670,7 @@ function sshArguments(forward) {
 }
 
 // src/collector/remotes/remoteAdapter.ts
-var BASIS3 = "api";
+var BASIS4 = "api";
 var NOT_CONNECTED = "unavailable";
 var ANSWER_WAIT_MS = 500;
 var STILL_CONNECTING_MS = 1e4;
@@ -9679,7 +11736,7 @@ function createRemoteAdapter(options) {
     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 };
+    return state === "ok" ? { health, sessions, basis: BASIS4 } : { health, sessions };
   }
   function connecting(at) {
     if (problem === null) {
@@ -10184,15 +12241,15 @@ import {
   unlinkSync as unlinkSync2,
   writeSync as writeSync2
 } from "node:fs";
-import os9 from "node:os";
-import path20 from "node:path";
+import os10 from "node:os";
+import path24 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()) {
+function readSettingsSetup(env, homeDir = os10.homedir()) {
   const named = env[SETTINGS_FILE_ENV]?.trim() || void 0;
-  const file = path20.resolve(named ?? path20.join(homeDir, ".agent-lookout", "settings.json"));
+  const file = path24.resolve(named ?? path24.join(homeDir, ".agent-lookout", "settings.json"));
   return { file, shown: tildify(file, homeDir) };
 }
 function codeOf(error) {
@@ -10237,7 +12294,7 @@ function readSettingsStamp(setup) {
 }
 function readSettingsText(setup) {
   const { file, shown } = setup;
-  const folder = path20.dirname(file);
+  const folder = path24.dirname(file);
   try {
     const folderKind = kindAt(folder);
     if (folderKind === null) return { kind: "missing" };
@@ -10296,7 +12353,7 @@ function readSettingsText(setup) {
 }
 function writeSettingsText(setup, text4) {
   const { file, shown } = setup;
-  const folder = path20.dirname(file);
+  const folder = path24.dirname(file);
   const notSaved = {
     ok: false,
     problem: `${shown} could not be written, so the change was not saved.`
@@ -10317,9 +12374,9 @@ function writeSettingsText(setup, text4) {
         problem: `${shown} is a link or not an ordinary file, which Agent Lookout does not write through, so the change was not saved.`
       };
     }
-    temporary = path20.join(
+    temporary = path24.join(
       folder,
-      `.${path20.basename(file)}.${process.pid}.${randomBytes3(6).toString("hex")}.tmp`
+      `.${path24.basename(file)}.${process.pid}.${randomBytes3(6).toString("hex")}.tmp`
     );
     const fd = openWithoutFollowingNow(
       temporary,
@@ -10359,7 +12416,7 @@ var RULE_WORDS = {
   idle: "the idle rule",
   quietHours: "the quiet hours"
 };
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function listOf(names) {
@@ -10397,7 +12454,7 @@ function rulesIn(read, shown) {
   } catch {
     value = null;
   }
-  if (!isRecord13(value)) {
+  if (!isRecord14(value)) {
     const notJson = `${shown} is not JSON that Agent Lookout can read, so the time rules and the permission rules are off. Changing one in Settings writes the file again.`;
     return {
       rules: off,
@@ -10412,7 +12469,7 @@ function rulesIn(read, shown) {
   const { timeRules, permissionRules: heldRules, ...rest } = value;
   const permissions = readPermissionRules(heldRules);
   const { rules, unread } = readTimeRules(timeRules);
-  const otherRules = isRecord13(timeRules) ? Object.fromEntries(
+  const otherRules = isRecord14(timeRules) ? Object.fromEntries(
     Object.entries(timeRules).filter(
       ([name]) => !TIME_RULE_NAMES.includes(name)
     )
@@ -10514,15 +12571,15 @@ import { randomBytes as randomBytes4 } from "node:crypto";
 
 // src/core/permission-rules/rulesChange.ts
 var CHANGE_SHAPE = 'The body must be one change: {"add": rule}, {"edit": rule with its "id"}, {"move": {"id", "to": "up" or "down"}} or {"remove": {"id"}}, and nothing else.';
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function rulesChangeIn(value) {
   const refused = { ok: false, problem: CHANGE_SHAPE };
-  if (!isRecord14(value) || Object.keys(value).length !== 1) return refused;
+  if (!isRecord15(value) || Object.keys(value).length !== 1) return refused;
   const [kind] = Object.keys(value);
   const body = value[kind];
-  if (!isRecord14(body)) return refused;
+  if (!isRecord15(body)) return refused;
   switch (kind) {
     case "add": {
       const read = ruleWordsIn(body);
@@ -10598,7 +12655,7 @@ function applyRulesChange(rules, change, newId) {
 
 // src/collector/settings/permissionRulesRoute.ts
 var MAX_PERMISSION_RULES_BODY_BYTES = 1024;
-var failed3 = (status, reason, error) => ({
+var failed4 = (status, reason, error) => ({
   status,
   body: { error, reason }
 });
@@ -10625,14 +12682,14 @@ function createPermissionRulesRoute(options) {
     try {
       value = JSON.parse(body.text);
     } catch {
-      return failed3(400, "invalid", "The body must be JSON: one change to the permission rules.");
+      return failed4(400, "invalid", "The body must be JSON: one change to the permission rules.");
     }
     const asked = rulesChangeIn(value);
-    if (!asked.ok) return failed3(400, "invalid", asked.problem);
+    if (!asked.ok) return failed4(400, "invalid", asked.problem);
     const made = settings.changePermissionRules(
       (rules) => applyRulesChange(rules, asked.change, newId)
     );
-    if (!made.ok) return failed3(STATUS_OF[made.reason], made.reason, made.problem);
+    if (!made.ok) return failed4(STATUS_OF[made.reason], made.reason, made.problem);
     return {
       status: 200,
       body: { ok: true, permissionRules: made.rules }
@@ -10642,7 +12699,7 @@ function createPermissionRulesRoute(options) {
 
 // src/collector/settings/timeRulesRoute.ts
 var MAX_TIME_RULES_BODY_BYTES = 2048;
-var failed4 = (status, reason, error) => ({
+var failed5 = (status, reason, error) => ({
   status,
   body: { error, reason }
 });
@@ -10666,12 +12723,12 @@ function createTimeRulesRoute(options) {
     try {
       value = JSON.parse(body.text);
     } catch {
-      return failed4(400, "invalid", "The body must be JSON: the three time rules.");
+      return failed5(400, "invalid", "The body must be JSON: the three time rules.");
     }
     const asked = timeRulesIn(value);
-    if (!asked.ok) return failed4(400, "invalid", asked.problem);
+    if (!asked.ok) return failed5(400, "invalid", asked.problem);
     const saved = settings.changeTimeRules(asked.rules);
-    if (!saved.ok) return failed4(500, "not-saved", saved.problem);
+    if (!saved.ok) return failed5(500, "not-saved", saved.problem);
     return {
       status: 200,
       body: { ok: true, timeRules: asked.rules }
@@ -10715,11 +12772,11 @@ function createOsascriptRunner(options) {
 }
 
 // src/collector/terminal/tabFinder.ts
-import os10 from "node:os";
+import os11 from "node:os";
 var TAB_LOOK_SOONEST_MS = 5e3;
 function createTabFinder(options) {
   const off = terminalJumpOff(options.env);
-  const homeDir = options.homeDir ?? os10.homedir();
+  const homeDir = options.homeDir ?? os11.homedir();
   const readProcesses = options.readProcesses ?? readProcessTableWithPs;
   const now = options.now ?? Date.now;
   const soonestMs = options.soonestMs ?? TAB_LOOK_SOONEST_MS;
@@ -10953,96 +13010,24 @@ function ledgerHistoryStore(store, ledger) {
 }
 
 // src/collector/webhook/webhookSender.ts
-var WEBHOOK_TIMEOUT_MS = 1e4;
-function postHeaders(body, version) {
-  return {
-    "Content-Type": "application/json",
-    "Content-Length": String(Buffer.byteLength(body)),
-    "User-Agent": `Agent Lookout/${version}`
-  };
-}
-var TIMED_OUT = "the address did not answer in time";
-function outcomeOfStatus(status) {
-  if (status >= 200 && status < 300) return { sent: true };
-  if (status >= 300 && status < 400) {
-    return { sent: false, reason: "the address answered with a redirect, which is not followed" };
-  }
-  if (status >= 400 && status < 500) {
-    return { sent: false, reason: `the address refused the post (status ${status})` };
-  }
-  if (status >= 500 && status < 600) {
-    return { sent: false, reason: `the receiving service had a problem (status ${status})` };
-  }
-  return { sent: false, reason: "the address's answer could not be understood" };
-}
-function failureReason2(error) {
-  const { code } = error ?? {};
-  if (typeof code !== "string") return "the post could not be sent";
-  if (code === "ECONNREFUSED") return "nothing answered at the address";
-  if (code === "ENOTFOUND" || code === "EAI_AGAIN") return "the address's host could not be found";
-  if (code === "ETIMEDOUT") return TIMED_OUT;
-  if (/CERT|SELF_SIGNED|UNABLE_TO|^ERR_TLS|^ERR_SSL|^EPROTO$/.test(code)) {
-    return "the secure connection to the address failed";
-  }
-  return "the connection to the address failed";
-}
-function requestOptions(body, version) {
-  return {
-    method: "POST",
-    headers: postHeaders(body, version),
-    // A connection of its own, closed after the answer.
-    agent: false,
-    rejectUnauthorized: true
-  };
-}
+var WORDS = {
+  where: "the address",
+  whose: "the address's",
+  notSent: "the post could not be sent",
+  refused: (status) => `the address refused the post (status ${status})`,
+  troubled: (status) => `the receiving service had a problem (status ${status})`
+};
 function createHttpSender(settings, options) {
-  const { url } = settings;
-  const timeoutMs = options.timeoutMs ?? WEBHOOK_TIMEOUT_MS;
-  let client = null;
-  const load = () => {
-    client ??= url.protocol === "https:" ? import("node:https").then(({ request: request2 }) => request2) : import("node:http").then(({ request: request2 }) => request2);
-    return client;
-  };
+  const poster = createJsonPoster(settings.url, options);
   return {
     async send(post) {
-      let request2;
+      let body;
       try {
-        request2 = await load();
+        body = JSON.stringify(post);
       } catch {
-        return { sent: false, reason: "the post could not be sent" };
+        return { sent: false, reason: WORDS.notSent };
       }
-      return new Promise((resolve) => {
-        let finished = false;
-        const finish = (outcome) => {
-          if (finished) return;
-          finished = true;
-          resolve(outcome);
-        };
-        let body;
-        let req;
-        try {
-          body = JSON.stringify(post);
-          req = request2(url, requestOptions(body, options.version));
-        } catch {
-          finish({ sent: false, reason: "the post could not be sent" });
-          return;
-        }
-        const timer = setTimeout(() => {
-          finish({ sent: false, reason: TIMED_OUT });
-          req.destroy();
-        }, timeoutMs);
-        timer.unref();
-        req.on("response", (res) => {
-          finish(outcomeOfStatus(res.statusCode ?? 0));
-          res.on("close", () => clearTimeout(timer));
-          res.resume();
-        });
-        req.on("error", (error) => {
-          clearTimeout(timer);
-          finish({ sent: false, reason: failureReason2(error) });
-        });
-        req.end(body);
-      });
+      return outcomeOfPost(await poster.post(body), WORDS);
     }
   };
 }
@@ -11052,15 +13037,15 @@ var WEBHOOK_URL_ENV = "AGENT_LOOKOUT_WEBHOOK_URL";
 var WEBHOOK_EVENTS_ENV = "AGENT_LOOKOUT_WEBHOOK_EVENTS";
 var WEBHOOK_AFTER_ENV = "AGENT_LOOKOUT_WEBHOOK_AFTER";
 var WEBHOOK_ASKING_ENV = "AGENT_LOOKOUT_WEBHOOK_ASKING";
-var MAX_URL_LENGTH = 2048;
-var URL_UNREADABLE2 = `${WEBHOOK_URL_ENV} could not be read. Copy the whole address, beginning https://.`;
+var MAX_URL_LENGTH2 = 2048;
+var URL_UNREADABLE3 = `${WEBHOOK_URL_ENV} could not be read. Copy the whole address, beginning https://.`;
 function readUrl(value) {
   let url;
   try {
-    if (value.length > MAX_URL_LENGTH) throw new Error();
+    if (value.length > MAX_URL_LENGTH2) throw new Error();
     url = new URL(value);
   } catch {
-    throw new SettingProblem(URL_UNREADABLE2);
+    throw new SettingProblem(URL_UNREADABLE3);
   }
   const local = LOCAL_HOSTS.has(url.hostname);
   if (url.protocol !== "https:" && !(url.protocol === "http:" && local)) {
@@ -11068,7 +13053,7 @@ function readUrl(value) {
       `${WEBHOOK_URL_ENV} must begin with https://, or with http:// for an address on this computer, 127.0.0.1 or localhost.`
     );
   }
-  if (url.hostname === "") throw new SettingProblem(URL_UNREADABLE2);
+  if (url.hostname === "") throw new SettingProblem(URL_UNREADABLE3);
   if (!isWebhookHost(url.hostname)) {
     throw new SettingProblem(
       `${WEBHOOK_URL_ENV} must name its host in letters, digits, dots and dashes, such as hooks.slack.com.`
@@ -11094,7 +13079,7 @@ function readWebhookSetup(env) {
     };
   } catch (error) {
     if (error instanceof SettingProblem) return { on: false, problem: error.message };
-    return { on: false, problem: URL_UNREADABLE2 };
+    return { on: false, problem: URL_UNREADABLE3 };
   }
 }
 function webhookProblemLine(problem) {
@@ -11191,6 +13176,26 @@ function createCollector(options) {
     now
   }) : null;
   const webhookOff = webhookOffStatus(webhookSetup.on ? null : webhookSetup.problem);
+  const ntfySetup = readNtfySetup(env);
+  if (!ntfySetup.on && ntfySetup.problem !== null) warn(ntfyProblemLine(ntfySetup.problem));
+  const makeNtfySender = options.createNtfySender ?? ((settings2) => createNtfySender(settings2, { version: options.version }));
+  const ntfy = ntfySetup.on ? createNtfyNotifications({
+    settings: ntfySetup.settings,
+    sender: makeNtfySender(ntfySetup.settings),
+    now
+  }) : null;
+  const ntfyOff = ntfyOffStatus(ntfySetup.on ? null : ntfySetup.problem);
+  const pushoverSetup = readPushoverSetup(env);
+  if (!pushoverSetup.on && pushoverSetup.problem !== null) {
+    warn(pushoverProblemLine(pushoverSetup.problem));
+  }
+  const makePushoverSender = options.createPushoverSender ?? ((settings2) => createPushoverSender(settings2, { version: options.version }));
+  const pushover = pushoverSetup.on ? createPushoverNotifications({
+    settings: pushoverSetup.settings,
+    sender: makePushoverSender(pushoverSetup.settings),
+    now
+  }) : null;
+  const pushoverOff = pushoverOffStatus(pushoverSetup.on ? null : pushoverSetup.problem);
   const remotes = createRemotes({
     env,
     version: options.version,
@@ -11211,6 +13216,7 @@ function createCollector(options) {
       platform
     }),
     createCodexAdapter({ env: options.env, now, pollIntervalMs: intervalMs }),
+    createAntigravityAdapter({ env: options.env, now, pollIntervalMs: intervalMs, platform }),
     createStatusFileAdapter({ env: options.env, now, pollIntervalMs: intervalMs })
   ];
   const poller = createPoller({
@@ -11245,6 +13251,8 @@ function createCollector(options) {
       answering?.observe(snapshot);
       email?.handle(snapshot);
       webhook?.handle(snapshot);
+      ntfy?.handle(snapshot);
+      pushover?.handle(snapshot);
       notifications.handle(snapshot);
       options.onSnapshot?.(snapshot);
     }
@@ -11287,6 +13295,13 @@ function createCollector(options) {
     notifications,
     email: () => email?.status() ?? emailOff,
     webhook: () => webhook?.status() ?? webhookOff,
+    ntfy: () => ntfy?.status() ?? ntfyOff,
+    pushover: () => pushover?.status() ?? pushoverOff,
+    phoneTest: createTestSendRoute({
+      channels: { ntfy, pushover },
+      limiter: createActionLimiter(now),
+      now
+    }),
     pullRequests: () => pullRequests?.status() ?? pullRequestsOff,
     jump: createJumpRoute({ poller, panes, run: tmux, tabs, osascript, now }),
     stop: stopRoutes && createStopRoute(stopRoutes),
@@ -11381,13 +13396,20 @@ function createCollector(options) {
     poller,
     email,
     webhook,
+    ntfy,
+    pushover,
     pullRequests,
     history: keeper,
     answering: {
       start: () => answerStart ??= answering?.start() ?? Promise.resolve(),
       stop: async () => {
         await answering?.stop();
-      }
+      },
+      serve: (snapshot) => answering?.serve(snapshot) ?? snapshot,
+      check: async () => {
+        await answering?.check();
+      },
+      ...answering?.answer && { answer: answering.answer }
     },
     remotes,
     settings
@@ -11411,7 +13433,7 @@ async function runStandalone(options) {
   } catch (error) {
     return stopWith(error.message);
   }
-  if (!existsSync(path21.join(distDir, "index.html"))) {
+  if (!existsSync(path25.join(distDir, "index.html"))) {
     return stopWith(
       "The dashboard has not been built yet. Run `npm run build`, then start it again."
     );
@@ -11454,12 +13476,12 @@ async function runStandalone(options) {
 
 // src/cli/start/openBrowser.ts
 import { spawn as spawn3 } from "node:child_process";
-import path22 from "node:path";
+import path26 from "node:path";
 var OPEN_WAIT_MS = 1e4;
 var WINDOWS_FOLDER = "C:\\Windows";
 function windowsFolder(env) {
   const named = env.SystemRoot?.trim() || env.SYSTEMROOT?.trim();
-  return named && path22.win32.isAbsolute(named) ? named : WINDOWS_FOLDER;
+  return named && path26.win32.isAbsolute(named) ? named : WINDOWS_FOLDER;
 }
 function openCommand(platform, url, env = process.env) {
   const address = loopbackAddress(url);
@@ -11468,7 +13490,7 @@ function openCommand(platform, url, env = process.env) {
   if (platform === "linux") return { file: "xdg-open", args: [address] };
   if (platform === "win32") {
     return {
-      file: path22.win32.join(windowsFolder(env), "System32", "rundll32.exe"),
+      file: path26.win32.join(windowsFolder(env), "System32", "rundll32.exe"),
       args: ["url.dll,FileProtocolHandler", address]
     };
   }