daily-focus 0.1.0

package/dist/chunk-2PLWVW5T.js

@@ -0,0 +1,987 @@
+import {
+  BRIEF_REFRESH_GRACE_HOURS,
+  describeSchedule,
+  nextRunDate,
+  resolveSchedule,
+  runsOn
+} from "./chunk-G4K24I4M.js";
+import {
+  calendarDaysBetween,
+  isDateOnly,
+  isSameLocalDay,
+  isWorkingDay,
+  localDateKey,
+  parseISO,
+  startOfLocalDay,
+  workingDaysSince,
+  workingMsBetween
+} from "./chunk-EXGTFXNV.js";
+
+// src/fs.ts
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+async function writeJsonAtomic(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  const temp = tempPathFor(path);
+  await writeFile(temp, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  await rename(temp, path);
+}
+function tempPathFor(path) {
+  return `${path}.tmp`;
+}
+
+// src/ids.ts
+function canonicalId(id) {
+  return id.trim().toLowerCase();
+}
+function fingerprintId(id) {
+  return id.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+// src/archive.ts
+import { readFile, readdir } from "node:fs/promises";
+import { resolve } from "node:path";
+var ARCHIVE_FILE = /^items-(\d{4}-\d{2}-\d{2})\.json$/;
+var MAX_ARCHIVE_FILES = 130;
+var RECENT_WINDOW_DAYS = 14;
+function archivePath(config, dateKey) {
+  return resolve(config.archiveDir, `items-${dateKey}.json`);
+}
+function briefDateKey(brief) {
+  if (brief.date && /^\d{4}-\d{2}-\d{2}$/.test(brief.date)) return brief.date;
+  const generated = parseISO(brief.generatedAt);
+  return localDateKey(generated ?? /* @__PURE__ */ new Date());
+}
+async function archiveBrief(config, brief) {
+  const dateKey = briefDateKey(brief);
+  const target = archivePath(config, dateKey);
+  try {
+    const existing = JSON.parse(await readFile(target, "utf8"));
+    const existingAt = parseISO(existing.generatedAt)?.getTime() ?? 0;
+    const incomingAt = parseISO(brief.generatedAt)?.getTime() ?? 0;
+    if (existingAt >= incomingAt) return false;
+  } catch {
+  }
+  await writeJsonAtomic(target, brief);
+  return true;
+}
+async function listArchivedDates(config) {
+  let names;
+  try {
+    names = await readdir(config.archiveDir);
+  } catch {
+    return [];
+  }
+  return names.map((name) => ARCHIVE_FILE.exec(name)?.[1]).filter((date) => date !== void 0).sort();
+}
+async function readArchiveIndex(config) {
+  const index = /* @__PURE__ */ new Map();
+  const dated = (await listArchivedDates(config)).reverse().slice(0, MAX_ARCHIVE_FILES);
+  for (const date of dated) {
+    let brief;
+    try {
+      brief = JSON.parse(await readFile(archivePath(config, date), "utf8"));
+    } catch {
+      continue;
+    }
+    for (const item of brief.items ?? []) {
+      if (!item?.id) continue;
+      const existing = index.get(item.id);
+      if (!existing) {
+        index.set(item.id, {
+          title: item.title ?? item.id,
+          advancesObjective: item.advancesObjective === true,
+          firstSeen: item.firstSeen
+        });
+        continue;
+      }
+      if (item.firstSeen && (!existing.firstSeen || item.firstSeen < existing.firstSeen)) {
+        existing.firstSeen = item.firstSeen;
+      }
+    }
+  }
+  return index;
+}
+function computeObjectiveProgress(index, actions, now, counts = isWorkingDay) {
+  const lastAction = /* @__PURE__ */ new Map();
+  for (const action of actions) {
+    if (action.action === "note") continue;
+    lastAction.set(canonicalId(action.id), action);
+  }
+  const byCanonical = /* @__PURE__ */ new Map();
+  for (const [id, entry] of index) byCanonical.set(canonicalId(id), entry);
+  let lastAt = null;
+  let lastTitle = null;
+  let recentCount = 0;
+  for (const [id, action] of lastAction) {
+    if (action.action !== "done") continue;
+    if (!byCanonical.get(id)?.advancesObjective) continue;
+    const at = parseISO(action.at);
+    if (!at) continue;
+    if (workingDaysSince(at, now, counts) <= RECENT_WINDOW_DAYS) recentCount++;
+    if (!lastAt || at.getTime() > lastAt.getTime()) {
+      lastAt = at;
+      lastTitle = byCanonical.get(id)?.title ?? null;
+    }
+  }
+  return {
+    workingDaysSince: lastAt ? workingDaysSince(lastAt, now, counts) : null,
+    lastAt: lastAt ? lastAt.toISOString() : null,
+    lastTitle,
+    recentCount,
+    windowDays: RECENT_WINDOW_DAYS
+  };
+}
+
+// src/validate.ts
+var SOURCES = /* @__PURE__ */ new Set([
+  "github",
+  "email",
+  "calendar",
+  "jira",
+  "slack",
+  "workday",
+  "tasks",
+  "atlassian",
+  "reminders",
+  "messages",
+  "eboks",
+  "other"
+]);
+var KINDS = /* @__PURE__ */ new Set(["task", "event", "info"]);
+var SOURCE_ALIASES = {
+  gmail: "email",
+  mail: "email",
+  gcal: "calendar",
+  "google-calendar": "calendar",
+  "google-tasks": "tasks",
+  gtasks: "tasks",
+  todo: "tasks",
+  pr: "github",
+  gh: "github",
+  confluence: "atlassian",
+  "apple-reminders": "reminders",
+  imessage: "messages",
+  "apple-messages": "messages",
+  sms: "messages",
+  "e-boks": "eboks"
+};
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function optionalString(v) {
+  return typeof v === "string" && v.trim() !== "" ? v : void 0;
+}
+function optionalStringArray(v) {
+  if (!Array.isArray(v)) return void 0;
+  const out = v.filter((x) => typeof x === "string" && x.trim() !== "");
+  return out.length > 0 ? out : void 0;
+}
+function normalizeSource(v) {
+  if (typeof v !== "string") return "other";
+  const key = v.trim().toLowerCase();
+  if (SOURCES.has(key)) return key;
+  return SOURCE_ALIASES[key] ?? "other";
+}
+function normalizeKind(v, hasStart) {
+  if (typeof v === "string" && KINDS.has(v.trim().toLowerCase())) {
+    return v.trim().toLowerCase();
+  }
+  return hasStart ? "event" : "task";
+}
+function parseClockTime(value) {
+  if (typeof value !== "string" || value.trim() === "") return void 0;
+  const text = value.trim();
+  const clock = /^(\d{1,2}):(\d{2})$/.exec(text);
+  if (clock) {
+    const hour = Number(clock[1]);
+    const minute = Number(clock[2]);
+    if (hour > 23 || minute > 59) return void 0;
+    return `${String(hour).padStart(2, "0")}:${clock[2]}`;
+  }
+  const parsed = new Date(text);
+  if (Number.isNaN(parsed.getTime())) return void 0;
+  return `${String(parsed.getHours()).padStart(2, "0")}:${String(parsed.getMinutes()).padStart(2, "0")}`;
+}
+function parseItem(raw, index, warnings) {
+  if (!isObject(raw)) {
+    warnings.push(`items[${index}] is not an object; skipped`);
+    return null;
+  }
+  const id = optionalString(raw.id);
+  if (!id) {
+    warnings.push(`items[${index}] has no "id"; skipped (ids are how actions stay attached)`);
+    return null;
+  }
+  const title = optionalString(raw.title);
+  if (!title) {
+    warnings.push(`items[${index}] (${id}) has no "title"; skipped`);
+    return null;
+  }
+  const start = optionalString(raw.start);
+  const item = {
+    id,
+    title,
+    source: normalizeSource(raw.source),
+    kind: normalizeKind(raw.kind, start !== void 0)
+  };
+  const detail = optionalString(raw.detail);
+  if (detail) item.detail = detail;
+  const url = optionalString(raw.url);
+  if (url && /^https?:\/\//i.test(url)) item.url = url;
+  else if (url) warnings.push(`items[${index}] (${id}) has a non-http url; dropped`);
+  if (typeof raw.priority === "number" && Number.isFinite(raw.priority)) {
+    item.priority = raw.priority;
+  }
+  const due = optionalString(raw.due);
+  if (due) item.due = due;
+  if (start) item.start = start;
+  const end = optionalString(raw.end);
+  if (end) item.end = end;
+  if (raw.blocking === false) item.blocking = false;
+  const tags = optionalStringArray(raw.tags);
+  if (tags) item.tags = tags;
+  const people = optionalStringArray(raw.people);
+  if (people) item.people = people;
+  const firstSeen = optionalString(raw.firstSeen);
+  if (firstSeen) item.firstSeen = firstSeen;
+  if (raw.advancesObjective === true) item.advancesObjective = true;
+  return item;
+}
+function parseBrief(text) {
+  const warnings = [];
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (err) {
+    return {
+      brief: null,
+      error: `items.json is not valid JSON: ${err.message}`,
+      warnings
+    };
+  }
+  if (!isObject(raw)) {
+    return { brief: null, error: "items.json must contain a JSON object", warnings };
+  }
+  if (raw.version !== void 0 && raw.version !== 1) {
+    warnings.push(`items.json declares version ${String(raw.version)}; this dashboard understands version 1`);
+  }
+  if (!Array.isArray(raw.items)) {
+    return { brief: null, error: 'items.json must have an "items" array', warnings };
+  }
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  raw.items.forEach((entry, i) => {
+    const item = parseItem(entry, i, warnings);
+    if (!item) return;
+    if (seen.has(item.id)) {
+      warnings.push(`items[${i}] repeats id "${item.id}"; kept the first occurrence`);
+      return;
+    }
+    seen.add(item.id);
+    items.push(item);
+  });
+  const generatedAt = optionalString(raw.generatedAt) ?? (/* @__PURE__ */ new Date()).toISOString();
+  if (!optionalString(raw.generatedAt)) {
+    warnings.push('items.json has no "generatedAt"; assuming it was written just now');
+  }
+  const brief = { version: 1, generatedAt, items };
+  const generatedBy = optionalString(raw.generatedBy);
+  if (generatedBy) brief.generatedBy = generatedBy;
+  const date = optionalString(raw.date);
+  if (date) brief.date = date;
+  const headline = optionalString(raw.headline);
+  if (headline) brief.headline = headline;
+  const dayStart = parseClockTime(raw.dayStart);
+  if (dayStart) brief.dayStart = dayStart;
+  const dayEnd = parseClockTime(raw.dayEnd);
+  if (dayEnd) brief.dayEnd = dayEnd;
+  if (raw.dayStart !== void 0 && !dayStart) warnings.push('items.json has an unreadable "dayStart"; using the default');
+  if (raw.dayEnd !== void 0 && !dayEnd) warnings.push('items.json has an unreadable "dayEnd"; using the default');
+  return { brief, error: null, warnings };
+}
+function parseActionLine(line) {
+  const trimmed = line.trim();
+  if (trimmed === "") return null;
+  let raw;
+  try {
+    raw = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (!isObject(raw)) return null;
+  const id = optionalString(raw.id);
+  const action = optionalString(raw.action);
+  if (!id || !action) return null;
+  if (!["done", "snooze", "dismiss", "reopen", "note"].includes(action)) return null;
+  const result = {
+    id,
+    action,
+    at: optionalString(raw.at) ?? (/* @__PURE__ */ new Date(0)).toISOString()
+  };
+  const until = optionalString(raw.until);
+  if (until) result.until = until;
+  const text = optionalString(raw.text);
+  if (text) result.text = text;
+  return result;
+}
+
+// src/checks.ts
+var GENEROUS_FLAG_THRESHOLD = 5;
+function runContractChecks({ brief, items, focus, history }) {
+  const problems = [];
+  if (focus?.objective) {
+    const aligned = items.filter((item) => item.advancesObjective);
+    const openAligned = aligned.filter((item) => item.status === "open");
+    if (aligned.length === 0) {
+      problems.push(
+        `Nothing in today's brief advances the objective (${focus.objective}). Either the agent missed it, or today genuinely has no path to it \u2014 both are worth knowing.`
+      );
+    } else if (openAligned.length === 0) {
+      problems.push(`Everything advancing the objective is already handled. Worth queuing the next step.`);
+    }
+    if (aligned.length > GENEROUS_FLAG_THRESHOLD) {
+      problems.push(
+        `${aligned.length} items are flagged as advancing the objective. That's generous enough that "days since progress" is probably flattering you.`
+      );
+    }
+  }
+  const reset = brief.items.filter((item) => {
+    const previous = history.get(item.id)?.firstSeen;
+    return previous && item.firstSeen && previous < item.firstSeen;
+  });
+  if (reset.length > 0) {
+    problems.push(
+      `${reset.length} item(s) had their "first seen" date moved forward, which resets how old they look. Oldest affected: ${reset[0].title}`
+    );
+  }
+  const byFingerprint = /* @__PURE__ */ new Map();
+  for (const id of history.keys()) byFingerprint.set(fingerprintId(id), id);
+  for (const item of brief.items) {
+    if (history.has(item.id)) continue;
+    const previous = byFingerprint.get(fingerprintId(item.id));
+    if (previous) {
+      problems.push(
+        `Item id changed shape: "${previous}" is now "${item.id}". Anything you already completed under the old id will come back.`
+      );
+    }
+  }
+  const leak = findLeakedPhrase(brief, focus);
+  if (leak) {
+    problems.push(
+      `Private text from focus.md appears in the brief ("${leak}\u2026"), so it is on screen. That section is meant to stay out of the rendered page.`
+    );
+  }
+  return problems;
+}
+function findLeakedPhrase(brief, focus) {
+  if (!focus?.agentOnly) return null;
+  const words = (text) => text.toLowerCase().split(/[^a-z0-9-]+/).filter(Boolean);
+  const rendered = words(JSON.stringify(brief)).join(" ");
+  const secret = words(focus.agentOnly);
+  for (let i = 0; i + 6 <= secret.length; i++) {
+    const phrase = secret.slice(i, i + 6).join(" ");
+    if (rendered.includes(phrase)) return phrase;
+  }
+  return null;
+}
+
+// src/sessions.ts
+import { appendFile, mkdir as mkdir2, readFile as readFile2, unlink } from "node:fs/promises";
+var MAX_SESSION_MINUTES = 120;
+var MIN_LOGGABLE_MINUTES = 1;
+async function readActive(config) {
+  try {
+    return JSON.parse(await readFile2(config.sessionFile, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function writeActive(config, session) {
+  await writeJsonAtomic(config.sessionFile, session);
+}
+async function clearActive(config) {
+  try {
+    await unlink(config.sessionFile);
+  } catch {
+  }
+}
+async function logSession(config, session, endedAt, endedBy) {
+  const startedAt = parseISO(session.startedAt);
+  if (!startedAt) return null;
+  const actualMinutes = Math.round((endedAt.getTime() - startedAt.getTime()) / 6e4);
+  if (actualMinutes < MIN_LOGGABLE_MINUTES) return null;
+  const entry = {
+    id: session.id,
+    title: session.title,
+    startedAt: session.startedAt,
+    endedAt: endedAt.toISOString(),
+    plannedMinutes: session.minutes,
+    actualMinutes,
+    reachedTarget: actualMinutes >= session.minutes,
+    advancesObjective: session.advancesObjective,
+    endedBy
+  };
+  await mkdir2(config.dataDir, { recursive: true });
+  await appendFile(config.sessionsLogFile, `${JSON.stringify(entry)}
+`, "utf8");
+  return entry;
+}
+async function startSession(config, opts) {
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  await stopSession(config, now);
+  await writeActive(config, {
+    id: opts.id,
+    title: opts.title,
+    startedAt: now.toISOString(),
+    minutes: opts.minutes,
+    advancesObjective: opts.advancesObjective,
+    // The click that got here is itself the first evidence of a person.
+    lastActiveAt: now.toISOString()
+  });
+}
+async function stopSession(config, now = /* @__PURE__ */ new Date(), endedBy = "user") {
+  const active = await readActive(config);
+  if (!active) return null;
+  await logSession(config, active, now, endedBy);
+  await clearActive(config);
+  return active;
+}
+async function reconcileSession(config, probe, now = /* @__PURE__ */ new Date()) {
+  if (config.awayAfterMinutes <= 0) return null;
+  const active = await readActive(config);
+  if (!active) return null;
+  const startedAt = parseISO(active.startedAt);
+  if (!startedAt) {
+    await clearActive(config);
+    return null;
+  }
+  const awayAfterMs = config.awayAfterMinutes * 6e4;
+  const previous = parseISO(active.lastActiveAt) ?? startedAt;
+  if (now.getTime() - previous.getTime() > awayAfterMs) {
+    const logged = await logSession(config, active, previous, "away");
+    await clearActive(config);
+    return logged;
+  }
+  const idleSeconds = await probe();
+  const lastInput = idleSeconds === null ? now : new Date(now.getTime() - Math.max(0, idleSeconds) * 1e3);
+  const confirmed = lastInput.getTime() > previous.getTime() ? lastInput : previous;
+  if (confirmed.toISOString() !== active.lastActiveAt) {
+    await writeActive(config, { ...active, lastActiveAt: confirmed.toISOString() });
+  }
+  return null;
+}
+async function closeIfPastBackstop(config, active, now) {
+  if (!active) return null;
+  const startedAt = parseISO(active.startedAt);
+  const elapsed = startedAt ? (now.getTime() - startedAt.getTime()) / 6e4 : Infinity;
+  if (elapsed <= MAX_SESSION_MINUTES) return active;
+  const ceiling = new Date((startedAt?.getTime() ?? now.getTime()) + MAX_SESSION_MINUTES * 6e4);
+  await stopSession(config, ceiling, "limit");
+  return null;
+}
+function lastUnattendedClose(todayLog) {
+  const last = todayLog.at(-1);
+  if (!last || last.endedBy === void 0 || last.endedBy === "user") return null;
+  return {
+    id: last.id,
+    title: last.title,
+    endedAt: last.endedAt,
+    actualMinutes: last.actualMinutes,
+    reason: last.endedBy
+  };
+}
+async function readSessionState(config, agenda, now = /* @__PURE__ */ new Date()) {
+  const active = await closeIfPastBackstop(config, await readActive(config), now);
+  const todayLog = await readTodaysSessions(config, now);
+  const completedToday = todayLog.length;
+  const minutesToday = todayLog.reduce((sum, entry) => sum + entry.actualMinutes, 0);
+  const unattendedClose = active ? null : lastUnattendedClose(todayLog);
+  if (!active) {
+    return { active: null, completedToday, minutesToday, unattendedClose };
+  }
+  const startedAt = parseISO(active.startedAt);
+  const endsAt = new Date(startedAt.getTime() + active.minutes * 6e4);
+  const remainingSeconds = Math.round((endsAt.getTime() - now.getTime()) / 1e3);
+  const nextEvent = agenda.events.map((event) => parseISO(event.start)).filter((start) => start !== null && start.getTime() > now.getTime()).sort((a, b) => a.getTime() - b.getTime())[0];
+  return {
+    active: {
+      id: active.id,
+      title: active.title,
+      startedAt: active.startedAt,
+      advancesObjective: active.advancesObjective,
+      lastActiveAt: active.lastActiveAt,
+      endsAt: endsAt.toISOString(),
+      minutes: active.minutes,
+      remainingSeconds,
+      overrun: remainingSeconds < 0,
+      collidesWithNextEvent: nextEvent ? nextEvent.getTime() < endsAt.getTime() : false,
+      nextEventAt: nextEvent ? nextEvent.toISOString() : null
+    },
+    completedToday,
+    minutesToday,
+    unattendedClose
+  };
+}
+async function readSessions(config) {
+  let text;
+  try {
+    text = await readFile2(config.sessionsLogFile, "utf8");
+  } catch {
+    return [];
+  }
+  const sessions = [];
+  for (const line of text.split("\n")) {
+    if (line.trim() === "") continue;
+    try {
+      const entry = JSON.parse(line);
+      if (entry?.id && entry.startedAt) sessions.push(entry);
+    } catch {
+    }
+  }
+  return sessions;
+}
+async function readTodaysSessions(config, now) {
+  const all = await readSessions(config);
+  return all.filter((entry) => {
+    const started = parseISO(entry.startedAt);
+    return started !== null && started.getFullYear() === now.getFullYear() && started.getMonth() === now.getMonth() && started.getDate() === now.getDate();
+  });
+}
+
+// src/store.ts
+import { appendFile as appendFile2, mkdir as mkdir3, readFile as readFile3 } from "node:fs/promises";
+import { setTimeout as delay } from "node:timers/promises";
+
+// src/agenda.ts
+var DEFAULT_EVENT_MINUTES = 30;
+var MS_PER_MINUTE = 6e4;
+function busySpan(item) {
+  if (isDateOnly(item.start)) return null;
+  if (item.blocking === false) return null;
+  const start = parseISO(item.start);
+  if (!start) return null;
+  const parsedEnd = parseISO(item.end);
+  const end = parsedEnd && parsedEnd.getTime() > start.getTime() ? parsedEnd : new Date(start.getTime() + DEFAULT_EVENT_MINUTES * MS_PER_MINUTE);
+  return { start: start.getTime(), end: end.getTime() };
+}
+function mergeIntervals(intervals) {
+  const sorted = [...intervals].sort((a, b) => a.start - b.start);
+  const merged = [];
+  for (const next of sorted) {
+    const last = merged[merged.length - 1];
+    if (last && next.start <= last.end) {
+      last.end = Math.max(last.end, next.end);
+    } else {
+      merged.push({ ...next });
+    }
+  }
+  return merged;
+}
+function dayBoundary(now, clock, fallbackHour) {
+  const parsed = clock ? /^(\d{1,2}):(\d{2})$/.exec(clock) : null;
+  const hour = parsed ? Number(parsed[1]) : fallbackHour;
+  const minute = parsed ? Number(parsed[2]) : 0;
+  return new Date(now.getFullYear(), now.getMonth(), now.getDate(), hour, minute, 0, 0);
+}
+function clockString(d) {
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+function buildAgenda(items, now, opts) {
+  const events = items.filter((item) => item.kind === "event" && item.status !== "dismissed").filter((item) => {
+    const start = parseISO(item.start);
+    return start !== null && isSameLocalDay(start, now);
+  }).sort((a, b) => {
+    const aAllDay = isDateOnly(a.start);
+    const bAllDay = isDateOnly(b.start);
+    if (aAllDay !== bAllDay) return aAllDay ? -1 : 1;
+    const at = parseISO(a.start)?.getTime() ?? 0;
+    const bt = parseISO(b.start)?.getTime() ?? 0;
+    return at - bt;
+  });
+  const spans = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const span = busySpan(event);
+    if (span) spans.set(event.id, span);
+  }
+  const conflictIds = /* @__PURE__ */ new Set();
+  const entries = [...spans.entries()];
+  for (let i = 0; i < entries.length; i++) {
+    for (let j = i + 1; j < entries.length; j++) {
+      const [idA, a] = entries[i];
+      const [idB, b] = entries[j];
+      if (a.start < b.end && b.start < a.end) {
+        conflictIds.add(idA);
+        conflictIds.add(idB);
+      }
+    }
+  }
+  const dayStart = dayBoundary(now, opts.dayStart, opts.workStartHour);
+  const dayEnd = dayBoundary(now, opts.dayEnd, opts.workEndHour);
+  const busy = mergeIntervals(
+    [...spans.values()].map((span) => ({
+      start: Math.max(span.start, dayStart.getTime()),
+      end: Math.min(span.end, dayEnd.getTime())
+    })).filter((span) => span.end > span.start)
+  );
+  const freeWindows = [];
+  let cursor = dayStart.getTime();
+  const stops = opts.freeWindows ? [...busy, { start: dayEnd.getTime(), end: dayEnd.getTime() }] : [];
+  for (const span of stops) {
+    const minutes = Math.round((span.start - cursor) / MS_PER_MINUTE);
+    if (minutes >= opts.minFreeWindowMinutes) {
+      freeWindows.push({
+        start: new Date(cursor).toISOString(),
+        end: new Date(span.start).toISOString(),
+        minutes
+      });
+    }
+    cursor = Math.max(cursor, span.end);
+  }
+  let remainingFocusMinutes = 0;
+  for (const window of freeWindows) {
+    const start = Math.max(new Date(window.start).getTime(), now.getTime());
+    const end = new Date(window.end).getTime();
+    if (end > start) remainingFocusMinutes += Math.round((end - start) / MS_PER_MINUTE);
+  }
+  return {
+    events,
+    conflictIds: [...conflictIds],
+    tracksFreeTime: opts.freeWindows,
+    freeWindows,
+    remainingFocusMinutes,
+    dayStart: clockString(dayStart),
+    dayEnd: clockString(dayEnd)
+  };
+}
+
+// src/focus.ts
+var AGENT_ONLY_MARKER = /^[ \t]*<!--[ \t]*agent-only[ \t]*-->[ \t]*$/im;
+var FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---[ \t]*\r?\n?/;
+var COMMENT = /<!--[\s\S]*?-->/g;
+var KNOWN_KEYS = /* @__PURE__ */ new Set(["objective", "blocker"]);
+function clean(value) {
+  const trimmed = value.trim().replace(/^(['"])([\s\S]*)\1$/, "$2").trim();
+  return trimmed === "" ? null : trimmed;
+}
+function parseFocus(text) {
+  const focus = { objective: null, blocker: null, note: null, agentOnly: null };
+  let body = text;
+  const frontmatter = FRONTMATTER.exec(text);
+  if (frontmatter) {
+    body = text.slice(frontmatter[0].length);
+    for (const line of (frontmatter[1] ?? "").split("\n")) {
+      const separator = line.indexOf(":");
+      if (separator === -1) continue;
+      const key = line.slice(0, separator).trim().toLowerCase();
+      if (KNOWN_KEYS.has(key)) {
+        focus[key] = clean(line.slice(separator + 1));
+      }
+    }
+  }
+  const marker = AGENT_ONLY_MARKER.exec(body);
+  if (marker) {
+    focus.agentOnly = clean(body.slice(marker.index + marker[0].length));
+    body = body.slice(0, marker.index);
+  }
+  focus.note = clean(body.replace(COMMENT, ""));
+  if (!focus.objective && focus.note) {
+    const [first, ...rest] = focus.note.split("\n");
+    focus.objective = clean(first ?? "");
+    focus.note = clean(rest.join("\n"));
+  }
+  return focus;
+}
+function toPublicFocus(focus) {
+  return { objective: focus.objective, blocker: focus.blocker, note: focus.note };
+}
+
+// src/store.ts
+var READ_RETRIES = 3;
+var READ_RETRY_MS = 40;
+var Store = class {
+  config;
+  /** Appends are chained so two concurrent clicks can't interleave a half-written line. */
+  #writeQueue = Promise.resolve();
+  constructor(config) {
+    this.config = config;
+  }
+  async ensureDataDir() {
+    await mkdir3(this.config.dataDir, { recursive: true });
+  }
+  /**
+   * Read and parse items.json.
+   *
+   * Retries a parse failure a couple of times: if the agent writes the file
+   * non-atomically we can catch it mid-truncation, and a transient blank read
+   * should not flash an error banner at the user.
+   */
+  async readBrief() {
+    let last = {
+      brief: null,
+      error: "items.json has not been written yet",
+      warnings: []
+    };
+    for (let attempt = 0; attempt < READ_RETRIES; attempt++) {
+      let text;
+      try {
+        text = await readFile3(this.config.itemsFile, "utf8");
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          return {
+            brief: null,
+            error: `No brief yet \u2014 nothing has written ${this.config.itemsFile}`,
+            warnings: []
+          };
+        }
+        return { brief: null, error: `Could not read items.json: ${err.message}`, warnings: [] };
+      }
+      last = parseBrief(text);
+      if (last.error === null) return last;
+      if (attempt < READ_RETRIES - 1) await delay(READ_RETRY_MS);
+    }
+    return last;
+  }
+  /** Read the whole action log, oldest first. */
+  async readActions() {
+    let text;
+    try {
+      text = await readFile3(this.config.actionsFile, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+    const actions = [];
+    for (const line of text.split("\n")) {
+      const action = parseActionLine(line);
+      if (action) actions.push(action);
+    }
+    return actions;
+  }
+  /**
+   * Snapshot the current brief into the archive if it isn't already there.
+   *
+   * Safe to call often — it's a no-op unless items.json is newer than what's on
+   * file for that date. Called on startup and whenever the store changes, so a
+   * brief written while the dashboard was closed still gets captured.
+   */
+  async archiveCurrentBrief() {
+    const { brief } = await this.readBrief();
+    if (!brief) return false;
+    try {
+      return await archiveBrief(this.config, brief);
+    } catch (err) {
+      console.warn(`[daily-focus] could not archive the brief: ${err.message}`);
+      return false;
+    }
+  }
+  /** Read the standing objective. Returns null when focus.md hasn't been written. */
+  async readFocus() {
+    try {
+      return parseFocus(await readFile3(this.config.focusFile, "utf8"));
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      console.warn(`[daily-focus] could not read focus.md: ${err.message}`);
+      return null;
+    }
+  }
+  /** Append one action. The log is append-only; corrections are new lines, never edits. */
+  async appendAction(action) {
+    const line = `${JSON.stringify(action)}
+`;
+    const write = this.#writeQueue.then(async () => {
+      await this.ensureDataDir();
+      await appendFile2(this.config.actionsFile, line, "utf8");
+    });
+    this.#writeQueue = write.catch(() => {
+    });
+    await write;
+  }
+  /**
+   * Read the store and fold it into everything the client needs.
+   *
+   * Everything except `assetVersion`, `board` and `tickets` — the first describes
+   * the served UI, not the data, and the other two are fetched rather than read,
+   * so the server owns all three and layers them on. Keeping them out here means
+   * the store has no opinion about how it's being displayed, or about GitHub and
+   * Jira.
+   */
+  async getState(now = /* @__PURE__ */ new Date(), actions, calendar) {
+    const [{ brief, error, warnings }, readActions, focus] = await Promise.all([
+      this.readBrief(),
+      // The caller may have read the log already, to fold the board from the same
+      // snapshot; two reads could straddle an append and disagree.
+      actions ? Promise.resolve(actions) : this.readActions(),
+      this.readFocus()
+    ]);
+    actions = readActions;
+    const schedule = resolveSchedule(this.config);
+    const isRunDay = (d) => runsOn(schedule, d);
+    const items = brief ? resolveItems(brief.items, actions, now) : [];
+    const live = calendar?.live === true;
+    const agendaItems = live ? resolveItems(calendar.events, actions, now) : items;
+    const agendaSource = {
+      live,
+      fetchedAt: calendar?.fetchedAt ?? null,
+      problem: calendar?.problem ?? null,
+      failure: calendar?.failure ?? null,
+      warnings: calendar?.warnings ?? []
+    };
+    const agenda = buildAgenda(agendaItems, now, {
+      freeWindows: this.config.freeWindows,
+      workStartHour: this.config.workStartHour,
+      workEndHour: this.config.workEndHour,
+      minFreeWindowMinutes: this.config.minFreeWindowMinutes,
+      // The brief's own bounds win: the agent read today's calendar, config didn't.
+      dayStart: brief?.dayStart,
+      dayEnd: brief?.dayEnd
+    });
+    const generatedAt = brief ? parseISO(brief.generatedAt) : null;
+    const ageHours = generatedAt ? Math.floor((now.getTime() - generatedAt.getTime()) / 36e5) : null;
+    const scheduledAgeHours = generatedAt ? workingMsBetween(generatedAt, now, isRunDay) / 36e5 : null;
+    const refreshDue = scheduledAgeHours !== null && scheduledAgeHours >= this.config.staleAfterHours;
+    const stale = scheduledAgeHours !== null && scheduledAgeHours >= this.config.staleAfterHours + BRIEF_REFRESH_GRACE_HOURS;
+    const visible = items.filter((item) => item.status === "open");
+    const todayStart = startOfLocalDay(now);
+    const history = brief ? await readArchiveIndex(this.config) : /* @__PURE__ */ new Map();
+    const contractIssues = brief ? runContractChecks({ brief, items, focus, history }) : [];
+    let objectiveProgress = null;
+    if (focus?.objective && brief) {
+      const withToday = new Map(history);
+      for (const item of brief.items) {
+        if (!withToday.has(item.id)) {
+          withToday.set(item.id, {
+            title: item.title,
+            advancesObjective: item.advancesObjective === true,
+            firstSeen: item.firstSeen
+          });
+        }
+      }
+      objectiveProgress = computeObjectiveProgress(withToday, actions, now, isRunDay);
+    }
+    const session = await readSessionState(this.config, agenda, now);
+    return {
+      // toPublicFocus, not focus — the agent-only section must never be serialised.
+      focus: focus ? toPublicFocus(focus) : null,
+      objectiveProgress,
+      session,
+      schedule: {
+        days: [...schedule.days],
+        source: schedule.source,
+        description: describeSchedule(schedule),
+        runsToday: isRunDay(now),
+        nextRunDate: nextRunDate(schedule, now)
+      },
+      brief: {
+        generatedAt: brief?.generatedAt ?? null,
+        generatedBy: brief?.generatedBy ?? null,
+        date: brief?.date ?? (generatedAt ? localDateKey(generatedAt) : null),
+        headline: brief?.headline ?? null,
+        ageHours,
+        refreshPending: refreshDue && !stale && isRunDay(now),
+        stale
+      },
+      items,
+      agenda,
+      agendaSource,
+      stats: {
+        open: visible.filter((item) => item.kind !== "event").length,
+        topPriority: visible.filter((item) => item.priority !== void 0).length,
+        completedToday: items.filter((item) => {
+          if (item.status !== "done") return false;
+          const at = parseISO(item.statusAt);
+          return at !== null && isSameLocalDay(at, now);
+        }).length,
+        overdue: visible.filter((item) => {
+          const due = parseISO(item.due);
+          return due !== null && due.getTime() < todayStart.getTime();
+        }).length
+      },
+      problem: error,
+      // Parser complaints and contract failures render the same way: both are
+      // things the agent got wrong that you would not otherwise see.
+      warnings: [...warnings, ...contractIssues],
+      now: now.toISOString()
+    };
+  }
+};
+function foldActionLog(actions, now) {
+  const folded = /* @__PURE__ */ new Map();
+  const today = startOfLocalDay(now);
+  for (const action of actions) {
+    const key = canonicalId(action.id);
+    let entry = folded.get(key);
+    if (!entry) {
+      entry = { status: "open", notes: [] };
+      folded.set(key, entry);
+    }
+    switch (action.action) {
+      case "note":
+        if (action.text) entry.notes.push({ text: action.text, at: action.at });
+        break;
+      case "done":
+        entry.status = "done";
+        delete entry.snoozedUntil;
+        entry.statusAt = action.at;
+        break;
+      case "dismiss":
+        entry.status = "dismissed";
+        delete entry.snoozedUntil;
+        entry.statusAt = action.at;
+        break;
+      case "snooze":
+        entry.status = "snoozed";
+        if (action.until) entry.snoozedUntil = action.until;
+        else delete entry.snoozedUntil;
+        entry.statusAt = action.at;
+        break;
+      case "reopen":
+        entry.status = "open";
+        delete entry.snoozedUntil;
+        entry.statusAt = action.at;
+        break;
+    }
+  }
+  for (const entry of folded.values()) {
+    if (entry.status !== "snoozed") continue;
+    const until = parseISO(entry.snoozedUntil);
+    if (until && until.getTime() <= today.getTime()) {
+      entry.status = "open";
+      delete entry.snoozedUntil;
+    }
+  }
+  return folded;
+}
+function resolveItems(items, actions, now) {
+  const folded = foldActionLog(actions, now);
+  return items.map((item) => {
+    const log = folded.get(canonicalId(item.id));
+    const firstSeen = parseISO(item.firstSeen);
+    const resolved = {
+      ...item,
+      status: log?.status ?? "open",
+      notes: log?.notes ?? [],
+      ageDays: firstSeen ? Math.max(0, calendarDaysBetween(firstSeen, now)) : 0
+    };
+    if (log?.snoozedUntil) resolved.snoozedUntil = log.snoozedUntil;
+    if (log?.statusAt) resolved.statusAt = log.statusAt;
+    return resolved;
+  });
+}
+
+export {
+  writeJsonAtomic,
+  tempPathFor,
+  canonicalId,
+  fingerprintId,
+  readArchiveIndex,
+  parseBrief,
+  runContractChecks,
+  startSession,
+  stopSession,
+  reconcileSession,
+  Store,
+  foldActionLog,
+  resolveItems
+};