agent-lookout 0.2.5 → 0.2.7

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

@@ -1,21 +1,24 @@
 import {
   sortSessions
-} from "./chunk-Q73JDXXW.js";
+} from "./chunk-JSBQMY3Q.js";
 import {
   ANSWER_DECISIONS,
   CAPABILITIES,
+  EDIT_TOOLS,
   EVENT_ACTORS,
   EVENT_KINDS,
   EVENT_SEVERITIES,
   MAX_MACHINE_NAME_LENGTH,
   MAX_NAME_LENGTH,
   MAX_NOTICE_TEXT_LENGTH,
+  NOT_YES_OR_NO_TOOLS,
   SESSION_STATUSES,
   SOURCE_STATES,
   SOURCE_STATE_LABEL,
   SURFACES,
   WAITING_REASONS,
   agentName,
+  answeredNow,
   changeNotice,
   checksStateOf,
   clean,
@@ -24,12 +27,14 @@ import {
   durationInWords,
   durationParts,
   formatDuration,
+  inAnsweredWait,
   isGitHubRepository,
   isMachineName,
   isPullRequestNumber,
   isRemoteSource,
   isStatusEvent,
   loopbackAddress,
+  needsYou,
   noticeTitle,
   oneLine,
   overPhrase,
@@ -43,7 +48,7 @@ import {
   waitingPhrase,
   waitingText,
   withoutWaitingText
-} from "./chunk-OT3EGOTY.js";
+} from "./chunk-I6Q35DHC.js";
 
 // src/collector/hosts/server.ts
 import { createServer } from "node:http";
@@ -66,7 +71,7 @@ function waitChanges(memory, snapshot) {
   const started = [];
   const stopped = [];
   for (const session of snapshot.sessions) {
-    if (session.status !== "needs-you") continue;
+    if (!needsYou(session)) continue;
     const waiting = waitingNow.get(session.source);
     if (!waiting || waiting.has(session.id)) continue;
     const remembered = memory.get(session.source);
@@ -192,6 +197,9 @@ var ANSWER_ACTION = "answer";
 var SETTINGS_PATH = "/api/settings";
 var TIME_RULES_PATH = "/api/settings/time-rules";
 var TIME_RULES_ACTION = "time-rules";
+var PERMISSION_RULES_PATH = "/api/settings/permission-rules";
+var PERMISSION_RULES_ACTION = "permission-rules";
+var MAX_RULE_ANSWERS = 100;
 var ACTION_HEADER = "X-Agent-Lookout-Action";
 var MAX_EVENTS_PER_RESPONSE = 200;
 var NOTIFICATIONS_HEADER = "X-Agent-Lookout-Notifications";
@@ -213,15 +221,15 @@ function isWebhookHost(host) {
 // src/core/history.ts
 var DEFAULT_HISTORY_WINDOW_MS = 15 * 60 * 1e3;
 function historyPointFor(sessions, at) {
-  let needsYou = 0;
+  let needsYou2 = 0;
   let working = 0;
   let idle = 0;
   for (const session of sessions) {
-    if (session.status === "needs-you") needsYou += 1;
-    else if (session.status === "working") working += 1;
+    if (needsYou(session)) needsYou2 += 1;
+    else if (session.status === "working" || session.status === "needs-you") working += 1;
     else if (session.status === "idle" && !session.stale) idle += 1;
   }
-  return { at, needsYou, working, idle, total: sessions.length };
+  return { at, needsYou: needsYou2, working, idle, total: sessions.length };
 }
 
 // src/core/time-rules/quietHold.ts
@@ -246,10 +254,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 });
@@ -264,14 +292,15 @@ function createQuietHold() {
       const stillOpen = /* @__PURE__ */ new Map();
       for (const wait of waits) {
         const now = listed.get(wait.session.id);
-        if (now?.status !== "needs-you") continue;
+        if (now === void 0 || !needsYou(now)) continue;
         if (wait.endedAt === null || now.statusSince === wait.begunAt) {
           stillOpen.set(wait.session.id, wait);
         }
       }
-      const open4 = [];
+      const open2 = [];
       for (const [id, wait] of stillOpen) {
-        open4.push({ session: listed.get(id), begunAt: wait.begunAt });
+        if (wait.reminderOnly) continue;
+        open2.push({ session: listed.get(id), begunAt: wait.begunAt });
       }
       const answered = /* @__PURE__ */ new Map();
       const lastBegun = /* @__PURE__ */ new Map();
@@ -309,7 +338,7 @@ function createQuietHold() {
       since = null;
       waits = [];
       over = [];
-      return { summary: items.length > 0 ? { from, to: at, items } : null, open: open4 };
+      return { summary: items.length > 0 ? { from, to: at, items } : null, open: open2 };
     }
   };
 }
@@ -328,6 +357,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 },
@@ -357,12 +387,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;
@@ -394,7 +434,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.'
 };
@@ -459,6 +499,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)
@@ -471,35 +523,39 @@ function createReminderWatch() {
       for (const id of stopped) watched.delete(id);
       const sources = readable(snapshot);
       for (const session of snapshot.sessions) {
-        if (session.status !== "needs-you" || !sources.has(session.source)) continue;
+        if (!needsYou(session) || !sources.has(session.source)) continue;
         const since = session.statusSince !== null && session.statusSince <= at ? session.statusSince : null;
         const known = watched.get(session.id);
         if (known && (since === null || since === known.begunAt)) continue;
         watched.set(session.id, {
           begunAt: since ?? at,
-          firstSeenAfterMs: since === null ? 0 : at - since,
-          reminded: /* @__PURE__ */ new Set()
+          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 (session.status !== "needs-you") continue;
+        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();
@@ -532,7 +588,7 @@ function createOutboundChannel(options) {
   const wanted = new Set(options.events);
   let memory = EMPTY_CHANGE_MEMORY;
   const ready = [];
-  const open4 = /* @__PURE__ */ new Map();
+  const open2 = /* @__PURE__ */ new Map();
   const done = /* @__PURE__ */ new Map();
   let sentAt = [];
   const reminders = createReminderWatch();
@@ -558,7 +614,7 @@ function createOutboundChannel(options) {
         const result = sessionChanges(memory, snapshot);
         memory = result.memory;
         for (const id of result.stopped) {
-          open4.delete(id);
+          open2.delete(id);
           hold.waitEnded(id, at);
         }
         reminders.observe(snapshot, result.stopped, at);
@@ -572,7 +628,7 @@ function createOutboundChannel(options) {
             }));
             ready.push((sentNow) => summaryMessage({ ...summary, items, now: sentNow }));
           }
-          for (const { session, begunAt } of end.open) open4.set(session.id, begunAt);
+          for (const { session, begunAt } of end.open) open2.set(session.id, begunAt);
         }
         if (quiet) hold.begin(at);
         for (const { event, session } of result.changes) {
@@ -593,7 +649,7 @@ function createOutboundChannel(options) {
           }
           const since = session.statusSince;
           if (since !== null && done.get(session.id) === since) continue;
-          open4.set(session.id, waitBegan(since, at));
+          open2.set(session.id, waitBegan(since, at));
         }
         sentAt = sendsInLastHour(sentAt, at);
         while (!quiet && ready.length > 0 && limitLiftsAt(sentAt, at) === null) {
@@ -601,21 +657,21 @@ function createOutboundChannel(options) {
           sentAt.push(at);
           send2(write(at));
         }
-        const thresholdMs = rules.longWait.minutes * 6e4;
-        for (const [id, begunAt] of open4) {
+        const schedule = reminderSchedule(rules.longWait);
+        for (const [id, begunAt] of open2) {
           const session = snapshot.sessions.find(
-            (candidate) => candidate.id === id && candidate.status === "needs-you"
+            (candidate) => candidate.id === id && needsYou(candidate)
           );
           if (!session) continue;
           const timing = sendTiming(begunAt, afterMs, sentAt, at);
           if (timing === "wait") continue;
           if (quiet) {
-            open4.delete(id);
+            open2.delete(id);
             hold.holdWait(session, begunAt);
             continue;
           }
           if (timing === "limited") continue;
-          open4.delete(id);
+          open2.delete(id);
           sentAt.push(at);
           send2(
             waitMessage({
@@ -627,13 +683,17 @@ 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) => !open4.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({
                 session: withoutWaitingText(due.session),
@@ -641,13 +701,15 @@ function createOutboundChannel(options) {
                 asking: asking ? waitingText(due.session.waitingText) ?? null : null,
                 begunAt: due.begunAt,
                 now: at,
-                thresholdMs
+                thresholdMs: schedule.thresholdMs,
+                everyMs: schedule.everyMs,
+                repeat: due.repeat
               })
             );
           }
         }
         for (const session of snapshot.sessions) {
-          if (session.status === "needs-you" && session.statusSince !== null && !open4.has(session.id)) {
+          if (needsYou(session) && session.statusSince !== null && !open2.has(session.id)) {
             done.set(session.id, session.statusSince);
           }
         }
@@ -661,9 +723,9 @@ function createOutboundChannel(options) {
 }
 
 // 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 = {
@@ -865,9 +927,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
@@ -998,15 +1061,15 @@ function recordValue(record) {
     case "cleared":
       return { cleared: record.at };
     case "point": {
-      const { at, needsYou, working, idle, total } = record.point;
-      return { point: [at, needsYou, working, idle, total] };
+      const { at, needsYou: needsYou2, working, idle, total } = record.point;
+      return { point: [at, needsYou2, working, idle, total] };
     }
     case "event":
       return { event: eventFields(record.event) };
   }
 }
 function eventFields(event) {
-  const { id, at, sessionId, sessionName: sessionName2, kind, from, to, severity, by, decision } = event;
+  const { id, at, sessionId, sessionName: sessionName2, kind, from, to, severity, by, decision, tool, rule } = event;
   return {
     id,
     at,
@@ -1017,7 +1080,12 @@ function eventFields(event) {
     ...to !== void 0 && { to },
     severity,
     ...by !== void 0 && { by },
-    ...decision !== void 0 && { decision }
+    ...decision !== void 0 && { decision },
+    ...tool !== void 0 && { tool },
+    // The rule's own two fields, and nothing else it might carry.
+    ...rule !== void 0 && {
+      rule: { tool: rule.tool, ...rule.command !== void 0 && { command: rule.command } }
+    }
   };
 }
 function isRecord2(value) {
@@ -1038,11 +1106,11 @@ function oneOf(list, value) {
 function readPoint(value) {
   if (!Array.isArray(value) || value.length !== 5) return null;
   const at = moment(value[0]);
-  const [needsYou, working, idle, total] = value.slice(1).map(count);
-  if (at === null || needsYou == null || working == null || idle == null || total == null) {
+  const [needsYou2, working, idle, total] = value.slice(1).map(count);
+  if (at === null || needsYou2 == null || working == null || idle == null || total == null) {
     return null;
   }
-  return { at, needsYou, working, idle, total };
+  return { at, needsYou: needsYou2, working, idle, total };
 }
 function readEvent(value) {
   if (!isRecord2(value)) return null;
@@ -1060,6 +1128,10 @@ function readEvent(value) {
   if (value.by !== void 0 && !by) return null;
   const decision = oneOf(ANSWER_DECISIONS, value.decision);
   if (value.decision !== void 0 && !decision) return null;
+  const tool = field(value.tool);
+  if (value.tool !== void 0 && !tool) return null;
+  const rule = value.rule === void 0 ? void 0 : readRule(value.rule);
+  if (rule === null) return null;
   return {
     id,
     at,
@@ -1070,9 +1142,20 @@ function readEvent(value) {
     ...to && { to },
     severity,
     ...by && { by },
-    ...decision && { decision }
+    ...decision && { decision },
+    ...tool && { tool },
+    ...rule && { rule }
   };
 }
+function readRule(value) {
+  if (!isRecord2(value)) return null;
+  const keys = Object.keys(value);
+  if (!keys.every((key) => key === "tool" || key === "command")) return null;
+  const tool = field(value.tool);
+  const command = value.command === void 0 ? void 0 : field(value.command);
+  if (!tool || command === null) return null;
+  return { tool, ...command !== void 0 && { command } };
+}
 function parseRecord(line) {
   if (line === "" || line.length > MAX_LINE_LENGTH) return null;
   let value;
@@ -1291,6 +1374,34 @@ function staleBy(sessions, at, thresholdMs) {
     return stale === session.stale ? session : { ...session, stale };
   });
 }
+function forEvents(sessions, previous, answered) {
+  if (answered.size === 0) return sessions;
+  const before = new Map(previous.map((session) => [session.id, session]));
+  const taken = [];
+  for (const session of sessions) {
+    if (!answered.has(session.id)) {
+      taken.push(session);
+      continue;
+    }
+    const was = before.get(session.id);
+    if (was) taken.push(was);
+  }
+  return taken;
+}
+function markAnswered(sessions, answered) {
+  if (answered.size === 0) return sessions;
+  return sessions.map(
+    (session) => answered.has(session.id) ? { ...session, answered: true } : session
+  );
+}
+var NONE_ANSWERED = /* @__PURE__ */ new Set();
+function withAnsweredThere(answered, sessions) {
+  const there = sessions.filter(
+    (session) => session.machine !== void 0 && session.answered === true
+  );
+  if (there.length === 0) return answered;
+  return /* @__PURE__ */ new Set([...answered, ...there.map((session) => session.id)]);
+}
 function declared(adapter) {
   return adapter.capabilities === void 0 ? {} : { capabilities: adapter.capabilities };
 }
@@ -1345,11 +1456,11 @@ function createPoller(options) {
     };
   }
   function ask(adapter) {
-    const open4 = overdue.get(adapter);
-    if (open4) {
-      if (open4.late === void 0) return Promise.resolve(stillWaiting(adapter, open4.since));
+    const open2 = overdue.get(adapter);
+    if (open2) {
+      if (open2.late === void 0) return Promise.resolve(stillWaiting(adapter, open2.since));
       overdue.delete(adapter);
-      return Promise.resolve(open4.late);
+      return Promise.resolve(open2.late);
     }
     const since = now();
     return new Promise((resolve) => {
@@ -1393,10 +1504,24 @@ function createPoller(options) {
       return sessions;
     }
   }
+  function answeredIn(snapshot) {
+    if (!options.answered) return NONE_ANSWERED;
+    try {
+      return options.answered(snapshot);
+    } catch {
+      return NONE_ANSWERED;
+    }
+  }
   async function poll() {
     const results = await Promise.all(adapters.map((adapter) => ask(adapter)));
     const found = await annotated(results.flatMap((result) => result.sessions));
     const at = now();
+    const sources = results.map((result, index) => ({
+      ...result.health,
+      ...result.basis !== void 0 && { basis: result.basis },
+      ...declared(adapters[index])
+    }));
+    const answered = withAnsweredThere(answeredIn({ sources, sessions: found }), found);
     const changes = [];
     results.forEach((result, index) => {
       const { state } = result.health;
@@ -1413,35 +1538,29 @@ function createPoller(options) {
       const { baselines, reported } = remembered;
       const basis = result.basis ?? "";
       const previous = baselines.get(basis);
+      const sessions = previous ? forEvents(result.sessions, previous, answered) : result.sessions;
       if (previous) {
-        changes.push(...withoutRepeats(diffSessions(previous, result.sessions, at), reported));
+        changes.push(...withoutRepeats(diffSessions(previous, sessions, at), reported));
       } else {
         if (lastSeen) {
           const known = new Set(lastSeen.map((session) => session.id));
           const before = lastSeen.filter(
             (session) => session.status !== null
           );
-          const after = result.sessions.filter((session) => known.has(session.id));
+          const after = sessions.filter((session) => known.has(session.id));
           changes.push(...diffSessions(before, after, at));
         }
-        for (const session of result.sessions) {
+        for (const session of sessions) {
           if (!reported.has(session.id)) reported.set(session.id, session.status);
         }
       }
-      baselines.set(basis, result.sessions.map(withoutWaitingText));
+      baselines.set(basis, sessions.map(withoutWaitingText));
     });
     const rules = options.timeRules?.();
     const snapshot = {
       generatedAt: at,
-      // The way each was read goes with it, so what follows the snapshots
-      // compares answers the way the event log does. So does what its agent
-      // can report, whatever the answer was.
-      sources: results.map((result, index) => ({
-        ...result.health,
-        ...result.basis !== void 0 && { basis: result.basis },
-        ...declared(adapters[index])
-      })),
-      sessions: sortSessions(staleBy(found, at, staleAfterMs(rules))),
+      sources,
+      sessions: sortSessions(staleBy(markAnswered(found, answered), at, staleAfterMs(rules))),
       ...rules && { timeRules: rules, quiet: isQuietAt(rules.quietHours, at) }
     };
     latest = snapshot;
@@ -1570,7 +1689,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) {
@@ -1791,11 +1912,12 @@ function createApiHandler(options) {
   if (options.cleanUp) actions.set(CLEAN_UP_PATH, options.cleanUp);
   if (options.answer) actions.set(ANSWER_PATH, options.answer);
   if (options.timeRules) actions.set(TIME_RULES_PATH, options.timeRules);
+  if (options.permissionRules) actions.set(PERMISSION_RULES_PATH, options.permissionRules);
   const serveSnapshot = options.serveSnapshot ?? ((snapshot) => snapshot);
   function route(req, res) {
-    const refusal2 = refusalFor(req);
-    if (refusal2) {
-      fail(res, 403, refusal2);
+    const refusal3 = refusalFor(req);
+    if (refusal3) {
+      fail(res, 403, refusal3);
       return;
     }
     let url;
@@ -2136,7 +2258,7 @@ function urlFor(address) {
 
 // src/collector/hosts/standalone.ts
 import { existsSync } from "node:fs";
-import path23 from "node:path";
+import path21 from "node:path";
 
 // src/core/mapping/claudeCodeMapping.ts
 var LIVE_STATUS = /* @__PURE__ */ new Map([
@@ -2195,7 +2317,7 @@ function claudeCodeOpenLink(surface, sessionId) {
 }
 
 // src/collector/terminal/terminalTabs.ts
-import path2 from "node:path";
+import path2 from "node:path/posix";
 var TERMINAL_PATH = "/System/Applications/Utilities/Terminal.app/Contents/MacOS/Terminal";
 var ITERM_PATH = "/Applications/iTerm.app/Contents/MacOS/iTerm2";
 var ITERM_SERVER_FOLDER = "Library/Application Support/iTerm2";
@@ -2785,7 +2907,15 @@ import path4 from "node:path";
 import { constants } from "node:fs";
 import { access, stat as stat2 } from "node:fs/promises";
 import path3 from "node:path";
-async function isExecutableFile(candidate) {
+function pathsOf(platform) {
+  return platform === "win32" ? path3.win32 : path3.posix;
+}
+var WINDOWS_PROGRAM_ENDINGS = [".com", ".exe"];
+function isWindowsProgram(file) {
+  return WINDOWS_PROGRAM_ENDINGS.includes(path3.win32.extname(file).toLowerCase());
+}
+async function isExecutableFile(candidate, platform = process.platform) {
+  if (platform === "win32" && !isWindowsProgram(candidate)) return false;
   try {
     const info = await stat2(candidate);
     if (!info.isFile()) return false;
@@ -2795,44 +2925,103 @@ async function isExecutableFile(candidate) {
     return false;
   }
 }
-function pathCandidates(env, program) {
-  return (env.PATH ?? "").split(path3.delimiter).filter((dir) => dir !== "" && path3.isAbsolute(dir)).map((dir) => path3.join(dir, program));
+function variable(env, name, platform = process.platform) {
+  if (platform !== "win32" || env[name] !== void 0) return env[name];
+  const key = Object.keys(env).find((each) => each.toUpperCase() === name);
+  return key === void 0 ? void 0 : env[key];
 }
-function tildify(target, homeDir) {
-  if (homeDir === "" || homeDir === path3.sep) return target;
-  if (target === homeDir) return "~";
-  if (target.startsWith(homeDir + path3.sep)) return `~${target.slice(homeDir.length)}`;
-  return target;
+function programEndings(env) {
+  const listed = (variable(env, "PATHEXT", "win32") ?? "").split(";").map((ending) => ending.trim().toLowerCase()).filter((ending) => WINDOWS_PROGRAM_ENDINGS.includes(ending));
+  return listed.length > 0 ? [...new Set(listed)] : WINDOWS_PROGRAM_ENDINGS;
+}
+function pathFolders(env, platform = process.platform) {
+  const paths = pathsOf(platform);
+  return (variable(env, "PATH", platform) ?? "").split(paths.delimiter).map((dir) => platform === "win32" ? dir.trim().replace(/^"(.*)"$/, "$1") : dir).filter((dir) => dir !== "" && paths.isAbsolute(dir));
+}
+function programNames(env, program, platform = process.platform) {
+  if (platform !== "win32" || isWindowsProgram(program)) return [program];
+  return programEndings(env).map((ending) => `${program}${ending}`);
+}
+function pathCandidates(env, program, platform = process.platform) {
+  const paths = pathsOf(platform);
+  const names = programNames(env, program, platform);
+  return pathFolders(env, platform).flatMap((dir) => names.map((name) => paths.join(dir, name)));
+}
+function tildify(target, homeDir, platform = process.platform) {
+  if (homeDir === "") return target;
+  if (platform !== "win32") {
+    if (homeDir === "/") return target;
+    if (target === homeDir) return "~";
+    if (target.startsWith(`${homeDir}/`)) return `~${target.slice(homeDir.length)}`;
+    return target;
+  }
+  const home = path3.win32.resolve(homeDir);
+  if (path3.win32.parse(home).root === home) return target;
+  const inside = path3.win32.relative(home, path3.win32.resolve(target));
+  if (inside === "") return "~";
+  if (inside === ".." || inside.startsWith("..\\") || path3.win32.isAbsolute(inside)) return target;
+  return `~/${inside.replaceAll("\\", "/")}`;
 }
 
 // src/collector/adapters/claude-code/findBinary.ts
 var CLAUDE_BIN_ENV = "AGENT_LOOKOUT_CLAUDE_BIN";
-function fixedLocations(homeDir) {
+var NPM_PROGRAM = ["node_modules", "@anthropic-ai", "claude-code", "bin", "claude.exe"];
+function npmFolder(env, homeDir) {
+  const appData = variable(env, "APPDATA", "win32")?.trim();
+  return appData && path4.win32.isAbsolute(appData) ? path4.win32.join(appData, "npm") : path4.win32.join(homeDir, "AppData", "Roaming", "npm");
+}
+function fixedLocations(homeDir, platform = process.platform, env = {}) {
+  if (platform === "win32") {
+    return [
+      path4.win32.join(homeDir, ".local", "bin", "claude.exe"),
+      path4.win32.join(npmFolder(env, homeDir), ...NPM_PROGRAM)
+    ];
+  }
   return [
-    path4.join(homeDir, ".local", "bin", "claude"),
+    path4.posix.join(homeDir, ".local", "bin", "claude"),
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude",
-    path4.join(homeDir, ".npm-global", "bin", "claude"),
+    path4.posix.join(homeDir, ".npm-global", "bin", "claude"),
     "/usr/bin/claude"
   ];
 }
+function onPath(env, platform) {
+  if (platform !== "win32") return pathCandidates(env, "claude", platform);
+  const names = programNames(env, "claude", platform);
+  return pathFolders(env, platform).flatMap((dir) => [
+    ...names.map((name) => path4.win32.join(dir, name)),
+    path4.win32.join(dir, ...NPM_PROGRAM)
+  ]);
+}
+var WINDOWS_SCRIPT = /\.(bat|cmd|ps1)$/i;
 async function findClaudeBinary(options) {
-  const isExecutable = options.isExecutable ?? isExecutableFile;
+  const platform = options.platform ?? process.platform;
+  const paths = pathsOf(platform);
+  const isExecutable = options.isExecutable ?? ((candidate) => isExecutableFile(candidate, platform));
   const named = options.env[CLAUDE_BIN_ENV]?.trim();
   if (named) {
-    const resolved = path4.resolve(named);
+    const resolved = paths.resolve(named);
     if (await isExecutable(resolved)) return { found: true, path: resolved };
-    return {
-      found: false,
-      looked: `${CLAUDE_BIN_ENV} is set to ${named}, which is not a program this user can run`
-    };
+    const why = platform === "win32" && WINDOWS_SCRIPT.test(resolved) ? "a script that needs a shell to run, and Agent Lookout runs no shell" : "not a program this user can run";
+    return { found: false, looked: `${CLAUDE_BIN_ENV} is set to ${named}, which is ${why}` };
   }
-  const fixed = fixedLocations(options.homeDir);
-  const candidates = [.../* @__PURE__ */ new Set([...pathCandidates(options.env, "claude"), ...fixed])];
+  const fixed = fixedLocations(options.homeDir, platform, options.env);
+  const candidates = [.../* @__PURE__ */ new Set([...onPath(options.env, platform), ...fixed])];
   for (const candidate of candidates) {
     if (await isExecutable(candidate)) return { found: true, path: candidate };
   }
-  const fixedDirs = fixed.map((candidate) => tildify(path4.dirname(candidate), options.homeDir));
+  if (platform === "win32") {
+    const places = [paths.dirname(fixed[0]), npmFolder(options.env, options.homeDir)].map(
+      (place) => tildify(place, options.homeDir, platform)
+    );
+    return {
+      found: false,
+      looked: `The claude command, claude.exe, was not found on PATH or in ${listWithOr(places)}`
+    };
+  }
+  const fixedDirs = fixed.map(
+    (candidate) => tildify(paths.dirname(candidate), options.homeDir, platform)
+  );
   return {
     found: false,
     looked: `The claude command was not found on PATH or in ${listWithOr(fixedDirs)}`
@@ -2845,7 +3034,6 @@ function listWithOr(items) {
 
 // src/collector/adapters/claude-code/index.ts
 import os from "node:os";
-import path9 from "node:path";
 
 // src/core/time.ts
 var EARLIEST_PLAUSIBLE_TIME_MS = Date.UTC(2020, 0, 1);
@@ -3044,13 +3232,73 @@ function createFinishedTracker(retentionMs = FINISHED_RETENTION_MS) {
 }
 
 // src/collector/adapters/claude-code/registry.ts
-import { constants as constants2 } from "node:fs";
-import { open, readdir } from "node:fs/promises";
+import { constants as constants3 } from "node:fs";
+import { readdir } from "node:fs/promises";
 import path5 from "node:path";
+
+// src/collector/files/noFollow.ts
+import { closeSync, constants as constants2, fstatSync, lstatSync, openSync } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+var OPEN_FOLLOWS_LINKS = constants2.O_NOFOLLOW === void 0;
+var NO_FOLLOW = (constants2.O_NOFOLLOW ?? 0) | (constants2.O_NONBLOCK ?? 0);
+function notOrdinary() {
+  return new Error("Not an ordinary file.");
+}
+function refusal2(named) {
+  if (!named.isSymbolicLink()) return notOrdinary();
+  return Object.assign(new Error("A symbolic link, which is not followed."), { code: "ELOOP" });
+}
+function sameFile(named, opened) {
+  return named.isFile() && named.dev === opened.dev && named.ino === opened.ino;
+}
+function isMissing(error) {
+  return error?.code === "ENOENT";
+}
+var creates = (flags) => (flags & constants2.O_CREAT) !== 0;
+async function openWithoutFollowing(file, flags, mode, follows = OPEN_FOLLOWS_LINKS) {
+  if (!follows) return open(file, flags | NO_FOLLOW, mode);
+  let before = null;
+  try {
+    before = await lstat(file, { bigint: true });
+  } catch (error) {
+    if (!(isMissing(error) && creates(flags))) throw error;
+  }
+  if (before !== null && !before.isFile()) throw refusal2(before);
+  const handle = await open(file, flags, mode);
+  try {
+    const opened = await handle.stat({ bigint: true });
+    const named = before ?? await lstat(file, { bigint: true });
+    if (!sameFile(named, opened)) throw notOrdinary();
+    return handle;
+  } catch (error) {
+    await handle.close();
+    throw error;
+  }
+}
+function openWithoutFollowingNow(file, flags, mode, follows = OPEN_FOLLOWS_LINKS) {
+  if (!follows) return openSync(file, flags | NO_FOLLOW, mode);
+  let before = null;
+  try {
+    before = lstatSync(file, { bigint: true });
+  } catch (error) {
+    if (!(isMissing(error) && creates(flags))) throw error;
+  }
+  if (before !== null && !before.isFile()) throw refusal2(before);
+  const fd = openSync(file, flags, mode);
+  try {
+    const named = before ?? lstatSync(file, { bigint: true });
+    if (!sameFile(named, fstatSync(fd, { bigint: true }))) throw notOrdinary();
+    return fd;
+  } catch (error) {
+    closeSync(fd);
+    throw error;
+  }
+}
+
+// src/collector/adapters/claude-code/registry.ts
 var MAX_ENTRY_BYTES = 256 * 1024;
 async function readRegularFile(file) {
-  const flags = constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0) | (constants2.O_NONBLOCK ?? 0);
-  const handle = await open(file, flags);
+  const handle = await openWithoutFollowing(file, constants3.O_RDONLY);
   try {
     const info = await handle.stat();
     if (!info.isFile()) throw new Error("Not an ordinary file.");
@@ -3108,7 +3356,7 @@ function parseRegistryEntry(content) {
     procStart: text2(raw.procStart)
   };
 }
-async function readRegistry(sessionsDir, io = nodeIo) {
+async function readRegistry(sessionsDir, io = nodeIo, previous) {
   let names;
   try {
     names = await io.readdir(sessionsDir);
@@ -3117,22 +3365,28 @@ async function readRegistry(sessionsDir, io = nodeIo) {
     return { readable: false, missing: code === "ENOENT" || code === "ENOTDIR" };
   }
   const files = names.filter(isRegistryFileName).sort();
-  const parsed = await Promise.all(
+  const parsed = /* @__PURE__ */ new Map();
+  const found = await Promise.all(
     files.map(async (name) => {
+      let content;
       try {
-        return parseRegistryEntry(await io.readFile(path5.join(sessionsDir, name)));
+        content = await io.readFile(path5.join(sessionsDir, name));
       } catch {
         return null;
       }
+      const entry = parseRegistryEntry(content);
+      if (entry === null) return previous?.get(name) ?? null;
+      parsed.set(name, entry);
+      return entry;
     })
   );
   const entries = /* @__PURE__ */ new Map();
-  parsed.forEach((entry, index) => {
+  found.forEach((entry, index) => {
     if (!entry) return;
     const isNamedForPid = files[index] === `${entry.pid}.json`;
     if (isNamedForPid || !entries.has(entry.pid)) entries.set(entry.pid, entry);
   });
-  return { readable: true, entries };
+  return { readable: true, entries, parsed };
 }
 
 // src/collector/adapters/claude-code/stopOffers.ts
@@ -3153,7 +3407,7 @@ function build(fields, origin, context) {
   const project = projectOf(fields.cwd);
   const surface = mapClaudeCodeSurface(fields.entrypoint);
   const mapped = mapClaudeCodeStatus(fields, origin);
-  const open4 = claudeCodeOpenLink(surface, fields.sessionId);
+  const open2 = claudeCodeOpenLink(surface, fields.sessionId);
   const startedAt = plausibleTime(fields.startedAt, context.now);
   let statusSince = plausibleTime(fields.statusUpdatedAt, context.now);
   if (statusSince !== null && startedAt !== null && statusSince < startedAt - WRITE_ORDER_SLACK_MS) {
@@ -3170,7 +3424,7 @@ function build(fields, origin, context) {
     ...mapped,
     startedAt,
     statusSince,
-    links: open4 ? { open: open4 } : {},
+    links: open2 ? { open: open2 } : {},
     stale: isStale({ status: mapped.status, statusSince }, context.now)
   };
   if (fields.pid !== void 0) {
@@ -3273,8 +3527,8 @@ function withStopOffers(sessions, live2, answer, options) {
 import path8 from "node:path";
 
 // src/collector/files/readOnlyIo.ts
-import { constants as constants3 } from "node:fs";
-import { lstat, open as open2, readdir as readdir2, stat as stat3 } from "node:fs/promises";
+import { constants as constants4 } from "node:fs";
+import { lstat as lstat2, readdir as readdir2, stat as stat3 } from "node:fs/promises";
 function infoOf(stats) {
   return {
     kind: stats.isFile() ? "file" : stats.isDirectory() ? "directory" : "other",
@@ -3284,8 +3538,7 @@ function infoOf(stats) {
   };
 }
 async function openRegularFile(file) {
-  const flags = constants3.O_RDONLY | (constants3.O_NOFOLLOW ?? 0) | (constants3.O_NONBLOCK ?? 0);
-  const handle = await open2(file, flags);
+  const handle = await openWithoutFollowing(file, constants4.O_RDONLY);
   let info;
   try {
     info = infoOf(await handle.stat());
@@ -3317,10 +3570,10 @@ async function openRegularFile(file) {
 var nodeIo2 = {
   readdir: (dir) => readdir2(dir),
   stat: async (target) => infoOf(await stat3(target)),
-  lstat: async (target) => infoOf(await lstat(target)),
+  lstat: async (target) => infoOf(await lstat2(target)),
   openRegular: openRegularFile
 };
-function isMissing(error) {
+function isMissing2(error) {
   const code = error?.code;
   return code === "ENOENT" || code === "ENOTDIR";
 }
@@ -3493,12 +3746,12 @@ function sameStamp(a, b) {
   return a.size === b.size && a.mtimeMs === b.mtimeMs && a.ino === b.ino;
 }
 async function readTranscriptTail(file, io, known, maxBytes = TRANSCRIPT_TAIL_BYTES) {
-  const open4 = await io.openRegular(file);
+  const open2 = await io.openRegular(file);
   try {
-    const stamp = stampOf(open4.info);
+    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 open4.read(start, stamp.size - start);
+    const bytes2 = await open2.read(start, stamp.size - start);
     return {
       unchanged: false,
       stamp,
@@ -3506,7 +3759,7 @@ async function readTranscriptTail(file, io, known, maxBytes = TRANSCRIPT_TAIL_BY
       fromStart: start === 0
     };
   } finally {
-    await open4.close();
+    await open2.close();
   }
 }
 
@@ -3544,7 +3797,7 @@ function createWaitingTextReader(options) {
       }
       return wait.text;
     } catch (error) {
-      if (isMissing(error)) wait.file = null;
+      if (isMissing2(error)) wait.file = null;
       wait.lookedAt = at;
       wait.stamp = null;
       wait.text = void 0;
@@ -3613,7 +3866,22 @@ var CLAUDE_CODE_CAPABILITIES = {
   },
   answer: {
     level: "partly",
-    reason: "With the Agent Lookout plugin installed. Allow only when all it allows is shown, so edits, plans and questions can only be denied."
+    reason: "With the Agent Lookout plugin, by Allow, Deny or a permission rule. Allow only if all is shown: never edits, plans or questions."
+  }
+};
+var CLAUDE_CODE_WINDOWS_CAPABILITIES = {
+  ...CLAUDE_CODE_CAPABILITIES,
+  jump: {
+    level: "partly",
+    reason: "Only in VS Code. On Windows there is no tmux pane or Terminal tab to reach, and the desktop app has no link."
+  },
+  stop: {
+    level: "no",
+    reason: "Not on Windows, where there is no ps to confirm a session's process by its start time, and no POSIX signal to stop it."
+  },
+  answer: {
+    level: "no",
+    reason: "Not on Windows: the plugin's hook is a POSIX sh script, and it reaches Agent Lookout through a Unix socket."
   }
 };
 var STOP_TURNED_OFF = {
@@ -3649,21 +3917,25 @@ function createClaudeCodeAdapter(options = {}) {
   const transcriptsOff = waitingTextOff(env);
   const feedWithheld = homeOverride !== void 0 && !binaryNamed;
   const neverRun = feedOff || feedWithheld;
-  const stops = stopOff(env) ? void 0 : options.stops;
+  const platform = options.platform ?? process.platform;
+  const onWindows = platform === "win32";
+  const paths = pathsOf(platform);
+  const stops = stopOff(env) || onWindows ? void 0 : options.stops;
   const answersOff = env.AGENT_LOOKOUT_ANSWER?.trim().toLowerCase() === "off";
-  const capabilities = stopOff(env) || answersOff ? {
+  const capabilities = onWindows ? CLAUDE_CODE_WINDOWS_CAPABILITIES : stopOff(env) || answersOff ? {
     ...CLAUDE_CODE_CAPABILITIES,
     ...stopOff(env) && { stop: STOP_TURNED_OFF },
     ...answersOff && { answer: ANSWER_TURNED_OFF }
   } : CLAUDE_CODE_CAPABILITIES;
-  const claudeHome = path9.resolve(homeOverride ?? path9.join(homeDir, ".claude"));
-  const sessionsDir = path9.join(claudeHome, "sessions");
-  const homeName = tildify(claudeHome, homeDir);
-  const registryName = tildify(sessionsDir, homeDir);
+  const claudeHome = paths.resolve(homeOverride ?? paths.join(homeDir, ".claude"));
+  const sessionsDir = paths.join(claudeHome, "sessions");
+  const homeName = tildify(claudeHome, homeDir, platform);
+  const registryName = tildify(sessionsDir, homeDir, platform);
   const waitingTexts = transcriptsOff ? null : createWaitingTextReader({ claudeHome, io: options.transcriptIo, now });
   let lastDue = null;
   let lastRead = null;
   let feedSoon = false;
+  let lastParsed;
   stops?.onAskFeedSoon(() => {
     feedSoon = true;
   });
@@ -3686,7 +3958,8 @@ function createClaudeCodeAdapter(options = {}) {
     ];
   }
   async function readRegistryNow(at) {
-    const registry = await readRegistry(sessionsDir, options.registryIo);
+    const registry = await readRegistry(sessionsDir, options.registryIo, lastParsed);
+    lastParsed = registry.readable ? registry.parsed : void 0;
     if (!registry.readable) return { registry, live: [], unknownStatus: false };
     const candidates = [...registry.entries.values()].filter(
       (entry) => entry.sessionId !== void 0 && isClaudeCodeSessionKind(entry.kind) && isAlive(entry.pid)
@@ -3720,7 +3993,12 @@ function createClaudeCodeAdapter(options = {}) {
     return at - due < intervalMs ? due : at;
   }
   async function runCommand(askedAt) {
-    const binary = await findClaudeBinary({ env, homeDir, isExecutable: options.isExecutable });
+    const binary = await findClaudeBinary({
+      env,
+      homeDir,
+      isExecutable: options.isExecutable,
+      platform
+    });
     if (!binary.found) {
       return {
         askedAt,
@@ -4119,8 +4397,10 @@ function stopFailed(reason) {
 function stopRefusalFor(req) {
   return actionRefusalFor(req, STOP_ACTION, MAX_STOP_BODY_BYTES);
 }
-function stillOffered(snapshot, sessionId) {
-  return snapshot.sessions.some((session) => session.id === sessionId && session.stop);
+function notSeenToStop(snapshot, stopped) {
+  return snapshot.sessions.some(
+    (session) => session.id === stopped.id && (session.stop !== void 0 || stopped.stop?.how === "background" && session.status !== "finished" && session.status !== "failed")
+  );
 }
 async function lookAgain(options, stopped) {
   if (stopped.length === 0) return;
@@ -4129,7 +4409,7 @@ async function lookAgain(options, stopped) {
   }
   try {
     const first = await options.poller.pollOnce();
-    if (stopped.some((session) => stillOffered(first, session.id))) {
+    if (stopped.some((session) => notSeenToStop(first, session))) {
       await options.poller.pollOnce();
     }
   } catch {
@@ -4148,7 +4428,9 @@ function createStopRoute(options) {
       if (acted === "signalled") {
         const running = await stopper.waitForEnd([target.pid]);
         if (running.size > 0) return stopFailed("still-running");
-      } else if (acted !== "stopped") {
+      } else if (acted === "stopped") {
+        await stopper.waitForEnd([target.pid]);
+      } else {
         return stopFailed(acted);
       }
       events.add([stoppedEvent(session, stopper.now())]);
@@ -4266,9 +4548,7 @@ function createCleanUpRoute(options) {
         outcomes[index] = acted;
       }
     }
-    const running = await stopper.waitForEnd(
-      sent.filter((one) => one.signalled).map((one) => one.target.pid)
-    );
+    const running = await stopper.waitForEnd(sent.map((one) => one.target.pid));
     const ended = [];
     for (const one of sent) {
       if (one.signalled && running.has(one.target.pid)) outcomes[one.index] = "still-running";
@@ -4367,6 +4647,15 @@ function answeredEvent(session, decision, at) {
     decision
   };
 }
+async function pollAfterAnswer(poller, sessionId) {
+  try {
+    const first = await poller.pollOnce();
+    if (first.sessions.some((session) => session.id === sessionId && needsYou(session))) {
+      await poller.pollOnce();
+    }
+  } catch {
+  }
+}
 function answerRefusalFor(req) {
   return actionRefusalFor(req, ANSWER_ACTION, MAX_ANSWER_BODY_BYTES);
 }
@@ -4396,8 +4685,7 @@ function createAnswerRoute(options) {
     const outcome = await asks.answer(asked.sessionId, asked.requestId, asked.decision);
     if (outcome !== "answered") return answerFailed(outcome);
     events.add([answeredEvent(session, asked.decision, now())]);
-    void poller.pollOnce().catch(() => {
-    });
+    await pollAfterAnswer(poller, asked.sessionId);
     return {
       status: 200,
       body: { ok: true, decision: asked.decision }
@@ -4407,7 +4695,6 @@ function createAnswerRoute(options) {
 
 // src/collector/answers/answerSettings.ts
 import os3 from "node:os";
-import path10 from "node:path";
 var ANSWER_ENV = "AGENT_LOOKOUT_ANSWER";
 var ANSWER_SOCKET_ENV = "AGENT_LOOKOUT_ANSWER_SOCKET";
 var ANSWER_WAIT_ENV = "AGENT_LOOKOUT_ANSWER_WAIT";
@@ -4415,6 +4702,7 @@ var DEFAULT_HOLD_MS = 3e5;
 var MIN_HOLD_MS = 5e3;
 var MAX_HOLD_MS = 54e4;
 var MAX_SOCKET_PATH_BYTES = 103;
+var WINDOWS_PROBLEM = "Permission prompts are not answered from Agent Lookout on Windows: the plugin's hook is a POSIX sh script, and it reaches Agent Lookout through a Unix socket.";
 function answerOff(env) {
   return env[ANSWER_ENV]?.trim().toLowerCase() === "off";
 }
@@ -4435,7 +4723,8 @@ function readAnswerSetup(env, homeDir = os3.homedir(), platform = process.platfo
       on: false,
       socketPath: null,
       holdMs: holdMs ?? DEFAULT_HOLD_MS,
-      problem: "Answering permission prompts is not offered on Windows."
+      problem: WINDOWS_PROBLEM,
+      quiet: true
     };
   }
   if (holdMs === null) {
@@ -4456,8 +4745,9 @@ function readAnswerSetup(env, homeDir = os3.homedir(), platform = process.platfo
       quiet: true
     };
   }
-  const ownDir = path10.resolve(homeDir, ".agent-lookout");
-  const socketPath = path10.resolve(named || path10.join(ownDir, "answer.sock"));
+  const paths = pathsOf(platform);
+  const ownDir = paths.resolve(homeDir, ".agent-lookout");
+  const socketPath = paths.resolve(named || paths.join(ownDir, "answer.sock"));
   if (Buffer.byteLength(socketPath) > MAX_SOCKET_PATH_BYTES) {
     return {
       on: false,
@@ -4471,7 +4761,7 @@ function readAnswerSetup(env, homeDir = os3.homedir(), platform = process.platfo
     socketPath,
     holdMs,
     problem: null,
-    ownFolder: path10.dirname(socketPath) === ownDir
+    ownFolder: paths.dirname(socketPath) === ownDir
   };
 }
 
@@ -4485,8 +4775,6 @@ var MAX_BLANK_RUN = 2;
 var MAX_INPUTS = 30;
 var MAX_TOOL_NAME_CHARS = 200;
 var MAX_DESCRIPTION_CHARS = 200;
-var EDIT_TOOLS = ["Edit", "Write", "MultiEdit", "NotebookEdit"];
-var NOT_YES_OR_NO_TOOLS = ["ExitPlanMode", "AskUserQuestion"];
 var EDIT_INPUTS = ["file_path", "notebook_path"];
 var HIDDEN = /[\p{Cc}\p{Cf}\p{Co}\p{Cn}\p{Cs}\p{Default_Ignorable_Code_Point}\u2028\u2029]/gu;
 var RIGHT_TO_LEFT = /[\p{Script=Hebrew}\p{Script=Arabic}\p{Script=Syriac}\p{Script=Thaana}\p{Script=Nko}\p{Script=Samaritan}\p{Script=Mandaic}\p{Script=Adlam}\p{Script=Hanifi_Rohingya}\p{Script=Mende_Kikakui}\p{Script=Old_Hungarian}\p{Script=Kharoshthi}\p{Script=Phoenician}\p{Script=Imperial_Aramaic}\p{Script=Avestan}\p{Script=Old_South_Arabian}\p{Script=Old_North_Arabian}\p{Script=Nabataean}\p{Script=Palmyrene}\p{Script=Manichaean}\p{Script=Inscriptional_Pahlavi}\p{Script=Inscriptional_Parthian}\p{Script=Psalter_Pahlavi}\p{Script=Sogdian}\p{Script=Old_Sogdian}\p{Script=Elymaic}\p{Script=Lydian}\p{Script=Cypriot}]/u;
@@ -4642,6 +4930,7 @@ function createHeldAsks(options) {
   const newId = options.newId ?? (() => randomBytes(16).toString("hex"));
   const startedAt = now();
   const held = /* @__PURE__ */ new Map();
+  let answers2 = /* @__PURE__ */ new Map();
   const lastRequest = /* @__PURE__ */ new Map();
   let seenAt = null;
   let missedAt = null;
@@ -4673,6 +4962,8 @@ function createHeldAsks(options) {
       if (!entry.confirmed) {
         entry.confirmed = true;
         entry.wait = reading.wait;
+        entry.since = reading.since ?? null;
+        answerByRule(entry);
         return;
       }
       if (reading.wait !== entry.wait) drop(entry, "left-waiting");
@@ -4692,6 +4983,55 @@ function createHeldAsks(options) {
       if (inFlight === run) inFlight = null;
     }
   }
+  async function answer(sessionId, requestId, decision) {
+    const entry = held.get(sessionId);
+    if (!entry || entry.requestId !== requestId || !entry.confirmed) return "no-ask";
+    if (decision === "allow" && !entry.shown.allow) return "not-allowable";
+    if (entry.answering) return "too-soon";
+    entry.answering = true;
+    const reading = await read(sessionId);
+    if (held.get(sessionId) !== entry || !entry.reply.isOpen()) {
+      if (held.get(sessionId) === entry) drop(entry, "closed");
+      return "gone";
+    }
+    const sameWait = reading.status === "waiting" && reading.wait === entry.wait;
+    if (!sameWait || now() >= entry.until) {
+      drop(entry, sameWait ? "limit" : "left-waiting");
+      return "gone";
+    }
+    held.delete(sessionId);
+    entry.reply.send(decisionOutput(decision));
+    answers2.set(sessionId, { source: SOURCE, since: entry.since, at: now() });
+    if (held.size === 0 && stopTimer !== null) {
+      stopTimer();
+      stopTimer = null;
+    }
+    return "answered";
+  }
+  function answerByRule(entry) {
+    const rules = options.rules;
+    if (rules === void 0) return;
+    const request2 = { sessionId: entry.sessionId, shown: entry.shown };
+    const verdict = verdictOf(entry);
+    if (verdict === null) return;
+    entry.byRule = true;
+    void answer(entry.sessionId, entry.requestId, verdict.decision).then((outcome) => {
+      if (outcome === "answered") rules.answered(request2, verdict);
+    });
+  }
+  function verdictOf(entry) {
+    if (options.rules === void 0) return null;
+    try {
+      return options.rules.verdictFor({ sessionId: entry.sessionId, shown: entry.shown });
+    } catch {
+      return null;
+    }
+  }
+  function answeringByRule(entry) {
+    if (!entry.reply.isOpen()) return false;
+    if (entry.confirmed) return entry.answering && entry.byRule;
+    return verdictOf(entry) !== null;
+  }
   function status() {
     const plugin = seenAt !== null && (missedAt === null || seenAt > missedAt) ? "seen" : missedAt !== null ? "missed" : "unknown";
     return { state: "on", plugin, holdMs };
@@ -4704,6 +5044,7 @@ function createHeldAsks(options) {
       const at = now();
       const older = held.get(request2.sessionId);
       if (older) drop(older, "newer");
+      answers2.delete(request2.sessionId);
       const entry = {
         requestId: newId(),
         sessionId: request2.sessionId,
@@ -4713,7 +5054,9 @@ function createHeldAsks(options) {
         reply,
         confirmed: false,
         wait: null,
-        answering: false
+        since: null,
+        answering: false,
+        byRule: false
       };
       if (held.size >= MAX_HELD) {
         drop(entry, "full");
@@ -4729,30 +5072,7 @@ function createHeldAsks(options) {
       void check();
     },
     check,
-    async answer(sessionId, requestId, decision) {
-      const entry = held.get(sessionId);
-      if (!entry || entry.requestId !== requestId || !entry.confirmed) return "no-ask";
-      if (decision === "allow" && !entry.shown.allow) return "not-allowable";
-      if (entry.answering) return "too-soon";
-      entry.answering = true;
-      const reading = await read(sessionId);
-      if (held.get(sessionId) !== entry || !entry.reply.isOpen()) {
-        if (held.get(sessionId) === entry) drop(entry, "closed");
-        return "gone";
-      }
-      const sameWait = reading.status === "waiting" && reading.wait === entry.wait;
-      if (!sameWait || now() >= entry.until) {
-        drop(entry, sameWait ? "limit" : "left-waiting");
-        return "gone";
-      }
-      held.delete(sessionId);
-      entry.reply.send(decisionOutput(decision));
-      if (held.size === 0 && stopTimer !== null) {
-        stopTimer();
-        stopTimer = null;
-      }
-      return "answered";
-    },
+    answer,
     withAsks(snapshot) {
       const answering = status();
       if (held.size === 0) return { ...snapshot, answering };
@@ -4765,6 +5085,17 @@ function createHeldAsks(options) {
       });
       return { ...snapshot, sessions, answering };
     },
+    answeredIn(snapshot) {
+      const { ids, kept } = answeredNow(answers2, snapshot, now());
+      answers2 = kept;
+      for (const entry of held.values()) {
+        if (!answeringByRule(entry)) continue;
+        const session = snapshot.sessions.find((listed) => listed.id === entry.sessionId);
+        const since = entry.confirmed ? entry.since : null;
+        if (session && inAnsweredWait(session, { since })) ids.add(entry.sessionId);
+      }
+      return ids;
+    },
     noteRequest(sessionId) {
       const at = now();
       seenAt = at;
@@ -4801,10 +5132,10 @@ function createHeldAsks(options) {
 }
 
 // src/collector/answers/hookSocket.ts
-import { chmod, lstat as lstat2, mkdir, stat as stat4, unlink } from "node:fs/promises";
+import { chmod, lstat as lstat3, mkdir, stat as stat4, unlink } from "node:fs/promises";
 import http from "node:http";
 import net from "node:net";
-import path11 from "node:path";
+import path9 from "node:path";
 var HOOK_PATH = "/hooks/permission-request";
 var HOOK_HEADER = "x-agent-lookout-hook";
 var HOOK_HEADER_VALUE = "permission-request";
@@ -4877,7 +5208,7 @@ function createHookSocket(options) {
   const maxBody = options.maxBodyBytes ?? MAX_HOOK_BODY_BYTES;
   const bodyTimeoutMs = options.bodyTimeoutMs ?? HOOK_BODY_TIMEOUT_MS;
   const uid = options.uid ?? process.getuid?.() ?? -1;
-  const folder = path11.dirname(socketPath);
+  const folder = path9.dirname(socketPath);
   let server = null;
   let made = null;
   async function handle(req, res) {
@@ -4911,7 +5242,7 @@ function createHookSocket(options) {
   async function readyFolder() {
     try {
       const madeHere = await mkdir(folder, { recursive: true, mode: 448 });
-      const info = await lstat2(folder);
+      const info = await lstat3(folder);
       if (!info.isDirectory()) return `${folder} is not a folder, so answering is off.`;
       if (uid >= 0 && info.uid !== uid) {
         return `${folder} belongs to another user, so answering is off.`;
@@ -4930,7 +5261,7 @@ function createHookSocket(options) {
   async function freePath() {
     let info;
     try {
-      info = await lstat2(socketPath);
+      info = await lstat3(socketPath);
     } catch (error) {
       return errorCode2(error) === "ENOENT" ? null : `${socketPath} could not be read.`;
     }
@@ -5000,12 +5331,12 @@ function createHookSocket(options) {
 
 // src/collector/answers/registryStatus.ts
 import os4 from "node:os";
-import path12 from "node:path";
+import path10 from "node:path";
 function createRegistryStatus(options) {
   const homeDir = options.homeDir ?? os4.homedir();
   const readFile2 = options.readFile ?? readRegularFile;
-  const home = options.env[CLAUDE_HOME_ENV]?.trim() || path12.join(homeDir, ".claude");
-  const sessionsDir = path12.join(path12.resolve(home), "sessions");
+  const home = options.env[CLAUDE_HOME_ENV]?.trim() || path10.join(homeDir, ".claude");
+  const sessionsDir = path10.join(path10.resolve(home), "sessions");
   return {
     async statusOf(sessionId) {
       const unknown = { status: "unknown" };
@@ -5016,7 +5347,7 @@ function createRegistryStatus(options) {
       const ownId = sessionId.slice("claude-code:".length);
       let content;
       try {
-        content = await readFile2(path12.join(sessionsDir, `${pid}.json`));
+        content = await readFile2(path10.join(sessionsDir, `${pid}.json`));
       } catch {
         return unknown;
       }
@@ -5026,12 +5357,618 @@ function createRegistryStatus(options) {
       if (!forPermission) return { status: "not-waiting" };
       return {
         status: "waiting",
-        wait: `${entry.statusUpdatedAt ?? ""}|${entry.waitingFor ?? ""}`
+        wait: `${entry.statusUpdatedAt ?? ""}|${entry.waitingFor ?? ""}`,
+        ...entry.statusUpdatedAt !== void 0 && { since: entry.statusUpdatedAt }
       };
     }
   };
 }
 
+// src/core/permission-rules/commandWords.ts
+var COMMAND_RUNNERS = [
+  // The shell's own words.
+  ".",
+  "builtin",
+  "command",
+  "coproc",
+  "eval",
+  "exec",
+  "nocorrect",
+  "noglob",
+  "source",
+  "time",
+  // Programs that run the command after their own words.
+  "arch",
+  "bunx",
+  "caffeinate",
+  "chroot",
+  "doas",
+  "env",
+  "flock",
+  "gtimeout",
+  "ionice",
+  "nice",
+  "nix-shell",
+  "nohup",
+  "npx",
+  "parallel",
+  "pnpx",
+  "sandbox-exec",
+  "script",
+  "setsid",
+  "stdbuf",
+  "su",
+  "sudo",
+  "taskset",
+  "timeout",
+  "unbuffer",
+  "uvx",
+  "watch",
+  "xargs",
+  "xcrun",
+  // Shells, which run the command they are given or a file.
+  "ash",
+  "bash",
+  "busybox",
+  "cmd",
+  "csh",
+  "dash",
+  "fish",
+  "ksh",
+  "powershell",
+  "pwsh",
+  "sh",
+  "tcsh",
+  "zsh"
+];
+var NETWORK_CLIENTS_AND_INTERPRETERS = [
+  // Programs that send requests, or open a connection, to an address.
+  "aria2c",
+  "curl",
+  "elinks",
+  "ftp",
+  "grpcurl",
+  "http",
+  "https",
+  "httpx",
+  "links",
+  "lynx",
+  "nc",
+  "ncat",
+  "netcat",
+  "scp",
+  "sftp",
+  "socat",
+  "ssh",
+  "telnet",
+  "w3m",
+  "websocat",
+  "wget",
+  "xh",
+  "xhs",
+  // Interpreters, which run code given in their words or in a file.
+  "awk",
+  "bpython",
+  "bun",
+  "clj",
+  "clojure",
+  "dart",
+  "deno",
+  "elixir",
+  "erl",
+  "escript",
+  "esno",
+  "expect",
+  "gawk",
+  "ghci",
+  "groovy",
+  "guile",
+  "iex",
+  "ipython",
+  "irb",
+  "java",
+  "jshell",
+  "jrunscript",
+  "julia",
+  "kotlin",
+  "lua",
+  "luajit",
+  "mawk",
+  "nawk",
+  "node",
+  "nodejs",
+  "ocaml",
+  "osascript",
+  "perl",
+  "php",
+  "pypy",
+  "python",
+  "r",
+  "racket",
+  "raku",
+  "rakudo",
+  "rscript",
+  "ruby",
+  "runghc",
+  "runhaskell",
+  "sbcl",
+  "scala",
+  "swift",
+  "tclsh",
+  "ts-node",
+  "tsx",
+  "vite-node",
+  "wish",
+  "zx"
+];
+var WINDOWS_PROGRAM_END = /\.(?:exe|com)$/;
+var LETTER = /[a-z]/;
+function programOf(word2) {
+  return word2.slice(word2.lastIndexOf("/") + 1).toLowerCase().replace(WINDOWS_PROGRAM_END, "");
+}
+function nameIn(program, names) {
+  let found;
+  for (const name of names) {
+    if (program === name) return name;
+    const fits = program.startsWith(name) && !LETTER.test(program.charAt(name.length));
+    if (fits && name.length > (found?.length ?? 0)) found = name;
+  }
+  return found;
+}
+function runsAnotherCommand(word2) {
+  return nameIn(programOf(word2), COMMAND_RUNNERS) !== void 0;
+}
+function sendsOrRunsCode(word2) {
+  return nameIn(programOf(word2), NETWORK_CLIENTS_AND_INTERPRETERS) !== void 0;
+}
+var SUBCOMMANDS_THAT_RUN_CODE = {
+  bundle: ["e", "ex", "exe", "exec"],
+  bundler: ["e", "ex", "exe", "exec"],
+  cargo: ["r", "run"],
+  docker: ["build", "buildx", "compose", "container", "create", "exec", "run", "start"],
+  "docker-compose": ["create", "exec", "run", "start", "up"],
+  dotnet: ["exec", "run", "tool"],
+  go: ["generate", "run", "tool"],
+  nix: ["develop", "run", "shell"],
+  npm: ["create", "exec", "explore", "init", "innit", "x"],
+  pipx: ["run"],
+  pnpm: ["create", "dlx", "exec", "x"],
+  podman: ["build", "compose", "container", "create", "exec", "run", "start"],
+  poetry: ["run"],
+  uv: ["run", "tool"],
+  yarn: ["create", "dlx", "exec", "node"],
+  yarnpkg: ["create", "dlx", "exec", "node"]
+};
+var TAKES_A_SHORTENED_SUBCOMMAND = ["npm"];
+function subcommandToolOf(word2) {
+  return nameIn(programOf(word2), Object.keys(SUBCOMMANDS_THAT_RUN_CODE));
+}
+function needsItsSubcommand(words) {
+  const [first, second] = words;
+  if (first === void 0 || subcommandToolOf(first) === void 0) return false;
+  return second === void 0 || second.startsWith("-");
+}
+function runsCodeBySubcommand(words) {
+  const [first, ...rest] = words;
+  if (first === void 0) return false;
+  const tool = subcommandToolOf(first);
+  if (tool === void 0) return false;
+  const listed = SUBCOMMANDS_THAT_RUN_CODE[tool] ?? [];
+  const shortened = TAKES_A_SHORTENED_SUBCOMMAND.includes(tool);
+  let pastOptions = false;
+  for (const word2 of rest) {
+    if (word2 === "--") {
+      if (pastOptions) return false;
+      continue;
+    }
+    if (!word2.startsWith("-")) pastOptions = true;
+    const lower = word2.toLowerCase();
+    if (listed.includes(lower)) return true;
+    if (shortened && lower.length >= 2 && listed.some((name) => name.startsWith(lower)))
+      return true;
+  }
+  return false;
+}
+var OPTIONS_THAT_RUN_A_PROGRAM = {
+  git: ["c", "config-env", "exec-path", "receive-pack", "upload-pack"],
+  go: ["exec", "toolexec", "vettool"],
+  npm: ["call", "node-options", "script-shell"]
+};
+function runsAProgramByOption(words) {
+  const [first, ...rest] = words;
+  if (first === void 0) return false;
+  const program = nameIn(programOf(first), Object.keys(OPTIONS_THAT_RUN_A_PROGRAM));
+  if (program === void 0) return false;
+  const options = OPTIONS_THAT_RUN_A_PROGRAM[program] ?? [];
+  return rest.some((word2) => {
+    if (!word2.startsWith("-")) return false;
+    const [name = ""] = word2.replace(/^-+/, "").split("=");
+    return options.includes(name);
+  });
+}
+var OWN_FOLDER_NAME = ".agent-lookout";
+var BY_NUMBER = "/.vol";
+function plainPath(word2) {
+  const lower = word2.toLowerCase();
+  if (!lower.startsWith("/")) return lower;
+  const parts = [];
+  for (const part of lower.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") parts.pop();
+    else parts.push(part);
+  }
+  return `/${parts.join("/")}`;
+}
+function foldersAbove(file) {
+  const folders = [];
+  let at = file;
+  while (at !== "/" && at !== "") {
+    at = at.slice(0, at.lastIndexOf("/")) || "/";
+    folders.push(at);
+  }
+  return folders;
+}
+function namesOwnFiles(words, ownPaths = [], folder) {
+  const own = ownPaths.filter((name) => name.startsWith("/")).map(plainPath);
+  const above = new Set(own.flatMap(foldersAbove));
+  const ownNames = own.filter((name) => !name.includes(OWN_FOLDER_NAME)).map((name) => name.slice(name.lastIndexOf("/") + 1));
+  const from = folder?.startsWith("/") ? folder : void 0;
+  return words.some((word2) => {
+    const lower = word2.toLowerCase();
+    if (lower.includes(OWN_FOLDER_NAME)) return true;
+    const parts = [lower, ...lower.split("=").slice(1)];
+    const read = parts.flatMap(
+      (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}`));
+    });
+  });
+}
+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}/`));
+}
+var PLAIN_WORD = /^[A-Za-z0-9_\-.,/:=+@%]+$/;
+var ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
+function plainCommandWords(command) {
+  if (command === "") return null;
+  const words = command.split(" ");
+  for (const word2 of words) {
+    if (word2 === "" || !PLAIN_WORD.test(word2)) return null;
+    if (word2.startsWith("=")) return null;
+  }
+  if (ASSIGNMENT.test(words[0])) return null;
+  return words;
+}
+var SEPARATORS = /[;&|\n\r()`{}<>]/;
+var DOLLAR_QUOTE = /\$(?=['"])/g;
+var QUOTING = /['"\\]/g;
+var CLAUSE_WORDS = ["!", "if", "then", "else", "elif", "do", "while", "until"];
+function looseCommandWords(command) {
+  const commands = [];
+  for (const part of command.split(SEPARATORS)) {
+    const words = part.split(/\s+/u).map((word2) => word2.replace(DOLLAR_QUOTE, "").replace(QUOTING, "")).filter((word2) => word2 !== "");
+    let first = 0;
+    for (; ; ) {
+      const word2 = words[first];
+      if (word2 === void 0) break;
+      if (!ASSIGNMENT.test(word2) && !CLAUSE_WORDS.includes(word2)) break;
+      first += 1;
+    }
+    if (first < words.length) commands.push(words.slice(first));
+  }
+  return commands;
+}
+var PREFIX_MARK = ":*";
+function ruleCommandOf(command) {
+  const prefix = command.endsWith(PREFIX_MARK);
+  const words = (prefix ? command.slice(0, -PREFIX_MARK.length) : command).split(" ");
+  return { words, prefix };
+}
+function wordsMatch(rule, words) {
+  if (rule.prefix ? words.length < rule.words.length : words.length !== rule.words.length) {
+    return false;
+  }
+  return rule.words.every((word2, index) => words[index] === word2);
+}
+function inOrder(wanted, words, from, to) {
+  let at = from;
+  for (const word2 of wanted) {
+    while (at < to && words[at] !== word2) at += 1;
+    if (at >= to) return -1;
+    at += 1;
+  }
+  return at;
+}
+function looselyFrom(rule, words, start) {
+  const [program, ...rest] = rule.words;
+  if (program === void 0 || programOf(words[start]) !== programOf(program)) {
+    return false;
+  }
+  if (rule.prefix) return inOrder(rest, words, start + 1, words.length) >= 0;
+  const last = rest.at(-1);
+  if (last === void 0) return words.length === start + 1;
+  const end = words.length - 1;
+  return end > start && words[end] === last && inOrder(rest.slice(0, -1), words, start + 1, end) >= 0;
+}
+function looselyMatches(rule, words) {
+  const first = words[0];
+  if (first === void 0) return false;
+  const starts = runsAnotherCommand(first) ? words.length : 1;
+  for (let start = 0; start < starts; start += 1) {
+    if (looselyFrom(rule, words, start)) return true;
+  }
+  return false;
+}
+
+// src/core/permission-rules/permissionRules.ts
+var RULE_DECISIONS = ["allow", "ask", "deny"];
+var EVERY_TOOL = "*";
+var COMMAND_TOOL = "Bash";
+var MCP_PREFIX = "mcp__";
+var MCP_SEPARATOR = "__";
+function isServerName(tool) {
+  if (!tool.startsWith(MCP_PREFIX)) return false;
+  const server = tool.slice(MCP_PREFIX.length);
+  return server !== "" && !server.includes(MCP_SEPARATOR);
+}
+var MAX_RULES = 100;
+var MAX_RULE_TOOL_CHARS = 128;
+var MAX_RULE_COMMAND_CHARS = 200;
+var TOOL_NAME = /^[A-Za-z][A-Za-z0-9_-]*$/;
+var RULE_ID = /^[A-Za-z0-9-]{1,40}$/;
+var ASCII_WORDS = /^[\x21-\x7e]+(?: [\x21-\x7e]+)*$/;
+var NOT_IN_A_RULE = /[;&|<>()`'"\\{}$*]/;
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function holdsOnly(value, keys, optional = []) {
+  const there = Object.keys(value);
+  return keys.every((key) => there.includes(key)) && there.every((key) => keys.includes(key) || optional.includes(key));
+}
+function toolProblem(tool) {
+  if (tool === EVERY_TOOL) return null;
+  if (tool === "") return "Name a tool, such as Bash or WebFetch, or * for every tool.";
+  if (tool.includes("(")) {
+    return "Write the tool's name alone, such as Bash, and the command in its own field.";
+  }
+  if (tool !== COMMAND_TOOL && tool.toLowerCase() === COMMAND_TOOL.toLowerCase()) {
+    return `Claude Code writes this tool's name ${COMMAND_TOOL}.`;
+  }
+  if (tool.length > MAX_RULE_TOOL_CHARS || !TOOL_NAME.test(tool) || tool === MCP_PREFIX || tool.startsWith(MCP_PREFIX) && tool.endsWith(MCP_SEPARATOR)) {
+    return "A tool's name is written as Claude Code writes it: a letter, then letters, digits, _ and -, such as Bash, WebFetch or mcp__docs__search.";
+  }
+  return null;
+}
+function commandProblem(command, decision) {
+  if (command.length > MAX_RULE_COMMAND_CHARS) {
+    return `A command in a rule is ${MAX_RULE_COMMAND_CHARS} characters at most.`;
+  }
+  if (!ASCII_WORDS.test(command)) {
+    return "Write the command in plain ASCII letters, digits and marks, with one space between words and none at either end.";
+  }
+  const prefix = command.endsWith(PREFIX_MARK);
+  const words = prefix ? command.slice(0, -PREFIX_MARK.length) : command;
+  if (words === "" || words.endsWith(" ")) {
+    return "Write :* straight after the words a command begins with, as in npm test:*.";
+  }
+  if (command.endsWith(" *")) {
+    return "Write a prefix with :* straight after its words, as in npm test:*.";
+  }
+  if (NOT_IN_A_RULE.test(words)) {
+    return "A rule names one command by its words: no ;, &, |, <, >, ( ), quotes, backslashes, $, { }, or * other than the :* that ends a prefix.";
+  }
+  if (decision === "allow" && plainCommandWords(words) === null) {
+    return "An allow rule names one plain command: no ~, !, ^, #, ?, [ ], no word starting with =, and no variable set before it.";
+  }
+  const [program = ""] = words.split(" ");
+  if (ASSIGNMENT.test(program)) {
+    return "Begin the command with the program's name: the variables set before a command are passed over when it is matched.";
+  }
+  if (decision === "allow" && runsAnotherCommand(program)) {
+    return `${program} runs another command, so an allow rule for it would let Claude Code run anything without asking you. Name the command it would run instead.`;
+  }
+  if (decision === "allow" && sendsOrRunsCode(program)) {
+    return `${program} is, or is named like, a program that can send requests or run code that does, so an allow rule for it would let Claude Code reach Agent Lookout on this computer and add a rule or answer its own prompts without asking you. Answer such commands by hand, or allow a script the project owns, such as ./scripts/test.sh, knowing Claude can edit it.`;
+  }
+  if (decision === "allow" && needsItsSubcommand(words.split(" "))) {
+    return `${program} does something different for each subcommand, and some run any code they are pointed at, so an allow rule for it names the subcommand too, such as ${program} test:*.`;
+  }
+  if (decision === "allow" && runsAProgramByOption(words.split(" "))) {
+    return `${words} names an option through which ${program} runs another program, so an allow rule for it would let Claude Code run anything without asking you.`;
+  }
+  if (decision === "allow" && runsCodeBySubcommand(words.split(" "))) {
+    return `${words} fetches or runs code that Claude Code can choose, so an allow rule for it would let it run anything without asking you. Name the script it should run instead, or answer such commands by hand.`;
+  }
+  if (decision === "allow" && namesOwnFiles(words.split(" "))) {
+    return "An allow rule may not name Agent Lookout's own folder, ~/.agent-lookout, which holds its settings and its rules.";
+  }
+  return null;
+}
+function ruleProblem(words) {
+  const { decision, tool, command } = words;
+  const toolWrong = toolProblem(tool);
+  if (toolWrong !== null) return toolWrong;
+  if (command !== void 0) {
+    if (tool !== COMMAND_TOOL)
+      return "A command goes with Bash only. Leave it empty for any other tool.";
+    const commandWrong = commandProblem(command, decision);
+    if (commandWrong !== null) return commandWrong;
+  }
+  if (decision !== "allow") return null;
+  if (tool === EVERY_TOOL) {
+    return "An allow rule names one tool. Allowing every tool would let Claude Code run anything without asking you.";
+  }
+  if (tool === COMMAND_TOOL && command === void 0) {
+    return "An allow rule for Bash names a command. Allowing every command would let Claude Code run anything without asking you.";
+  }
+  if (isServerName(tool)) {
+    return `An allow rule names one tool of a server, such as ${tool}${MCP_SEPARATOR}search. Allowing every tool of ${tool} would let Claude Code use each without asking you.`;
+  }
+  if (EDIT_TOOLS.includes(tool)) {
+    return `Agent Lookout does not show the change ${tool} makes, so it never allows one, by hand or by a rule.`;
+  }
+  if (NOT_YES_OR_NO_TOOLS.includes(tool)) {
+    return `${tool} is answered with more than yes or no, so Agent Lookout never allows it, by hand or by a rule.`;
+  }
+  return null;
+}
+function ruleWordsIn(value) {
+  const shape = 'A rule is {"decision": "allow", "ask" or "deny", "tool": "...", "command": "..."}, with the command for Bash only, and nothing else.';
+  if (!isRecord7(value) || !holdsOnly(value, ["decision", "tool"], ["command"])) {
+    return { ok: false, problem: shape };
+  }
+  const { decision, tool, command } = value;
+  if (!RULE_DECISIONS.includes(decision))
+    return { ok: false, problem: shape };
+  if (typeof tool !== "string" || command !== void 0 && typeof command !== "string") {
+    return { ok: false, problem: shape };
+  }
+  const words = {
+    decision,
+    tool,
+    ...command !== void 0 && { command }
+  };
+  const problem = ruleProblem(words);
+  return problem === null ? { ok: true, words } : { ok: false, problem };
+}
+function isRuleId(value) {
+  return typeof value === "string" && RULE_ID.test(value);
+}
+function readRule2(value) {
+  if (!isRecord7(value)) return null;
+  const { id, ...rest } = value;
+  if (!isRuleId(id)) return null;
+  const read = ruleWordsIn(rest);
+  return read.ok ? { id, ...read.words } : null;
+}
+function readPermissionRules(value) {
+  if (value === void 0) return { ok: true, rules: [] };
+  if (!Array.isArray(value) || value.length > MAX_RULES) return { ok: false };
+  const rules = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    const rule = readRule2(item);
+    if (rule === null || ids.has(rule.id)) return { ok: false };
+    ids.add(rule.id);
+    rules.push(rule);
+  }
+  return { ok: true, rules };
+}
+function sameWords(a, b) {
+  return a.decision === b.decision && a.tool === b.tool && a.command === b.command;
+}
+
+// src/core/permission-rules/ruleDecision.ts
+var INPUTS_AN_ALLOW_RULE_TAKES = ["timeout", "run_in_background"];
+var ORDER = ["deny", "ask", "allow"];
+function toolMatches(rule, request2) {
+  if (rule.tool === EVERY_TOOL || rule.tool === request2.tool) return true;
+  return isServerName(rule.tool) && request2.tool.startsWith(`${rule.tool}${MCP_SEPARATOR}`);
+}
+function holdsBack(rule, request2) {
+  if (!toolMatches(rule, request2)) return false;
+  if (rule.command === void 0) return true;
+  if (request2.tool !== COMMAND_TOOL || request2.command === void 0) return false;
+  const wanted = ruleCommandOf(rule.command);
+  return looseCommandWords(request2.command).some((words) => looselyMatches(wanted, words));
+}
+function lets(rule, request2) {
+  if (!request2.allowable || rule.tool === EVERY_TOOL || isServerName(rule.tool)) return false;
+  if (rule.tool !== request2.tool) return false;
+  if (request2.tool !== COMMAND_TOOL) return rule.command === void 0;
+  if (rule.command === void 0 || request2.command === void 0) return false;
+  if (!request2.inputNames.every((name) => INPUTS_AN_ALLOW_RULE_TAKES.includes(name))) return false;
+  const wanted = ruleCommandOf(rule.command);
+  const [program = ""] = wanted.words;
+  if (runsAnotherCommand(program) || sendsOrRunsCode(program)) return false;
+  if (needsItsSubcommand(wanted.words)) return false;
+  const words = plainCommandWords(request2.command);
+  if (words === null || runsCodeBySubcommand(words) || runsAProgramByOption(words)) return false;
+  const own = request2.ownPaths ?? [];
+  if (request2.folder !== void 0 && folderReachesOwnFiles(request2.folder, own)) return false;
+  if (namesOwnFiles(words, own, request2.folder)) return false;
+  return wordsMatch(wanted, words);
+}
+function decideByRules(rules, request2) {
+  for (const decision of ORDER) {
+    const matches = decision === "allow" ? lets : holdsBack;
+    const rule = rules.find(
+      (candidate) => candidate.decision === decision && matches(candidate, request2)
+    );
+    if (rule !== void 0) return { decision, rule };
+  }
+  return null;
+}
+
+// src/collector/answers/ruleAnswers.ts
+function ruleAnsweredEvent(session, sessionId, tool, verdict, at) {
+  const { rule } = verdict;
+  return {
+    id: `${sessionId}@${at}:answered`,
+    at,
+    sessionId,
+    sessionName: session?.name ?? sessionId,
+    kind: "answered",
+    ...session && { from: session.status },
+    severity: "advisory",
+    by: "agent-lookout",
+    decision: verdict.decision,
+    tool,
+    rule: { tool: rule.tool, ...rule.command !== void 0 && { command: rule.command } }
+  };
+}
+function createRuleAnswers(options) {
+  const { poller, events } = options;
+  const now = options.now ?? Date.now;
+  let recent = [];
+  return {
+    verdictFor({ sessionId, shown }) {
+      const rules = options.rules();
+      if (rules.length === 0) return null;
+      const folder = poller.getSnapshot().sessions.find((listed) => listed.id === sessionId)?.cwd;
+      const verdict = decideByRules(rules, {
+        tool: shown.tool,
+        ...shown.command !== void 0 && { command: shown.command },
+        inputNames: shown.command === void 0 ? [] : (shown.inputs ?? []).map((input) => input.name),
+        // The one rule for what may be allowed: what the dashboard would offer Allow for.
+        allowable: shown.allow,
+        ownPaths: options.ownPaths ?? [],
+        ...folder && { folder }
+      });
+      if (verdict === null || verdict.decision === "ask") return null;
+      return { decision: verdict.decision, rule: verdict.rule };
+    },
+    answered({ sessionId, shown }, verdict) {
+      const at = now();
+      const session = poller.getSnapshot().sessions.find((listed) => listed.id === sessionId) ?? null;
+      const event = ruleAnsweredEvent(session, sessionId, shown.tool, verdict, at);
+      events.add([event]);
+      const { id: _id, ...rule } = verdict.rule;
+      recent = [
+        {
+          at,
+          sessionId,
+          sessionName: event.sessionName,
+          tool: shown.tool,
+          decision: verdict.decision,
+          rule
+        },
+        ...recent
+      ].slice(0, MAX_RULE_ANSWERS);
+      void poller.pollOnce().catch(() => {
+      });
+    },
+    recent: () => [...recent]
+  };
+}
+
 // src/collector/answers/answering.ts
 function createAnswering(options) {
   const { env, poller, events } = options;
@@ -5046,14 +5983,26 @@ function createAnswering(options) {
       },
       serve: (snapshot) => ({ ...snapshot, answering: off }),
       observe: () => {
-      }
+      },
+      answeredIn: () => /* @__PURE__ */ new Set(),
+      ruleAnswers: () => []
     };
   }
+  const ruleAnswers = createRuleAnswers({
+    rules: options.rules ?? (() => []),
+    // A command that names the settings file or the socket could change the
+    // rules or answer prompts, so no rule allows it, wherever they are.
+    ownPaths: [options.settingsFile ?? "", setup.socketPath],
+    poller,
+    events,
+    now: options.now
+  });
   const asks = createHeldAsks({
     status: options.status ?? createRegistryStatus({ snapshot: poller.getSnapshot, env }),
     holdMs: setup.holdMs,
     now: options.now,
-    every: options.every
+    every: options.every,
+    rules: ruleAnswers
   });
   const socket = createHookSocket({
     socketPath: setup.socketPath,
@@ -5062,6 +6011,7 @@ function createAnswering(options) {
   });
   let problem = null;
   let listening = false;
+  const answerRoute = createAnswerRoute({ poller, events, asks, now: options.now });
   return {
     async start() {
       const started = await socket.start();
@@ -5085,7 +6035,16 @@ function createAnswering(options) {
     observe(snapshot) {
       if (listening) asks.observe(snapshot);
     },
-    route: createAnswerRoute({ poller, events, asks, now: options.now })
+    answeredIn: (snapshot) => asks.answeredIn(snapshot),
+    // A socket that could not be opened holds no request, so there is nothing
+    // to answer. Past the route's own checks, a POST is told what it would be
+    // told with answering off, where there is no such route.
+    async route(req) {
+      if (problem === null) return answerRoute(req);
+      req.resume();
+      return answerRefusalFor(req) ?? refusal(405, "This address only answers GET requests.", { Allow: "GET" });
+    },
+    ruleAnswers: () => ruleAnswers.recent()
   };
 }
 
@@ -5221,8 +6180,8 @@ function waitsOf(input) {
       names.set(sessionId, event.sessionName);
     }
     if (began !== null) {
-      const open4 = waitingNow.has(sessionId);
-      waits.push({ sessionId, from: began, to: open4 || began >= thisRun ? now : thisRun, open: open4 });
+      const open2 = waitingNow.has(sessionId);
+      waits.push({ sessionId, from: began, to: open2 || began >= thisRun ? now : thisRun, open: open2 });
       unended.add(sessionId);
     }
   }
@@ -5314,26 +6273,26 @@ function waitTotals(input) {
 
 // src/collector/adapters/codex/index.ts
 import os5 from "node:os";
-import path14 from "node:path";
+import path12 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 open4;
+  let open2;
   if (lastTurn === null) {
-    open4 = "idle";
+    open2 = "idle";
   } else if (typeof lastTurn !== "string") {
     return "unknown";
   } else if (TURN_UNDER_WAY.has(lastTurn)) {
-    open4 = "working";
+    open2 = "working";
   } else if (TURN_OVER.has(lastTurn)) {
-    open4 = "idle";
+    open2 = "idle";
   } else {
     return "unknown";
   }
-  return live2 === false ? "finished" : open4;
+  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})?$/;
@@ -5357,7 +6316,7 @@ var IMPORTED_TURN_ID = /^external-import-turn-\d{1,9}$/;
 function isImportedCodexTurn(turnId) {
   return typeof turnId === "string" && IMPORTED_TURN_ID.test(turnId);
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var CODEX_DESKTOP_ORIGINATOR = "Codex Desktop";
@@ -5365,7 +6324,7 @@ function mapCodexSurface(source, originator) {
   if (originator === CODEX_DESKTOP_ORIGINATOR) return "desktop";
   if (source === "cli" || source === "exec") return "terminal";
   if (source === "vscode") return "vscode";
-  if (isRecord7(source) && source.custom === "chatgpt") return "desktop";
+  if (isRecord8(source) && source.custom === "chatgpt") return "desktop";
   return "unknown";
 }
 var NOT_A_SESSION_SOURCE = /* @__PURE__ */ new Set(["subagent", "internal", "mcp"]);
@@ -5376,7 +6335,7 @@ function isCodexSessionSource(source, meta = {}) {
     return false;
   }
   if (typeof source === "string") return !NOT_A_SESSION_SOURCE.has(source);
-  if (isRecord7(source)) return !Object.keys(source).some((kind) => NOT_A_SESSION_SOURCE.has(kind));
+  if (isRecord8(source)) return !Object.keys(source).some((kind) => NOT_A_SESSION_SOURCE.has(kind));
   return true;
 }
 
@@ -5395,7 +6354,7 @@ function parseCodexTime(value) {
 var LINE_TIME = /^\{"timestamp":"([^"]{1,64})"/;
 var TURN_HINT = /"type":"(?:task|turn)_/;
 var TURN_TYPE = /^(?:task|turn)_/;
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function text3(value) {
@@ -5406,7 +6365,7 @@ function label(value) {
 }
 function compactSource(value) {
   if (typeof value === "string") return text3(value);
-  if (!isRecord8(value)) return void 0;
+  if (!isRecord9(value)) return void 0;
   return Object.fromEntries(
     Object.entries(value).map(([kind, detail]) => [
       kind,
@@ -5417,7 +6376,7 @@ function compactSource(value) {
 function parse(line) {
   try {
     const value = JSON.parse(line);
-    return isRecord8(value) ? value : null;
+    return isRecord9(value) ? value : null;
   } catch {
     return null;
   }
@@ -5425,7 +6384,7 @@ function parse(line) {
 function readMetaLine(line) {
   if (!line.includes('"session_meta"')) return null;
   const value = parse(line);
-  if (!value || value.type !== "session_meta" || !isRecord8(value.payload)) return null;
+  if (!value || value.type !== "session_meta" || !isRecord9(value.payload)) return null;
   const payload = value.payload;
   const meta = {
     id: text3(payload.id),
@@ -5445,7 +6404,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" || !isRecord8(value.payload)) return null;
+  if (!value || value.type !== "event_msg" || !isRecord9(value.payload)) return null;
   const turn = value.payload.type;
   if (typeof turn !== "string" || !TURN_TYPE.test(turn)) return null;
   return {
@@ -5631,7 +6590,7 @@ function createRolloutReader(io) {
 }
 
 // src/collector/adapters/codex/rollouts.ts
-import path13 from "node:path";
+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}";
 var ROLLOUT_FILE_NAME = new RegExp(
   `^rollout-\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2}-\\d{2}-(${UUID})(?:_(${UUID}))?\\.jsonl$`,
@@ -5649,7 +6608,7 @@ function twoDigits(value) {
 function recentDayFolders(sessionsDir, now) {
   const folders = [now, now - 24 * 60 * 60 * 1e3].map((at) => {
     const date = new Date(at);
-    return path13.join(
+    return path11.join(
       sessionsDir,
       String(date.getFullYear()),
       twoDigits(date.getMonth() + 1),
@@ -5678,12 +6637,12 @@ function createRolloutFinder(options) {
     const refs = [];
     for (const name of (await names(dir)).sort()) {
       const threadId = threadIdOfRollout(name);
-      if (threadId !== null) refs.push({ path: path13.join(dir, name), threadId });
+      if (threadId !== null) refs.push({ path: path11.join(dir, name), threadId });
     }
     return refs;
   }
   async function subfolders(dir, pattern) {
-    return (await names(dir)).filter((name) => pattern.test(name)).sort().map((name) => path13.join(dir, name));
+    return (await names(dir)).filter((name) => pattern.test(name)).sort().map((name) => path11.join(dir, name));
   }
   async function buildIndex() {
     const years = await subfolders(sessionsDir, YEAR);
@@ -5727,7 +6686,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 isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseSessionIndex(content) {
@@ -5740,7 +6699,7 @@ function parseSessionIndex(content) {
     } catch {
       continue;
     }
-    if (!isRecord9(value)) continue;
+    if (!isRecord10(value)) continue;
     const { id, thread_name: name } = value;
     if (typeof id !== "string" || id === "" || typeof name !== "string") continue;
     const trimmed = name.trim();
@@ -5780,7 +6739,7 @@ function createSessionIndexReader(file, io) {
         }
         names = await readNames();
       } catch (error) {
-        if (isMissing(error)) {
+        if (isMissing2(error)) {
           seen = null;
           names = /* @__PURE__ */ new Map();
         }
@@ -5844,14 +6803,14 @@ async function readWriterLocks(dir, io) {
   try {
     names = await io.readdir(dir);
   } catch (error) {
-    return { supported: false, missing: isMissing(error) };
+    return { supported: false, missing: isMissing2(error) };
   }
-  const open4 = /* @__PURE__ */ new Set();
+  const open2 = /* @__PURE__ */ new Set();
   for (const name of names) {
     const threadId = threadIdOfLock(name);
-    if (threadId !== null) open4.add(threadId);
+    if (threadId !== null) open2.add(threadId);
   }
-  return { supported: true, open: open4 };
+  return { supported: true, open: open2 };
 }
 
 // src/collector/adapters/codex/index.ts
@@ -5889,7 +6848,7 @@ var CODEX_CAPABILITIES = {
   },
   answer: {
     level: "no",
-    reason: "Codex records no approval waits, so there is nothing to answer from here."
+    reason: "Codex records no approval waits, so there is nothing to answer from here, by hand or by a permission rule."
   }
 };
 function createCodexAdapter(options = {}) {
@@ -5902,10 +6861,10 @@ function createCodexAdapter(options = {}) {
   const ownOverride = env[CODEX_HOME_ENV]?.trim() || void 0;
   const codexOverride = env[CODEX_OWN_HOME_ENV]?.trim() || void 0;
   const homeFrom = ownOverride ? "agent-lookout" : codexOverride ? "codex" : "default";
-  const codexHome = path14.resolve(ownOverride ?? codexOverride ?? path14.join(homeDir, ".codex"));
-  const sessionsDir = path14.join(codexHome, "sessions");
-  const locksDir = path14.join(codexHome, WRITER_LOCK_DIR);
-  const indexFile = path14.join(codexHome, SESSION_INDEX_FILE);
+  const 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 homeName = tildify(codexHome, homeDir);
   const sessionsName = tildify(sessionsDir, homeDir);
   const locksName = tildify(locksDir, homeDir);
@@ -5953,7 +6912,7 @@ function createCodexAdapter(options = {}) {
     try {
       return (await io.stat(codexHome)).kind === "directory";
     } catch (error) {
-      return !isMissing(error);
+      return !isMissing2(error);
     }
   }
   async function poll() {
@@ -5975,7 +6934,7 @@ function createCodexAdapter(options = {}) {
     try {
       await io.readdir(sessionsDir);
     } catch (error) {
-      if (!isMissing(error)) {
+      if (!isMissing2(error)) {
         return result(
           "error",
           `Codex sessions could not be read: the folder ${sessionsName} could not be listed.`,
@@ -6023,7 +6982,7 @@ function createCodexAdapter(options = {}) {
     const chosen = /* @__PURE__ */ new Map();
     const subagentWrites = /* @__PURE__ */ new Map();
     for (const ref of [...candidates.values()].sort((a, b) => a.path < b.path ? -1 : 1)) {
-      const open4 = locked(ref.threadId);
+      const open2 = locked(ref.threadId);
       let info;
       try {
         info = await io.lstat(ref.path);
@@ -6031,7 +6990,7 @@ function createCodexAdapter(options = {}) {
         tracked.delete(ref.path);
         continue;
       }
-      if (info.kind !== "file" || !open4 && info.mtimeMs < cutoff) {
+      if (info.kind !== "file" || !open2 && info.mtimeMs < cutoff) {
         tracked.delete(ref.path);
         continue;
       }
@@ -6054,7 +7013,7 @@ function createCodexAdapter(options = {}) {
       }
       if (state.lastTurnImported) continue;
       const at = lastActivity(state, checkedAt);
-      if (!open4 && (at === null || !isWithinRetention(at, checkedAt))) {
+      if (!open2 && (at === null || !isWithinRetention(at, checkedAt))) {
         tracked.delete(ref.path);
         continue;
       }
@@ -6113,7 +7072,7 @@ function createCodexAdapter(options = {}) {
 
 // src/collector/adapters/status-files/index.ts
 import os6 from "node:os";
-import path15 from "node:path";
+import path13 from "node:path";
 
 // src/core/mapping/statusFileMapping.ts
 var STATUS = /* @__PURE__ */ new Map([
@@ -6248,7 +7207,7 @@ var STATUS_FILE_CAPABILITIES = {
   },
   answer: {
     level: "no",
-    reason: "A status file only says a session waits, and holds nothing to answer it through."
+    reason: "A status file only says a session waits, and holds nothing to answer it through, by hand or by a permission rule."
   }
 };
 function counted(count2, one, many) {
@@ -6262,7 +7221,7 @@ function createStatusFileAdapter(options = {}) {
   const isAlive = options.isAlive ?? isProcessAlive;
   const pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS;
   const override = env[STATUS_DIR_ENV]?.trim() || void 0;
-  const dir = path15.resolve(override ?? path15.join(homeDir, ".agent-lookout", "sessions"));
+  const dir = path13.resolve(override ?? path13.join(homeDir, ".agent-lookout", "sessions"));
   const dirName = tildify(dir, homeDir);
   const decoder2 = new TextDecoder();
   let lastRead = /* @__PURE__ */ new Map();
@@ -6295,26 +7254,26 @@ function createStatusFileAdapter(options = {}) {
     return { health, sessions: [] };
   }
   async function readOne(file) {
-    let open4;
+    let open2;
     try {
-      open4 = await io.openRegular(file);
+      open2 = await io.openRegular(file);
     } catch (error) {
-      if (isMissing(error)) return { kind: "gone" };
+      if (isMissing2(error)) return { kind: "gone" };
       const code = error?.code;
       const notAFile = code === void 0 || code === "ELOOP" || code === "EISDIR";
       return { kind: "refused", why: notAFile ? "is not an ordinary file" : "could not be opened" };
     }
     const tooLarge = { kind: "refused", why: "is over 16 KB" };
     try {
-      if (open4.info.size > MAX_FILE_BYTES) return tooLarge;
-      const bytes2 = await open4.read(0, MAX_FILE_BYTES + 1);
+      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));
-      return parsed ? { kind: "read", file: parsed, mtimeMs: open4.info.mtimeMs } : { kind: "invalid" };
+      return parsed ? { kind: "read", file: parsed, mtimeMs: open2.info.mtimeMs } : { kind: "invalid" };
     } catch {
       return { kind: "refused", why: "could not be read" };
     } finally {
-      await open4.close().catch(() => {
+      await open2.close().catch(() => {
       });
     }
   }
@@ -6322,7 +7281,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(path15.join(dir, name)).catch(() => null);
+        const info = await io.lstat(path13.join(dir, name)).catch(() => null);
         return { name, mtimeMs: info?.mtimeMs ?? -Infinity };
       })
     );
@@ -6342,7 +7301,7 @@ function createStatusFileAdapter(options = {}) {
     try {
       names = await io.readdir(dir);
     } catch (error) {
-      if (!isMissing(error)) {
+      if (!isMissing2(error)) {
         const answer = result(
           "error",
           `Status files could not be read: the folder ${dirName} could not be listed.`,
@@ -6372,7 +7331,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(path15.join(dir, fileName2));
+      const reading = await readOne(path13.join(dir, fileName2));
       let kept;
       if (reading.kind === "read") {
         kept = reading;
@@ -6469,6 +7428,7 @@ function transportOptions(settings, timeoutMs = MAIL_TIMEOUT_MS) {
     secure: security === "tls",
     requireTLS: security === "starttls",
     ignoreTLS: security === "plain",
+    tls: { rejectUnauthorized: true },
     ...auth ? { auth: { user: auth.user, pass: auth.pass } } : {},
     name: GREETING_NAME,
     connectionTimeout: timeoutMs,
@@ -6497,7 +7457,7 @@ function failureReason(error) {
       return "the mail server refused the email";
     case "ECONNECTION":
     case "ESOCKET":
-      if (errno === "ECONNREFUSED" || errno === -61 || errno === -111) {
+      if (errno === "ECONNREFUSED" || errno === -61 || errno === -111 || errno === -4078) {
         return "nothing answered at the mail server's address";
       }
       return "the connection to the mail server failed";
@@ -6598,7 +7558,7 @@ function createEventStore(capacity = EVENT_CAPACITY) {
 
 // src/collector/git/branchFinder.ts
 import os7 from "node:os";
-import path17 from "node:path";
+import path15 from "node:path";
 
 // src/collector/git/gitHead.ts
 var MAX_GIT_FILE_BYTES = 4 * 1024;
@@ -6638,18 +7598,18 @@ function parseCommonDir(content) {
 
 // src/collector/git/repository.ts
 import { createHash as createHash2 } from "node:crypto";
-import path16 from "node:path";
+import path14 from "node:path";
 var REPOSITORY_ID_LENGTH = 16;
 function repositoryId(gitFolder) {
   return createHash2("sha256").update(gitFolder).digest("hex").slice(0, REPOSITORY_ID_LENGTH);
 }
 function sharedName(common) {
-  const base = path16.basename(common);
-  if (base.startsWith(".")) return path16.basename(path16.dirname(common));
+  const base = path14.basename(common);
+  if (base.startsWith(".")) return path14.basename(path14.dirname(common));
   return base.endsWith(".git") ? base.slice(0, -".git".length) : base;
 }
 function repositoryOf({ dir, gitDir, commonDir }) {
-  const name = sessionName(commonDir === null ? path16.basename(dir) : sharedName(commonDir));
+  const name = sessionName(commonDir === null ? path14.basename(dir) : sharedName(commonDir));
   return name === void 0 ? null : { id: repositoryId(commonDir ?? gitDir), name };
 }
 
@@ -6659,32 +7619,32 @@ var MAX_LEVELS = 24;
 var READ_WAIT_MS = 1e3;
 var decoder = new TextDecoder("utf-8", { fatal: true });
 async function readGitFile(io, file, maxBytes = MAX_GIT_FILE_BYTES) {
-  let open4;
+  let open2;
   try {
-    open4 = await io.openRegular(file);
+    open2 = await io.openRegular(file);
   } catch (error) {
-    return isMissing(error) ? void 0 : null;
+    return isMissing2(error) ? void 0 : null;
   }
   try {
-    if (open4.info.size > maxBytes) return null;
-    const bytes2 = await open4.read(0, maxBytes + 1);
+    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);
   } catch {
     return null;
   } finally {
-    await open4.close().catch(() => {
+    await open2.close().catch(() => {
     });
   }
 }
 async function commonDirOf(io, gitDir) {
-  const content = await readGitFile(io, path17.join(gitDir, "commondir"));
+  const content = await readGitFile(io, path15.join(gitDir, "commondir"));
   if (content === void 0) return null;
   const target = content === null ? null : parseCommonDir(content);
-  return target === null ? void 0 : path17.resolve(gitDir, target);
+  return target === null ? void 0 : path15.resolve(gitDir, target);
 }
 async function headIn(dir, kind, io) {
-  const marker = path17.join(dir, ".git");
+  const marker = path15.join(dir, ".git");
   let gitDir;
   if (kind === "directory") {
     gitDir = marker;
@@ -6692,11 +7652,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 = path17.resolve(dir, target);
+    gitDir = path15.resolve(dir, target);
   } else {
     return null;
   }
-  const content = await readGitFile(io, path17.join(gitDir, "HEAD"));
+  const content = await readGitFile(io, path15.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;
@@ -6705,22 +7665,22 @@ async function headIn(dir, kind, io) {
   return { head: { ...head, repository }, gitFolder: commonDir ?? gitDir };
 }
 async function findHead(cwd, { io, homeDir }) {
-  if (!path17.isAbsolute(cwd)) return null;
-  const home = path17.resolve(homeDir);
-  let dir = path17.resolve(cwd);
+  if (!path15.isAbsolute(cwd)) return null;
+  const home = path15.resolve(homeDir);
+  let dir = path15.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 = path17.dirname(dir);
+    const parent = path15.dirname(dir);
     if (dir === home || dir === parent) return null;
     let kind;
     try {
-      kind = (await io.lstat(path17.join(dir, ".git"))).kind;
+      kind = (await io.lstat(path15.join(dir, ".git"))).kind;
     } catch (error) {
-      if (!isMissing(error)) return null;
+      if (!isMissing2(error)) return null;
       dir = parent;
       continue;
     }
@@ -6801,14 +7761,14 @@ var STATUS_STATE = {
   PENDING: "pending",
   EXPECTED: "pending"
 };
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function textOf(value) {
   return typeof value === "string" ? value : "";
 }
 function checkOf(value) {
-  if (!isRecord10(value)) return null;
+  if (!isRecord11(value)) return null;
   const startedAt = Date.parse(textOf(value.startedAt));
   const at = Number.isNaN(startedAt) ? -Infinity : startedAt;
   if (value.__typename === "CheckRun") {
@@ -6857,7 +7817,7 @@ function readGhAnswer(stdout, repository) {
   } catch {
     return null;
   }
-  if (!isRecord10(data)) return null;
+  if (!isRecord11(data)) return null;
   const { number } = data;
   const state = stateOf2(data.state, data.isDraft);
   const title = typeof data.title === "string" ? sessionName(data.title) : void 0;
@@ -6881,8 +7841,9 @@ var GH_LOCATIONS = [
   "/usr/bin/gh"
 ];
 var GH_FIELDS = "number,title,state,isDraft,statusCheckRollup";
-async function findGhBinary(env, isExecutable = isExecutableFile, locations = GH_LOCATIONS) {
-  const candidates = [.../* @__PURE__ */ new Set([...pathCandidates(env, "gh"), ...locations])];
+async function findGhBinary(env, isExecutable, locations = GH_LOCATIONS, platform = process.platform) {
+  isExecutable ??= (candidate) => isExecutableFile(candidate, platform);
+  const candidates = [.../* @__PURE__ */ new Set([...pathCandidates(env, "gh", platform), ...locations])];
   for (const candidate of candidates) {
     if (await isExecutable(candidate)) return candidate;
   }
@@ -6995,7 +7956,7 @@ function createGhAsker(options) {
 }
 
 // src/collector/git/pullRequestTarget.ts
-import path18 from "node:path";
+import path16 from "node:path";
 
 // src/collector/git/gitConfig.ts
 var MAX_CONFIG_BYTES = 64 * 1024;
@@ -7253,7 +8214,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, path18.join(gitFolder, "config"), MAX_CONFIG_BYTES);
+    const text4 = await readGitFile(io, path16.join(gitFolder, "config"), MAX_CONFIG_BYTES);
     if (typeof text4 !== "string") return null;
     const config = parseGitConfig(text4);
     const base = config === null ? null : baseRemoteOf(config);
@@ -7262,7 +8223,7 @@ async function readPullRequestTarget(gitFolder, branch, io = nodeIo2) {
     if (base.name !== null && isSafeRemoteName(base.name)) {
       const head = await readGitFile(
         io,
-        path18.join(gitFolder, "refs", "remotes", base.name, "HEAD")
+        path16.join(gitFolder, "refs", "remotes", base.name, "HEAD")
       );
       if (typeof head === "string") defaultBranch = parseRemoteHead(head, base.name);
     }
@@ -7433,40 +8394,38 @@ function createClearHistoryRoute(options) {
 }
 
 // src/collector/history/historyKeeper.ts
-import path19 from "node:path";
+import path17 from "node:path";
 
 // src/collector/history/historyFiles.ts
 import {
-  closeSync,
-  constants as constants4,
-  fstatSync,
-  lstatSync,
-  openSync,
+  closeSync as closeSync2,
+  constants as constants5,
+  fstatSync as fstatSync2,
+  lstatSync as lstatSync2,
   readSync,
   unlinkSync,
   writeSync
 } from "node:fs";
-import { lstat as lstat3, lutimes, mkdir as mkdir2, open as open3, readdir as readdir3, unlink as unlink2 } from "node:fs/promises";
+import { lstat as lstat4, lutimes, mkdir as mkdir2, readdir as readdir3, unlink as unlink2 } from "node:fs/promises";
 function infoOf2(info) {
   return { kind: info.isFile() ? "file" : "other", size: info.size, mtimeMs: info.mtimeMs };
 }
 var FILE_MODE = 384;
 var FOLDER_MODE = 448;
-var NO_FOLLOW = (constants4.O_NOFOLLOW ?? 0) | (constants4.O_NONBLOCK ?? 0);
-var READ = constants4.O_RDONLY | NO_FOLLOW;
-var APPEND = constants4.O_WRONLY | constants4.O_APPEND | constants4.O_CREAT | NO_FOLLOW;
-var CREATE = constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | NO_FOLLOW;
-function notOrdinary() {
+var READ = constants5.O_RDONLY;
+var APPEND = constants5.O_WRONLY | constants5.O_APPEND | constants5.O_CREAT;
+var CREATE = constants5.O_WRONLY | constants5.O_CREAT | constants5.O_EXCL;
+function notOrdinary2() {
   return new Error("Not an ordinary file.");
 }
-function isMissing2(error) {
+function isMissing3(error) {
   return error?.code === "ENOENT";
 }
 async function readRegular(file, maxBytes) {
-  const handle = await open3(file, READ);
+  const handle = await openWithoutFollowing(file, READ);
   try {
     const info = await handle.stat();
-    if (!info.isFile()) throw notOrdinary();
+    if (!info.isFile()) throw notOrdinary2();
     if (info.size > maxBytes) throw new Error("Too large to be a history file.");
     const buffer = Buffer.alloc(info.size);
     let filled = 0;
@@ -7481,10 +8440,10 @@ async function readRegular(file, maxBytes) {
   }
 }
 function readRegularNow(file, maxBytes) {
-  const fd = openSync(file, READ);
+  const fd = openWithoutFollowingNow(file, READ);
   try {
-    const info = fstatSync(fd);
-    if (!info.isFile()) throw notOrdinary();
+    const info = fstatSync2(fd);
+    if (!info.isFile()) throw notOrdinary2();
     if (info.size > maxBytes) throw new Error("Too large to be a history file.");
     const buffer = Buffer.alloc(info.size);
     let filled = 0;
@@ -7495,22 +8454,22 @@ function readRegularNow(file, maxBytes) {
     }
     return buffer.toString("utf8", 0, filled);
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
 }
 function writeNow(file, flags, text4) {
-  const fd = openSync(file, flags, FILE_MODE);
+  const fd = openWithoutFollowingNow(file, flags, FILE_MODE);
   try {
-    if (!fstatSync(fd).isFile()) throw notOrdinary();
+    if (!fstatSync2(fd).isFile()) throw notOrdinary2();
     writeSync(fd, text4);
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
 }
 async function writeTo(file, flags, text4) {
-  const handle = await open3(file, flags, FILE_MODE);
+  const handle = await openWithoutFollowing(file, flags, FILE_MODE);
   try {
-    if (!(await handle.stat()).isFile()) throw notOrdinary();
+    if (!(await handle.stat()).isFile()) throw notOrdinary2();
     await handle.writeFile(text4, "utf8");
   } finally {
     await handle.close();
@@ -7521,8 +8480,8 @@ var nodeHistoryFs = {
     await mkdir2(dir, { recursive: true, mode: FOLDER_MODE });
   },
   list: (dir) => readdir3(dir),
-  lstat: async (file) => infoOf2(await lstat3(file)),
-  lstatNow: (file) => infoOf2(lstatSync(file)),
+  lstat: async (file) => infoOf2(await lstat4(file)),
+  lstatNow: (file) => infoOf2(lstatSync2(file)),
   readRegular,
   readRegularNow,
   append: (file, text4) => writeTo(file, APPEND, text4),
@@ -7537,14 +8496,14 @@ var nodeHistoryFs = {
     try {
       await unlink2(file);
     } catch (error) {
-      if (!isMissing2(error)) throw error;
+      if (!isMissing3(error)) throw error;
     }
   },
   removeNow(file) {
     try {
       unlinkSync(file);
     } catch (error) {
-      if (!isMissing2(error)) throw error;
+      if (!isMissing3(error)) throw error;
     }
   }
 };
@@ -7735,7 +8694,7 @@ function createHistoryKeeper(options) {
   });
   const lock = createWriterLock({
     fs,
-    file: path19.join(dir, LOCK_FILE),
+    file: path17.join(dir, LOCK_FILE),
     pid: options.pid,
     now,
     isAlive: options.isAlive,
@@ -7761,7 +8720,7 @@ function createHistoryKeeper(options) {
     });
     return next;
   }
-  const full = (name) => path19.join(dir, name);
+  const full = (name) => path17.join(dir, name);
   function hold(record) {
     if (unusable !== null || !running) return;
     const line = encodeRecord(record);
@@ -8223,13 +9182,13 @@ function keptHistoryStore(store, keeper) {
 // src/collector/history/historySettings.ts
 import { createHash as createHash3 } from "node:crypto";
 import os8 from "node:os";
-import path20 from "node:path";
+import path18 from "node:path";
 var HISTORY_ENV = "AGENT_LOOKOUT_HISTORY";
 var HISTORY_DIR_ENV = "AGENT_LOOKOUT_HISTORY_DIR";
 function readHistorySetup(env, homeDir = os8.homedir()) {
   if (env[HISTORY_ENV]?.trim().toLowerCase() === "off") return { on: false };
   const override = env[HISTORY_DIR_ENV]?.trim() || void 0;
-  const dir = path20.resolve(override ?? path20.join(homeDir, ".agent-lookout", "history"));
+  const dir = path18.resolve(override ?? path18.join(homeDir, ".agent-lookout", "history"));
   return {
     on: true,
     dir,
@@ -8240,9 +9199,9 @@ function readHistorySetup(env, homeDir = os8.homedir()) {
 function sourcesFingerprint(env, homeDir = os8.homedir()) {
   const set = (name) => env[name]?.trim() || void 0;
   const folders = [
-    path20.resolve(set(CLAUDE_HOME_ENV) ?? path20.join(homeDir, ".claude")),
-    path20.resolve(set(CODEX_HOME_ENV) ?? set(CODEX_OWN_HOME_ENV) ?? path20.join(homeDir, ".codex")),
-    path20.resolve(set(STATUS_DIR_ENV) ?? path20.join(homeDir, ".agent-lookout", "sessions"))
+    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"))
   ];
   return createHash3("sha256").update(JSON.stringify(folders)).digest("hex").slice(0, 32);
 }
@@ -8315,7 +9274,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) {
@@ -8341,7 +9300,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);
@@ -8351,9 +9310,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 });
         }
       }
@@ -8362,7 +9325,7 @@ function createServerNotifications(options) {
         if (entry.kind === "summary") continue;
         const session = entry.kind === "change" ? entry.change.session : entry.reminder.session;
         const current = listed.get(session.id);
-        if (current?.status !== "needs-you") continue;
+        if (current === void 0 || !needsYou(current)) continue;
         if (entry.kind === "reminder") entry.reminder = { ...entry.reminder, session: current };
         else if (entry.change.event === "needs-you")
           entry.change = { ...entry.change, session: current };
@@ -8532,7 +9495,7 @@ var MAX_REMOTE_SOURCES = 20;
 var MAX_ID_LENGTH = 512;
 var MAX_PATH_LENGTH = 4096;
 var MAX_WORD_LENGTH2 = 200;
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function oneOf2(allowed, value) {
@@ -8546,7 +9509,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 (!isRecord11(value)) return void 0;
+  if (!isRecord12(value)) return void 0;
   let head;
   if (value.commit !== void 0) {
     if (value.branch !== void 0 || typeof value.commit !== "string") return void 0;
@@ -8558,7 +9521,7 @@ function readGit(value, machine) {
     head = { branch };
   }
   const repository = value.repository;
-  if (isRecord11(repository) && typeof repository.id === "string") {
+  if (isRecord12(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}
@@ -8568,7 +9531,7 @@ ${repository.id}`), name };
   return head;
 }
 function readSession(value, machine, sources, now, keepWaitingText) {
-  if (!isRecord11(value)) return null;
+  if (!isRecord12(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;
@@ -8598,6 +9561,7 @@ function readSession(value, machine, sources, now, keepWaitingText) {
     if (detail !== void 0) session.waitingDetail = detail;
     const asking = keepWaitingText ? waitingText(value.waitingText) : void 0;
     if (asking !== void 0) session.waitingText = asking;
+    if (value.answered === true) session.answered = true;
   }
   const lastWriteAt = plausibleTime(value.lastWriteAt, now);
   if (lastWriteAt !== null) session.lastWriteAt = lastWriteAt;
@@ -8607,7 +9571,7 @@ function readSession(value, machine, sources, now, keepWaitingText) {
   return session;
 }
 function readCell(value) {
-  if (!isRecord11(value)) return null;
+  if (!isRecord12(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);
@@ -8615,7 +9579,7 @@ function readCell(value) {
 }
 var ACTS_HERE = ["jump", "stop", "answer"];
 function readCapabilities(value, machine) {
-  if (!isRecord11(value)) return null;
+  if (!isRecord12(value)) return null;
   const read = {};
   for (const capability of CAPABILITIES) {
     if (ACTS_HERE.includes(capability)) continue;
@@ -8631,7 +9595,7 @@ function readCapabilities(value, machine) {
   };
 }
 function readRemoteSnapshot(value, machine, now, options = {}) {
-  if (!isRecord11(value) || !Array.isArray(value.sessions) || !Array.isArray(value.sources)) {
+  if (!isRecord12(value) || !Array.isArray(value.sessions) || !Array.isArray(value.sources)) {
     return null;
   }
   const named = /* @__PURE__ */ new Map();
@@ -8639,7 +9603,7 @@ function readRemoteSnapshot(value, machine, now, options = {}) {
   const agents = [];
   for (const item of value.sources) {
     if (sources.length >= MAX_REMOTE_SOURCES) break;
-    if (!isRecord11(item)) continue;
+    if (!isRecord12(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;
@@ -8664,14 +9628,15 @@ function readRemoteSnapshot(value, machine, now, options = {}) {
 }
 
 // src/collector/remotes/sshProgram.ts
-import path21 from "node:path";
+import path19 from "node:path";
 var SSH_BIN_ENV = "AGENT_LOOKOUT_SSH_BIN";
 var SSH_LOCATIONS = ["/usr/bin/ssh", "/opt/homebrew/bin/ssh", "/usr/local/bin/ssh"];
 var SERVER_ALIVE_SECONDS = 15;
-async function findSsh(env, isExecutable = isExecutableFile) {
+async function findSsh(env, isExecutable, platform = process.platform) {
+  isExecutable ??= (candidate) => isExecutableFile(candidate, platform);
   const named = env[SSH_BIN_ENV]?.trim();
   if (named) {
-    const resolved = path21.resolve(named);
+    const resolved = pathsOf(platform).resolve(named);
     if (await isExecutable(resolved)) return { found: true, path: resolved };
     return {
       found: false,
@@ -8679,13 +9644,13 @@ async function findSsh(env, isExecutable = isExecutableFile) {
       named: true
     };
   }
-  const candidates = [.../* @__PURE__ */ new Set([...pathCandidates(env, "ssh"), ...SSH_LOCATIONS])];
+  const candidates = [.../* @__PURE__ */ new Set([...pathCandidates(env, "ssh", platform), ...SSH_LOCATIONS])];
   for (const candidate of candidates) {
     if (await isExecutable(candidate)) return { found: true, path: candidate };
   }
   return {
     found: false,
-    looked: `The ssh command was not found on PATH or in ${SSH_LOCATIONS.map((at) => path21.dirname(at)).join(", ")}`
+    looked: `The ssh command was not found on PATH or in ${SSH_LOCATIONS.map((at) => path19.dirname(at)).join(", ")}`
   };
 }
 function sshArguments(forward) {
@@ -9268,11 +10233,11 @@ function createRemotes(options) {
 // src/collector/settings/settingsFile.ts
 import { randomBytes as randomBytes3 } from "node:crypto";
 import {
-  closeSync as closeSync2,
-  constants as constants5,
-  fstatSync as fstatSync2,
+  closeSync as closeSync3,
+  constants as constants6,
+  fstatSync as fstatSync3,
   fsyncSync,
-  lstatSync as lstatSync2,
+  lstatSync as lstatSync3,
   mkdirSync,
   openSync as openSync2,
   readSync as readSync2,
@@ -9281,23 +10246,22 @@ import {
   writeSync as writeSync2
 } from "node:fs";
 import os9 from "node:os";
-import path22 from "node:path";
+import path20 from "node:path";
 var SETTINGS_FILE_ENV = "AGENT_LOOKOUT_SETTINGS_FILE";
 var SETTINGS_FILE_MODE = 384;
 var SETTINGS_FOLDER_MODE = 448;
 var MAX_SETTINGS_BYTES = 64 * 1024;
 function readSettingsSetup(env, homeDir = os9.homedir()) {
   const named = env[SETTINGS_FILE_ENV]?.trim() || void 0;
-  const file = path22.resolve(named ?? path22.join(homeDir, ".agent-lookout", "settings.json"));
+  const file = path20.resolve(named ?? path20.join(homeDir, ".agent-lookout", "settings.json"));
   return { file, shown: tildify(file, homeDir) };
 }
-var NO_FOLLOW2 = (constants5.O_NOFOLLOW ?? 0) | (constants5.O_NONBLOCK ?? 0);
 function codeOf(error) {
   return error?.code;
 }
 function kindAt(target) {
   try {
-    const info = lstatSync2(target);
+    const info = lstatSync3(target);
     if (info.isSymbolicLink()) return "link";
     if (info.isFile()) return "file";
     return info.isDirectory() ? "folder" : "other";
@@ -9309,54 +10273,69 @@ function kindAt(target) {
 function syncFolder(folder) {
   let fd = null;
   try {
-    fd = openSync2(folder, constants5.O_RDONLY);
+    fd = openSync2(folder, constants6.O_RDONLY);
     fsyncSync(fd);
   } catch {
   } finally {
-    if (fd !== null) closeSync2(fd);
+    if (fd !== null) closeSync3(fd);
+  }
+}
+var linkRefused = (shown) => ({
+  kind: "refused",
+  problem: `${shown} is a link, which Agent Lookout does not follow, so the time rules and the permission rules are off.`
+});
+var notOrdinary3 = (shown) => ({
+  kind: "refused",
+  problem: `${shown} is not an ordinary file, so the time rules and the permission rules are off.`
+});
+function readSettingsStamp(setup) {
+  try {
+    const info = lstatSync3(setup.file, { bigint: true });
+    return `${info.ino}:${info.size}:${info.mtimeNs}:${info.ctimeNs}`;
+  } catch {
+    return null;
   }
 }
 function readSettingsText(setup) {
   const { file, shown } = setup;
-  const folder = path22.dirname(file);
+  const folder = path20.dirname(file);
   try {
     const folderKind = kindAt(folder);
     if (folderKind === null) return { kind: "missing" };
     if (folderKind !== "folder") {
       return {
         kind: "refused",
-        problem: `The folder of ${shown} is a link or not a folder, which Agent Lookout does not follow, so the time rules are off.`
+        problem: `The folder of ${shown} is a link or not a folder, which Agent Lookout does not follow, so the time rules and the permission rules are off.`
       };
     }
+    const fileKind = kindAt(file);
+    if (fileKind === "link") return linkRefused(shown);
+    if (fileKind === "folder" || fileKind === "other") return notOrdinary3(shown);
   } catch {
-    return { kind: "refused", problem: `${shown} could not be read, so the time rules are off.` };
+    return {
+      kind: "refused",
+      problem: `${shown} could not be read, so the time rules and the permission rules are off.`
+    };
   }
   let fd;
   try {
-    fd = openSync2(file, constants5.O_RDONLY | NO_FOLLOW2);
+    fd = openWithoutFollowingNow(file, constants6.O_RDONLY);
   } catch (error) {
     const code = codeOf(error);
     if (code === "ENOENT") return { kind: "missing" };
-    if (code === "ELOOP") {
-      return {
-        kind: "refused",
-        problem: `${shown} is a link, which Agent Lookout does not follow, so the time rules are off.`
-      };
-    }
-    return { kind: "refused", problem: `${shown} could not be read, so the time rules are off.` };
+    if (code === "ELOOP") return linkRefused(shown);
+    return {
+      kind: "refused",
+      problem: `${shown} could not be read, so the time rules and the permission rules are off.`
+    };
   }
   try {
-    const info = fstatSync2(fd);
-    if (!info.isFile()) {
-      return {
-        kind: "refused",
-        problem: `${shown} is not an ordinary file, so the time rules are off.`
-      };
-    }
+    const info = fstatSync3(fd);
+    if (!info.isFile()) return notOrdinary3(shown);
     if (info.size > MAX_SETTINGS_BYTES) {
       return {
         kind: "refused",
-        problem: `${shown} is larger than 64 KB, so it was not read and the time rules are off.`
+        problem: `${shown} is larger than 64 KB, so it was not read and the time rules and the permission rules are off.`
       };
     }
     const buffer = Buffer.alloc(info.size);
@@ -9368,14 +10347,17 @@ function readSettingsText(setup) {
     }
     return { kind: "read", text: buffer.toString("utf8", 0, filled) };
   } catch {
-    return { kind: "refused", problem: `${shown} could not be read, so the time rules are off.` };
+    return {
+      kind: "refused",
+      problem: `${shown} could not be read, so the time rules and the permission rules are off.`
+    };
   } finally {
-    closeSync2(fd);
+    closeSync3(fd);
   }
 }
 function writeSettingsText(setup, text4) {
   const { file, shown } = setup;
-  const folder = path22.dirname(file);
+  const folder = path20.dirname(file);
   const notSaved = {
     ok: false,
     problem: `${shown} could not be written, so the change was not saved.`
@@ -9396,20 +10378,20 @@ 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 = path22.join(
+    temporary = path20.join(
       folder,
-      `.${path22.basename(file)}.${process.pid}.${randomBytes3(6).toString("hex")}.tmp`
+      `.${path20.basename(file)}.${process.pid}.${randomBytes3(6).toString("hex")}.tmp`
     );
-    const fd = openSync2(
+    const fd = openWithoutFollowingNow(
       temporary,
-      constants5.O_WRONLY | constants5.O_CREAT | constants5.O_EXCL | NO_FOLLOW2,
+      constants6.O_WRONLY | constants6.O_CREAT | constants6.O_EXCL,
       SETTINGS_FILE_MODE
     );
     try {
       writeSync2(fd, text4);
       fsyncSync(fd);
     } finally {
-      closeSync2(fd);
+      closeSync3(fd);
     }
     renameSync(temporary, file);
     temporary = null;
@@ -9430,14 +10412,15 @@ function writeSettingsText(setup, text4) {
 // src/collector/settings/collectorSettings.ts
 var fileSettingsStore = {
   read: readSettingsText,
-  write: writeSettingsText
+  write: writeSettingsText,
+  stamp: readSettingsStamp
 };
 var RULE_WORDS = {
   longWait: "the long wait reminder",
   idle: "the idle rule",
   quietHours: "the quiet hours"
 };
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function listOf(names) {
@@ -9446,11 +10429,28 @@ function listOf(names) {
 }
 function rulesIn(read, shown) {
   const off = readTimeRules(void 0).rules;
+  const none = { permissionRules: [], heldRules: void 0 };
   if (read.kind === "missing") {
-    return { rules: off, rest: {}, otherRules: {}, problem: null, writable: true };
+    return {
+      rules: off,
+      ...none,
+      rest: {},
+      otherRules: {},
+      problem: null,
+      rulesProblem: null,
+      writable: true
+    };
   }
   if (read.kind === "refused") {
-    return { rules: off, rest: {}, otherRules: {}, problem: read.problem, writable: false };
+    return {
+      rules: off,
+      ...none,
+      rest: {},
+      otherRules: {},
+      problem: read.problem,
+      rulesProblem: read.problem,
+      writable: false
+    };
   }
   let value;
   try {
@@ -9458,60 +10458,252 @@ function rulesIn(read, shown) {
   } catch {
     value = null;
   }
-  if (!isRecord12(value)) {
+  if (!isRecord13(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,
+      ...none,
       rest: {},
       otherRules: {},
-      problem: `${shown} is not JSON that Agent Lookout can read, so the time rules are off. Changing one in Settings writes the file again.`,
+      problem: notJson,
+      rulesProblem: notJson,
       writable: true
     };
   }
-  const { timeRules, ...rest } = value;
+  const { timeRules, permissionRules: heldRules, ...rest } = value;
+  const permissions = readPermissionRules(heldRules);
   const { rules, unread } = readTimeRules(timeRules);
-  const otherRules = isRecord12(timeRules) ? Object.fromEntries(
+  const otherRules = isRecord13(timeRules) ? Object.fromEntries(
     Object.entries(timeRules).filter(
       ([name]) => !TIME_RULE_NAMES.includes(name)
     )
   ) : {};
   const problem = unread.length === 0 ? null : `${shown} holds ${listOf(unread)} in a form Agent Lookout cannot read, so ${unread.length === 1 ? "it is" : "they are"} off.`;
-  return { rules, rest, otherRules, problem, writable: true };
+  return {
+    rules,
+    permissionRules: permissions.ok ? permissions.rules : null,
+    heldRules,
+    rest,
+    otherRules,
+    problem,
+    rulesProblem: permissions.ok ? null : unreadRulesLine(shown),
+    writable: true
+  };
+}
+function unreadRulesLine(shown) {
+  return `${shown} holds permission rules Agent Lookout cannot read, or a rule it refuses, so no rule is used. Changing a rule in Settings writes the list again with only the rules shown there.`;
 }
 function createCollectorSettings(options) {
   const { setup } = options;
   const store = options.store ?? fileSettingsStore;
-  const first = rulesIn(store.read(setup), setup.shown);
-  let rules = first.rules;
-  const { rest, otherRules } = first;
-  let problem = first.problem;
+  let stamp = store.stamp(setup);
+  let held = rulesIn(store.read(setup), setup.shown);
+  const first = held;
+  let rules = held.rules;
+  let problem = held.problem;
+  let permissionRules = held.permissionRules ?? [];
+  let keepHeld = held.permissionRules === null;
+  let rulesProblem = held.rulesProblem;
+  function read() {
+    stamp = store.stamp(setup);
+    held = rulesIn(store.read(setup), setup.shown);
+    rules = held.rules;
+    problem = held.problem;
+    permissionRules = held.permissionRules ?? [];
+    keepHeld = held.permissionRules === null;
+    rulesProblem = held.rulesProblem;
+  }
+  const notWritable = () => ({
+    ok: false,
+    problem: `${setup.shown} could not be read, so it is not written over and the change was not saved. Mend or remove the file, then make the change again.`
+  });
+  function textWith(time, permissions, keep) {
+    const listed = keep ? { permissionRules: held.heldRules } : permissions.length > 0 || held.heldRules !== void 0 ? { permissionRules: permissions } : {};
+    const whole = { ...held.rest, timeRules: { ...held.otherRules, ...time }, ...listed };
+    return `${JSON.stringify(whole, null, 2)}
+`;
+  }
   return {
     timeRules: () => rules,
-    status: () => ({ timeRules: rules, file: setup.shown, problem }),
+    permissionRules: () => permissionRules,
+    status: () => ({
+      timeRules: rules,
+      file: setup.shown,
+      problem,
+      permissionRules: [...permissionRules],
+      permissionRulesProblem: rulesProblem
+    }),
+    readAgain() {
+      if (store.stamp(setup) !== stamp) read();
+    },
     changeTimeRules(next) {
-      if (!first.writable) {
-        return {
-          ok: false,
-          problem: `${setup.shown} could not be read when Agent Lookout started, so it is not written over and the change was not saved. Mend or remove the file, then start Agent Lookout again.`
-        };
-      }
-      const text4 = `${JSON.stringify({ ...rest, timeRules: { ...otherRules, ...next } }, null, 2)}
-`;
-      const written = store.write(setup, text4);
+      read();
+      if (!held.writable) return notWritable();
+      const written = store.write(setup, textWith(next, permissionRules, keepHeld));
       if (!written.ok) {
         problem = written.problem;
         return written;
       }
       rules = next;
       problem = null;
+      if (!keepHeld) rulesProblem = null;
       return written;
     },
-    problemAtStart: first.problem
+    changePermissionRules(change) {
+      read();
+      if (!held.writable) return { reason: "not-saved", ...notWritable() };
+      const made = change(permissionRules);
+      if (!made.ok || !made.changed) return made;
+      const written = store.write(setup, textWith(rules, made.rules, false));
+      if (!written.ok) {
+        rulesProblem = written.problem;
+        return { ok: false, reason: "not-saved", problem: written.problem };
+      }
+      permissionRules = [...made.rules];
+      keepHeld = false;
+      rulesProblem = null;
+      problem = null;
+      return made;
+    },
+    problemAtStart: first.problem,
+    rulesProblemAtStart: first.rulesProblem === first.problem ? null : first.rulesProblem
+  };
+}
+
+// src/collector/settings/permissionRulesRoute.ts
+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) {
+  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;
+  const [kind] = Object.keys(value);
+  const body = value[kind];
+  if (!isRecord14(body)) return refused;
+  switch (kind) {
+    case "add": {
+      const read = ruleWordsIn(body);
+      return read.ok ? { ok: true, change: { kind, words: read.words } } : read;
+    }
+    case "edit": {
+      const { id, ...words } = body;
+      if (!isRuleId(id)) return refused;
+      const read = ruleWordsIn(words);
+      return read.ok ? { ok: true, change: { kind, id, words: read.words } } : read;
+    }
+    case "move": {
+      const { id, to } = body;
+      if (Object.keys(body).length !== 2 || !isRuleId(id)) return refused;
+      if (to !== "up" && to !== "down") return refused;
+      return { ok: true, change: { kind, id, to } };
+    }
+    case "remove": {
+      const { id } = body;
+      if (Object.keys(body).length !== 1 || !isRuleId(id)) return refused;
+      return { ok: true, change: { kind, id } };
+    }
+    default:
+      return refused;
+  }
+}
+var NO_RULE = {
+  ok: false,
+  reason: "no-rule",
+  problem: "The list holds no such rule. It may have been changed in another tab."
+};
+var DUPLICATE = {
+  ok: false,
+  reason: "duplicate",
+  problem: "The list holds that rule already."
+};
+function applyRulesChange(rules, change, newId) {
+  if (change.kind === "add") {
+    if (rules.length >= MAX_RULES) {
+      return {
+        ok: false,
+        reason: "full",
+        problem: `The list holds ${MAX_RULES} rules, the most it can. Remove one to add another.`
+      };
+    }
+    if (rules.some((rule2) => sameWords(rule2, change.words))) return DUPLICATE;
+    let id = newId();
+    while (rules.some((rule2) => rule2.id === id)) id = newId();
+    return { ok: true, rules: [...rules, { id, ...change.words }], changed: true };
+  }
+  const at = rules.findIndex((rule2) => rule2.id === change.id);
+  if (at < 0) return NO_RULE;
+  const rule = rules[at];
+  if (change.kind === "remove") {
+    return { ok: true, rules: rules.filter((_, index) => index !== at), changed: true };
+  }
+  if (change.kind === "edit") {
+    if (sameWords(rule, change.words)) return { ok: true, rules: [...rules], changed: false };
+    if (rules.some((other) => other.id !== rule.id && sameWords(other, change.words))) {
+      return DUPLICATE;
+    }
+    const next2 = [...rules];
+    next2[at] = { id: rule.id, ...change.words };
+    return { ok: true, rules: next2, changed: true };
+  }
+  const to = change.to === "up" ? at - 1 : at + 1;
+  if (to < 0 || to >= rules.length) return { ok: true, rules: [...rules], changed: false };
+  const next = [...rules];
+  next[at] = next[to];
+  next[to] = rule;
+  return { ok: true, rules: next, changed: true };
+}
+
+// src/collector/settings/permissionRulesRoute.ts
+var MAX_PERMISSION_RULES_BODY_BYTES = 1024;
+var failed3 = (status, reason, error) => ({
+  status,
+  body: { error, reason }
+});
+var STATUS_OF = { "no-rule": 404, full: 409, duplicate: 409, "not-saved": 500 };
+function permissionRulesRefusalFor(req) {
+  return actionRefusalFor(req, PERMISSION_RULES_ACTION, MAX_PERMISSION_RULES_BODY_BYTES);
+}
+var newRuleId = () => randomBytes4(6).toString("hex");
+function createPermissionRulesRoute(options) {
+  const { settings } = options;
+  const newId = options.newId ?? newRuleId;
+  return async function answerPermissionRules(req) {
+    const refused = permissionRulesRefusalFor(req);
+    if (refused) {
+      req.resume();
+      return refused;
+    }
+    const body = await readRequestBody(req, MAX_PERMISSION_RULES_BODY_BYTES);
+    if (!body.ok) {
+      req.resume();
+      return body.tooLarge ? refusal(413, `The body must be no more than ${MAX_PERMISSION_RULES_BODY_BYTES} bytes.`) : refusal(400, "The body could not be read.");
+    }
+    let value;
+    try {
+      value = JSON.parse(body.text);
+    } catch {
+      return failed3(400, "invalid", "The body must be JSON: one change to the permission rules.");
+    }
+    const asked = rulesChangeIn(value);
+    if (!asked.ok) return failed3(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);
+    return {
+      status: 200,
+      body: { ok: true, permissionRules: made.rules }
+    };
   };
 }
 
 // src/collector/settings/timeRulesRoute.ts
 var MAX_TIME_RULES_BODY_BYTES = 2048;
-var failed3 = (status, reason, error) => ({
+var failed4 = (status, reason, error) => ({
   status,
   body: { error, reason }
 });
@@ -9535,12 +10727,12 @@ function createTimeRulesRoute(options) {
     try {
       value = JSON.parse(body.text);
     } catch {
-      return failed3(400, "invalid", "The body must be JSON: the three time rules.");
+      return failed4(400, "invalid", "The body must be JSON: the three time rules.");
     }
     const asked = timeRulesIn(value);
-    if (!asked.ok) return failed3(400, "invalid", asked.problem);
+    if (!asked.ok) return failed4(400, "invalid", asked.problem);
     const saved = settings.changeTimeRules(asked.rules);
-    if (!saved.ok) return failed3(500, "not-saved", saved.problem);
+    if (!saved.ok) return failed4(500, "not-saved", saved.problem);
     return {
       status: 200,
       body: { ok: true, timeRules: asked.rules }
@@ -9692,8 +10884,9 @@ var TMUX_LOCATIONS = [
   "/opt/local/bin/tmux",
   "/usr/bin/tmux"
 ];
-async function findTmuxBinary(env, isExecutable = isExecutableFile) {
-  const candidates = [.../* @__PURE__ */ new Set([...pathCandidates(env, "tmux"), ...TMUX_LOCATIONS])];
+async function findTmuxBinary(env, isExecutable, platform = process.platform) {
+  isExecutable ??= (candidate) => isExecutableFile(candidate, platform);
+  const candidates = [.../* @__PURE__ */ new Set([...pathCandidates(env, "tmux", platform), ...TMUX_LOCATIONS])];
   for (const candidate of candidates) {
     if (await isExecutable(candidate)) return candidate;
   }
@@ -9727,9 +10920,10 @@ function runTmuxBinary(binary, args, options) {
 function createTmuxRunner(options) {
   const { env } = options;
   const off = env[TMUX_ENV]?.trim().toLowerCase() === "off";
+  const platform = options.platform ?? process.platform;
   return async (args) => {
-    if (off || process.platform === "win32") return NOT_RUN3;
-    const binary = await findTmuxBinary(env, options.isExecutable);
+    if (off || platform === "win32") return NOT_RUN3;
+    const binary = await findTmuxBinary(env, options.isExecutable, platform);
     if (binary === null) return NOT_RUN3;
     return runTmuxBinary(binary, args, { env, timeoutMs: options.timeoutMs });
   };
@@ -9782,7 +10976,8 @@ function createWaitLedger() {
         events,
         measured: spans,
         runStarts,
-        waitingNow: snapshot.sessions.filter((session) => session.status === "needs-you").map((session) => ({ id: session.id, name: session.name })),
+        // Not a session in a wait Agent Lookout answered, whatever its source still says.
+        waitingNow: snapshot.sessions.filter(needsYou).map((session) => ({ id: session.id, name: session.name })),
         names: new Map(snapshot.sessions.map((session) => [session.id, session.name])),
         since: since.at,
         now
@@ -9973,11 +11168,13 @@ function createCollector(options) {
   const env = options.env ?? process.env;
   const intervalMs = options.intervalMs ?? POLL_INTERVAL_MS;
   const warn = options.warn ?? console.error;
+  const settingsSetup = readSettingsSetup(env);
   const settings = createCollectorSettings({
-    setup: readSettingsSetup(env),
+    setup: settingsSetup,
     store: options.settingsStore
   });
   if (settings.problemAtStart !== null) warn(settings.problemAtStart);
+  if (settings.rulesProblemAtStart !== null) warn(settings.rulesProblemAtStart);
   const memoryEvents = createEventStore();
   const memoryHistory = createHistoryStore();
   const historySetup = readHistorySetup(env);
@@ -10008,9 +11205,9 @@ function createCollector(options) {
   });
   const tabs = createTabFinder({ env, readProcesses: options.readProcesses, now });
   const osascript = options.osascript ?? createOsascriptRunner({ env });
-  const stopsOn = !stopOff(env);
-  const stopTargets = stopsOn ? createStopTargets() : void 0;
   const platform = options.platform ?? process.platform;
+  const stopsOn = !stopOff(env) && platform !== "win32";
+  const stopTargets = stopsOn ? createStopTargets() : void 0;
   const notifications = createServerNotifications({
     notifier: options.notifier ?? createSystemNotifier({ platform }),
     onAtStart: notificationsOnAtStart(env),
@@ -10071,7 +11268,8 @@ function createCollector(options) {
       panes,
       terminals: tabs,
       readProcessStarts: options.readProcessStarts,
-      stops: stopTargets
+      stops: stopTargets,
+      platform
     }),
     createCodexAdapter({ env: options.env, now, pollIntervalMs: intervalMs }),
     createStatusFileAdapter({ env: options.env, now, pollIntervalMs: intervalMs })
@@ -10087,7 +11285,17 @@ function createCollector(options) {
     // Every source's sessions alike are given the branch of their folder, and
     // with pull requests on, the branch's pull request, as last learnt.
     // Every snapshot carries the time rules in force, and is stale by them.
-    timeRules: () => settings.timeRules(),
+    // The settings file is looked at again here, once a poll, so a change
+    // another copy of Agent Lookout saved is in force by the next one.
+    timeRules: () => {
+      settings.readAgain();
+      return settings.timeRules();
+    },
+    // And marks each session still in a wait whose permission request was
+    // answered, so every channel, the page's too, takes that wait as over at
+    // the same poll, and the Events log and the waits never count a wait a
+    // rule answered before a poll saw it.
+    answered: (snapshot) => answering?.answeredIn(snapshot) ?? /* @__PURE__ */ new Set(),
     annotate: async (sessions) => {
       const onBranches = await branches.annotate(sessions);
       return pullRequests ? pullRequests.annotate(onBranches) : onBranches;
@@ -10103,7 +11311,18 @@ function createCollector(options) {
     }
   });
   const answers2 = options.adapters === void 0 || options.answering !== void 0;
-  const answering = answers2 ? createAnswering({ env, poller, events, now, warn, ...options.answering }) : null;
+  const answering = answers2 ? createAnswering({
+    env,
+    poller,
+    events,
+    now,
+    warn,
+    platform,
+    // Read for each request, so a change in Settings holds for the next one.
+    rules: () => settings.permissionRules(),
+    settingsFile: settingsSetup.file,
+    ...options.answering
+  }) : null;
   const stopper = createStopper({
     env,
     now,
@@ -10133,8 +11352,13 @@ function createCollector(options) {
     jump: createJumpRoute({ poller, panes, run: tmux, tabs, osascript, now }),
     stop: stopRoutes && createStopRoute(stopRoutes),
     cleanUp: stopRoutes && createCleanUpRoute(stopRoutes),
-    settings: () => settings.status(),
+    settings: () => ({
+      ...settings.status(),
+      ruleAnswers: answering?.ruleAnswers() ?? [],
+      ruleAnswersSince: poller.startedAt
+    }),
     timeRules: createTimeRulesRoute({ settings }),
+    permissionRules: createPermissionRulesRoute({ settings }),
     clearHistory: createClearHistoryRoute({
       keeper,
       forget: () => {
@@ -10248,7 +11472,7 @@ async function runStandalone(options) {
   } catch (error) {
     return stopWith(error.message);
   }
-  if (!existsSync(path23.join(distDir, "index.html"))) {
+  if (!existsSync(path21.join(distDir, "index.html"))) {
     return stopWith(
       "The dashboard has not been built yet. Run `npm run build`, then start it again."
     );
@@ -10291,12 +11515,24 @@ async function runStandalone(options) {
 
 // src/cli/start/openBrowser.ts
 import { spawn as spawn3 } from "node:child_process";
+import path22 from "node:path";
 var OPEN_WAIT_MS = 1e4;
-function openCommand(platform, url) {
+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;
+}
+function openCommand(platform, url, env = process.env) {
   const address = loopbackAddress(url);
   if (address === null) return null;
   if (platform === "darwin") return { file: "/usr/bin/open", args: [address] };
   if (platform === "linux") return { file: "xdg-open", args: [address] };
+  if (platform === "win32") {
+    return {
+      file: path22.win32.join(windowsFolder(env), "System32", "rundll32.exe"),
+      args: ["url.dll,FileProtocolHandler", address]
+    };
+  }
   return null;
 }
 function runProgram2(file, args, waitMs = OPEN_WAIT_MS) {
@@ -10307,7 +11543,7 @@ function runProgram2(file, args, waitMs = OPEN_WAIT_MS) {
       resolve(opened);
     };
     try {
-      const child = spawn3(file, [...args], { stdio: "ignore", detached: true });
+      const child = spawn3(file, [...args], { stdio: "ignore", detached: true, windowsHide: true });
       child.once("error", () => settle(false));
       child.once("exit", (code) => settle(code === 0));
       child.unref();
@@ -10318,7 +11554,7 @@ function runProgram2(file, args, waitMs = OPEN_WAIT_MS) {
   });
 }
 async function openInBrowser(url, options = {}) {
-  const command = openCommand(options.platform ?? process.platform, url);
+  const command = openCommand(options.platform ?? process.platform, url, options.env);
   if (command === null) return false;
   return (options.run ?? runProgram2)(command.file, command.args);
 }