portable-agent-layer 0.72.0 → 0.74.0

package/src/tools/control-room/matrix.ts

@@ -12,7 +12,11 @@
  */
 
 import {
-  PROJECT_STALE_DAYS_DEFAULT,
+  type GoalProgress,
+  progressFor,
+  readGoalLinks,
+} from "../../hooks/lib/goal-links";
+import {
   type ProjectProgress,
   readAllProjects,
   type ServesAuthority,
@@ -21,9 +25,11 @@ import {
 import { isImportant, SERVES_MEANING } from "../../hooks/lib/serves";
 import { dueFrom, readTelosGoals, type TelosGoal } from "../../hooks/lib/telos-goals";
 import type { HandoffEntry } from "../lib/handoff-note";
+import { parseIscs } from "../lib/project-isc";
 import { freshHandoffs } from "./data";
+import { type ControlRoomPrefs, readPrefs } from "./prefs";
+import { readSnoozes, snoozedUntil } from "./snooze";
 
-const URGENT_WITHIN_DAYS = 14;
 const RANKED_STATUSES = new Set(["active", "paused"]);
 
 export interface MatrixItem {
@@ -33,12 +39,16 @@ export interface MatrixItem {
   detail: string;
   urgent: boolean;
   important: boolean;
+  /** The quadrant the user pinned this to, which overrules both guesses. */
+  placed: string | null;
   urgentBecause: string[];
   importantBecause: string;
   serves: ServesKind | null;
   servesBy: ServesAuthority | null;
   due: string | null;
   waitingOn: string | null;
+  /** Counted from the criteria of the projects serving it, or null when none does. */
+  progress: { projects: string[]; closed: number; written: number } | null;
 }
 
 export interface Matrix {
@@ -50,11 +60,11 @@ export interface Matrix {
   unranked: number;
 }
 
-function dueSoon(due: string | null, now: Date): boolean {
+function dueSoon(due: string | null, now: Date, withinDays: number): boolean {
   if (!due) return false;
   const at = new Date(`${due}T23:59:59Z`).getTime();
   if (!Number.isFinite(at)) return false;
-  return at - now.getTime() <= URGENT_WITHIN_DAYS * 86_400_000;
+  return at - now.getTime() <= withinDays * 86_400_000;
 }
 
 function earliestDue(lines: string[]): string | null {
@@ -67,10 +77,10 @@ function plural(count: number, noun: string): string {
 }
 
 /** Measured against the grid's own clock, so a placement can be pinned in a test. */
-function quietSince(updated: string | undefined, now: Date): boolean {
+function quietSince(updated: string | undefined, now: Date, afterDays: number): boolean {
   if (!updated) return false;
   const age = now.getTime() - new Date(updated).getTime();
-  return Number.isFinite(age) && age > PROJECT_STALE_DAYS_DEFAULT * 86_400_000;
+  return Number.isFinite(age) && age > afterDays * 86_400_000;
 }
 
 /**
@@ -83,15 +93,20 @@ function projectUrgency(
   waiting: string | null,
   due: string | null,
   hasHandoff: boolean,
-  now: Date
+  now: Date,
+  prefs: ControlRoomPrefs
 ): string[] {
   const reasons: string[] = [];
   const blockers = p.blockers?.length ?? 0;
   if (blockers > 0) reasons.push(plural(blockers, "blocker"));
   if (waiting) reasons.push("waiting on you");
   else if (hasHandoff) reasons.push("handoff in progress");
-  if (dueSoon(due, now)) reasons.push(`next step dated ${due}`);
-  if (important && p.status === "active" && quietSince(p.updated, now)) {
+  if (dueSoon(due, now, prefs.urgentWithinDays)) reasons.push(`next step dated ${due}`);
+  if (
+    important &&
+    p.status === "active" &&
+    quietSince(p.updated, now, prefs.quietAfterDays)
+  ) {
     reasons.push("gone quiet");
   }
   return reasons;
@@ -100,7 +115,8 @@ function projectUrgency(
 function projectItem(
   p: ProjectProgress,
   handoffs: Map<string, HandoffEntry>,
-  now: Date
+  now: Date,
+  prefs: ControlRoomPrefs
 ): MatrixItem {
   const entry = p.path ? handoffs.get(p.path) : undefined;
   const waiting = entry?.waitingOn ?? null;
@@ -112,17 +128,20 @@ function projectItem(
     waiting,
     due,
     entry !== undefined,
-    now
+    now,
+    prefs
   );
 
+  const placed = placementOf(p.placed);
   return {
     kind: "project",
     id: p.name,
     label: p.name,
     detail: p.serves_note ?? p.next?.[0] ?? "",
-    urgent: urgentBecause.length > 0,
-    important,
-    urgentBecause,
+    urgent: placed ? placed.urgent : urgentBecause.length > 0,
+    important: placed ? placed.important : important,
+    placed: p.placed ?? null,
+    urgentBecause: placed ? ["placed by you", ...urgentBecause] : urgentBecause,
     importantBecause: p.serves
       ? SERVES_MEANING[p.serves]
       : "no purpose on record yet — set one to rank it",
@@ -130,11 +149,17 @@ function projectItem(
     servesBy: p.serves_by ?? null,
     due,
     waitingOn: waiting,
+    progress: null,
   };
 }
 
-function goalItem(goal: TelosGoal, now: Date): MatrixItem {
-  const urgent = dueSoon(goal.due, now);
+function goalItem(
+  goal: TelosGoal,
+  now: Date,
+  prefs: ControlRoomPrefs,
+  progress: GoalProgress | null
+): MatrixItem {
+  const urgent = dueSoon(goal.due, now, prefs.urgentWithinDays);
   return {
     kind: "goal",
     id: goal.id,
@@ -142,15 +167,54 @@ function goalItem(goal: TelosGoal, now: Date): MatrixItem {
     detail: goal.horizon ?? goal.text,
     urgent,
     important: true,
+    placed: null,
     urgentBecause: urgent ? [`dated ${goal.due}`] : [],
     importantBecause: "a goal you stated",
     serves: null,
     servesBy: null,
     due: goal.due,
     waitingOn: null,
+    progress,
   };
 }
 
+/** The user's placement, translated back into the two axes it stands for. */
+function placementOf(
+  placed: string | undefined
+): { urgent: boolean; important: boolean } | null {
+  switch (placed) {
+    case "now":
+      return { urgent: true, important: true };
+    case "plan":
+      return { urgent: false, important: true };
+    case "noise":
+      return { urgent: true, important: false };
+    case "later":
+      return { urgent: false, important: false };
+    default:
+      return null;
+  }
+}
+
+/** Criteria closed over criteria written, with snoozed and retired ones left out. */
+function criteriaBySlug(
+  projects: ProjectProgress[],
+  snoozes: Record<string, string>
+): Map<string, { closed: number; written: number }> {
+  return new Map(
+    projects.map((p) => {
+      const iscs = [
+        ...parseIscs(p.criteria ?? ""),
+        ...parseIscs(p.changelog ?? ""),
+      ].filter((i) => i.status !== "retired" && !snoozedUntil(p.name, i.id, snoozes));
+      return [
+        p.name,
+        { closed: iscs.filter((i) => i.status === "done").length, written: iscs.length },
+      ];
+    })
+  );
+}
+
 function quadrant(items: MatrixItem[], urgent: boolean, important: boolean) {
   return items
     .filter((i) => i.urgent === urgent && i.important === important)
@@ -172,11 +236,19 @@ export function buildMatrix(items: MatrixItem[], unranked: number): Matrix {
 }
 
 export function matrix(now: Date = new Date()): Matrix {
+  const prefs = readPrefs();
   const handoffs = new Map(freshHandoffs(now));
-  const ranked = readAllProjects().filter((p) => RANKED_STATUSES.has(p.status));
+  const all = readAllProjects();
+  const ranked = all.filter((p) => RANKED_STATUSES.has(p.status));
+  const links = readGoalLinks();
+  const criteria = criteriaBySlug(all, readSnoozes(now));
   const items = [
-    ...ranked.map((p) => projectItem(p, handoffs, now)),
-    ...readTelosGoals().map((g) => goalItem(g, now)),
+    ...ranked.map((p) => projectItem(p, handoffs, now, prefs)),
+    ...(prefs.rankGoals
+      ? readTelosGoals().map((g) =>
+          goalItem(g, now, prefs, progressFor(g.id, links, criteria))
+        )
+      : []),
   ];
   return buildMatrix(items, ranked.filter((p) => !p.serves).length);
 }

package/src/tools/control-room/prefs.ts

@@ -0,0 +1,96 @@
+/**
+ * The knobs behind the grid and the bell.
+ *
+ * These were constants in the source, which meant "gone quiet after 14 days"
+ * was PAL's opinion rather than the user's. They live in pal-settings.json now,
+ * with the old constants as the defaults so nothing changes until someone says
+ * otherwise.
+ */
+
+import { PROJECT_STALE_DAYS_DEFAULT } from "../../hooks/lib/projects";
+import {
+  raw as rawSettings,
+  reload,
+  write as writeSettings,
+} from "../../hooks/lib/settings";
+
+const ATTENTION_SOURCES = ["refusals", "waiting", "unranked"] as const;
+export type AttentionSource = (typeof ATTENTION_SOURCES)[number];
+
+export interface ControlRoomPrefs {
+  quietAfterDays: number;
+  urgentWithinDays: number;
+  rankGoals: boolean;
+  attention: Record<AttentionSource, boolean>;
+}
+
+const PREF_DEFAULTS: ControlRoomPrefs = {
+  quietAfterDays: PROJECT_STALE_DAYS_DEFAULT,
+  urgentWithinDays: 14,
+  rankGoals: true,
+  attention: { refusals: true, waiting: true, unranked: true },
+};
+
+const DAY_LIMIT = 365;
+
+function storedPrefs(): Partial<ControlRoomPrefs> {
+  const stored = rawSettings().controlRoom;
+  return (stored ?? {}) as Partial<ControlRoomPrefs>;
+}
+
+function positiveDays(value: unknown, fallback: number): number {
+  return typeof value === "number" &&
+    Number.isInteger(value) &&
+    value > 0 &&
+    value <= DAY_LIMIT
+    ? value
+    : fallback;
+}
+
+export function readPrefs(): ControlRoomPrefs {
+  const stored = storedPrefs();
+  return {
+    quietAfterDays: positiveDays(stored.quietAfterDays, PREF_DEFAULTS.quietAfterDays),
+    urgentWithinDays: positiveDays(
+      stored.urgentWithinDays,
+      PREF_DEFAULTS.urgentWithinDays
+    ),
+    rankGoals: stored.rankGoals ?? PREF_DEFAULTS.rankGoals,
+    attention: { ...PREF_DEFAULTS.attention, ...(stored.attention ?? {}) },
+  };
+}
+
+export type PrefUpdate = Partial<ControlRoomPrefs>;
+
+export function validatePrefs(update: PrefUpdate): string | null {
+  for (const key of ["quietAfterDays", "urgentWithinDays"] as const) {
+    const value = update[key];
+    if (value === undefined) continue;
+    if (positiveDays(value, -1) === -1) {
+      return `${key} must be a whole number of days, 1..${DAY_LIMIT}`;
+    }
+  }
+  if (update.rankGoals !== undefined && typeof update.rankGoals !== "boolean") {
+    return "rankGoals must be true or false";
+  }
+  for (const [key, value] of Object.entries(update.attention ?? {})) {
+    if (!(ATTENTION_SOURCES as readonly string[]).includes(key)) {
+      return `unknown attention source: ${key}`;
+    }
+    if (typeof value !== "boolean") return `attention.${key} must be true or false`;
+  }
+  return null;
+}
+
+export function writePrefs(update: PrefUpdate): ControlRoomPrefs {
+  const data = rawSettings();
+  const current = readPrefs();
+  const next: ControlRoomPrefs = {
+    ...current,
+    ...update,
+    attention: { ...current.attention, ...(update.attention ?? {}) },
+  };
+  writeSettings({ ...data, controlRoom: { ...next } });
+  reload();
+  return next;
+}

package/src/tools/control-room/server-config.ts

@@ -0,0 +1,8 @@
+/**
+ * Where the control room listens. Split from server.ts so the build can read it
+ * without importing the server itself — server.ts imports the page bundle, and
+ * a bundler asked to load that would be chasing its own output.
+ */
+
+export const DEFAULT_PORT = 7250;
+export const LOOPBACK = "127.0.0.1";

package/src/tools/control-room/server.ts

@@ -9,14 +9,35 @@
 import { loadMachine } from "../../hooks/lib/machine";
 import { readAllProjects } from "../../hooks/lib/projects";
 import { isServesKind, setServes } from "../../hooks/lib/serves";
+import { PAGE_OUTCOMES } from "../ledger/outcomes";
 import { type LedgerFilter, ledgerFiles, parseSince } from "../ledger/query";
 import { ledgerView } from "../ledger/view";
-import { agenda, agentsAtWork, board, handoffs, signal } from "./data";
+import { attention, markRead } from "./attention";
+import { agenda, agentsAtWork, board, handoffs, signal, summary } from "./data";
+import { projectDetail } from "./detail";
 import { matrix } from "./matrix";
-import index from "./ui/index.html";
+import { type PrefUpdate, readPrefs, validatePrefs, writePrefs } from "./prefs";
+import { DEFAULT_PORT, LOOPBACK } from "./server-config";
+import { MAX_SNOOZE_DAYS, setSnooze } from "./snooze";
+import { indexHtml, staticAsset } from "./static";
+import {
+  type InstallSettings,
+  isQuadrant,
+  QUADRANTS,
+  readInstallSettings,
+  setIscStatus,
+  setPlacement,
+  type WriteOutcome,
+  writeInstallSettings,
+} from "./writes";
 
-export const DEFAULT_PORT = 7250;
-export const LOOPBACK = "127.0.0.1";
+export { DEFAULT_PORT, LOOPBACK };
+
+/**
+ * Every path the single-page app owns. Listed rather than wildcarded, because a
+ * blanket "/*" outranks the fetch handler and would swallow /api as well.
+ */
+const PAGE_ROUTES = ["/", "/projects", "/projects/:slug", "/log", "/settings"];
 
 export interface ServerStatus {
   pid: number;
@@ -30,11 +51,25 @@ function json(body: unknown, status = 200): Response {
   return Response.json(body, { status });
 }
 
-/** A window the page cannot parse is an error, not the whole ledger. */
+const AUTHORITIES: readonly string[] = ["user", "agent"];
+
+/**
+ * Free-form on the record, so the page may name any of them: a runtime or
+ * machine label PAL has never seen simply matches nothing.
+ */
+const PASSTHROUGH = ["project", "runtime", "machine", "actor", "tool"] as const;
+
+/**
+ * A window the page cannot parse is an error, not the whole ledger. The same
+ * goes for a closed set it spells wrong — silently answering with every row
+ * would read as "no such filter" rather than "no such value".
+ */
 function filterFromQuery(params: URLSearchParams): LedgerFilter | string {
   const filter: LedgerFilter = {};
-  const project = params.get("project");
-  if (project) filter.project = project;
+  for (const key of PASSTHROUGH) {
+    const value = params.get(key);
+    if (value) filter[key] = value;
+  }
   for (const key of ["since", "until"] as const) {
     const spec = params.get(key);
     if (!spec) continue;
@@ -42,6 +77,18 @@ function filterFromQuery(params: URLSearchParams): LedgerFilter | string {
     if (!at) return `Unrecognised ${key}: ${spec}`;
     filter[key] = at;
   }
+  const outcome = params.get("outcome");
+  if (outcome) {
+    if (!(PAGE_OUTCOMES as readonly string[]).includes(outcome)) {
+      return `Unrecognised outcome: ${outcome}`;
+    }
+    filter.outcome = outcome;
+  }
+  const authority = params.get("authority");
+  if (authority) {
+    if (!AUTHORITIES.includes(authority)) return `Unrecognised authority: ${authority}`;
+    filter.authority = authority;
+  }
   return filter;
 }
 
@@ -52,6 +99,23 @@ function projects(): Response {
   return json(slugs.map((slug) => ({ slug })));
 }
 
+function oneProject(slug: string | null): Response {
+  if (!slug) return json({ error: "slug is required" }, 400);
+  const detail = projectDetail(slug);
+  return detail ? json(detail) : json({ error: `no such project: ${slug}` }, 404);
+}
+
+const SUMMARY_DAYS_DEFAULT = 14;
+const SUMMARY_DAYS_MAX = 365;
+
+function summaryFor(spec: string | null): Response {
+  const days = spec ? Number(spec) : SUMMARY_DAYS_DEFAULT;
+  if (!Number.isInteger(days) || days < 1 || days > SUMMARY_DAYS_MAX) {
+    return json({ error: `days must be a whole number of 1..${SUMMARY_DAYS_MAX}` }, 400);
+  }
+  return json(summary(days));
+}
+
 function withFilter(url: URL, view: (filter: LedgerFilter) => unknown): Response {
   const filter = filterFromQuery(url.searchParams);
   if (typeof filter === "string") return json({ error: filter }, 400);
@@ -99,19 +163,130 @@ async function overrideServes(request: Request): Promise<Response> {
   return json({ project, serves, by: "user" });
 }
 
+async function readBody(request: Request): Promise<Record<string, unknown> | null> {
+  try {
+    return ((await request.json()) ?? {}) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+function answer(outcome: WriteOutcome, body: Record<string, unknown>): Response {
+  return outcome.ok
+    ? json({ ...body, changed: outcome.changed })
+    : json({ error: outcome.error }, outcome.status);
+}
+
+/** Close or reopen one criterion — the same rule `complete-isc` reaches. */
+async function iscWrite(request: Request): Promise<Response> {
+  const body = await readBody(request);
+  if (!body) return json({ error: "expected a JSON body" }, 400);
+  const { project, id, status } = body;
+  if (typeof project !== "string" || !project) {
+    return json({ error: "project is required" }, 400);
+  }
+  if (typeof id !== "number" || !Number.isInteger(id) || id < 1) {
+    return json({ error: "id must be a positive integer" }, 400);
+  }
+  if (status !== "open" && status !== "done") {
+    return json({ error: "status must be open or done" }, 400);
+  }
+  return answer(setIscStatus(project, id, status === "done"), { project, id, status });
+}
+
+async function placementWrite(request: Request): Promise<Response> {
+  const body = await readBody(request);
+  if (!body) return json({ error: "expected a JSON body" }, 400);
+  const { project, quadrant } = body;
+  if (typeof project !== "string" || !project) {
+    return json({ error: "project is required" }, 400);
+  }
+  if (quadrant !== null && !isQuadrant(quadrant)) {
+    return json(
+      { error: `quadrant must be null or one of ${QUADRANTS.join(", ")}` },
+      400
+    );
+  }
+  return answer(setPlacement(project, quadrant), { project, quadrant });
+}
+
+async function settingsWrite(request: Request): Promise<Response> {
+  const body = await readBody(request);
+  if (!body) return json({ error: "expected a JSON body" }, 400);
+  const update: Partial<InstallSettings> = {};
+  for (const key of ["actor", "timezone"] as const) {
+    const value = body[key];
+    if (value === undefined) continue;
+    if (typeof value !== "string") return json({ error: `${key} must be a string` }, 400);
+    update[key] = value;
+  }
+  const outcome = writeInstallSettings(update);
+  return outcome.ok ? json(readInstallSettings()) : answer(outcome, {});
+}
+
+async function snoozeWrite(request: Request): Promise<Response> {
+  const body = await readBody(request);
+  if (!body) return json({ error: "expected a JSON body" }, 400);
+  const { project, id, days } = body;
+  if (typeof project !== "string" || !project) {
+    return json({ error: "project is required" }, 400);
+  }
+  if (typeof id !== "number" || !Number.isInteger(id) || id < 1) {
+    return json({ error: "id must be a positive integer" }, 400);
+  }
+  if (
+    typeof days !== "number" ||
+    !Number.isInteger(days) ||
+    days < 0 ||
+    days > MAX_SNOOZE_DAYS
+  ) {
+    return json({ error: `days must be a whole number of 0..${MAX_SNOOZE_DAYS}` }, 400);
+  }
+  return json({ project, id, until: setSnooze(project, id, days) });
+}
+
+async function readWrite(request: Request): Promise<Response> {
+  const body = await readBody(request);
+  if (!body) return json({ error: "expected a JSON body" }, 400);
+  const ids = body.all === true ? attention().items.map((i) => i.id) : body.ids;
+  if (!Array.isArray(ids) || ids.some((id) => typeof id !== "string")) {
+    return json({ error: "ids must be an array of strings, or all must be true" }, 400);
+  }
+  return json({ marked: markRead(ids as string[]) });
+}
+
+async function prefsWrite(request: Request): Promise<Response> {
+  const body = await readBody(request);
+  if (!body) return json({ error: "expected a JSON body" }, 400);
+  const failure = validatePrefs(body as PrefUpdate);
+  return failure ? json({ error: failure }, 400) : json(writePrefs(body as PrefUpdate));
+}
+
+const WRITES: Record<string, (request: Request) => Promise<Response>> = {
+  "/api/serves": overrideServes,
+  "/api/isc": iscWrite,
+  "/api/placement": placementWrite,
+  "/api/settings": settingsWrite,
+  "/api/snooze": snoozeWrite,
+  "/api/attention/read": readWrite,
+  "/api/prefs": prefsWrite,
+};
+
 export function startControlRoom(port: number = DEFAULT_PORT) {
   const startedAt = new Date().toISOString();
   return Bun.serve({
     hostname: LOOPBACK,
     port,
     development: false,
-    routes: { "/": index },
+    routes: Object.fromEntries(PAGE_ROUTES.map((path) => [path, () => indexHtml()])),
     fetch(request, server) {
       const url = new URL(request.url);
-      if (request.method === "POST" && url.pathname === "/api/serves") {
-        return overrideServes(request);
-      }
+      const write = WRITES[url.pathname];
+      if (request.method === "POST" && write) return write(request);
       if (request.method !== "GET") return json({ error: "read only" }, 405);
+      if (!url.pathname.startsWith("/api/")) {
+        return staticAsset(url.pathname) ?? json({ error: "not found" }, 404);
+      }
       switch (url.pathname) {
         case "/api/agenda":
           return json(agenda());
@@ -127,8 +302,18 @@ export function startControlRoom(port: number = DEFAULT_PORT) {
           return withFilter(url, agentsAtWork);
         case "/api/ledger":
           return withFilter(url, ledgerView);
+        case "/api/project":
+          return oneProject(url.searchParams.get("slug"));
+        case "/api/summary":
+          return summaryFor(url.searchParams.get("days"));
         case "/api/projects":
           return projects();
+        case "/api/settings":
+          return json(readInstallSettings());
+        case "/api/prefs":
+          return json(readPrefs());
+        case "/api/attention":
+          return json(attention());
         case "/api/status":
           return status(server.port ?? port, startedAt);
         default:

package/src/tools/control-room/snooze.ts

@@ -0,0 +1,65 @@
+/**
+ * Snoozed criteria — an ISC you have seen and do not want ranked this week.
+ *
+ * Kept out of the ISA on purpose: the record says what the project is judged
+ * against, and "not this week" is a fact about your attention rather than about
+ * the project. It expires by date, so nothing has to unsnooze it.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { ensureDir, paths } from "../../hooks/lib/paths";
+
+const DAY_MS = 86_400_000;
+export const MAX_SNOOZE_DAYS = 90;
+
+/** project#isc → the day it wakes up. */
+export type Snoozes = Record<string, string>;
+
+function snoozeKey(project: string, id: number): string {
+  return `${project}#${id}`;
+}
+
+function snoozeFile(): string {
+  return resolve(ensureDir(paths.state()), "snoozed.json");
+}
+
+export function readSnoozes(now: Date = new Date()): Snoozes {
+  const file = snoozeFile();
+  if (!existsSync(file)) return {};
+  let stored: Snoozes;
+  try {
+    stored = JSON.parse(readFileSync(file, "utf-8")) as Snoozes;
+  } catch {
+    return {};
+  }
+  const today = now.toISOString().slice(0, 10);
+  return Object.fromEntries(
+    Object.entries(stored).filter(
+      ([, until]) => typeof until === "string" && until > today
+    )
+  );
+}
+
+export function snoozedUntil(
+  project: string,
+  id: number,
+  snoozes: Snoozes
+): string | null {
+  return snoozes[snoozeKey(project, id)] ?? null;
+}
+
+/** Zero days wakes it now, which is how the page un-snoozes. */
+export function setSnooze(
+  project: string,
+  id: number,
+  days: number,
+  now: Date = new Date()
+): string | null {
+  const live = readSnoozes(now);
+  const key = snoozeKey(project, id);
+  if (days <= 0) delete live[key];
+  else live[key] = new Date(now.getTime() + days * DAY_MS).toISOString().slice(0, 10);
+  writeFileSync(snoozeFile(), `${JSON.stringify(live, null, 2)}\n`, "utf-8");
+  return live[key] ?? null;
+}