daily-focus 0.1.0

package/dist/server-B4FWZHS2.js

@@ -0,0 +1,4814 @@
+import {
+  FOCUS_TEMPLATE,
+  sourcesTemplate
+} from "./chunk-V2UN3JYL.js";
+import {
+  describeLink,
+  linkStore,
+  storeLinkWarning
+} from "./chunk-QKT2FAB5.js";
+import {
+  Store,
+  canonicalId,
+  foldActionLog,
+  reconcileSession,
+  startSession,
+  stopSession,
+  tempPathFor,
+  writeJsonAtomic
+} from "./chunk-2PLWVW5T.js";
+import {
+  CLI_NAMES,
+  LAUNCH_SETTINGS,
+  PROFILES,
+  briefWritingTools,
+  describeTime,
+  envSources,
+  layerEnv,
+  loadConfig,
+  nextScheduledRun,
+  readDotEnv,
+  resolveSchedule,
+  scheduledRunDue
+} from "./chunk-G4K24I4M.js";
+import {
+  PACKAGED,
+  command,
+  ranDirectly
+} from "./chunk-6VWWJZKJ.js";
+import {
+  laterISO,
+  parseISO
+} from "./chunk-EXGTFXNV.js";
+
+// src/server.ts
+import { createServer } from "node:http";
+import { createReadStream } from "node:fs";
+import { stat as stat4 } from "node:fs/promises";
+import { basename, extname, join as join4, normalize, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/editable.ts
+import { createHash } from "node:crypto";
+import { readFile, rename, writeFile } from "node:fs/promises";
+var ABSENT = "absent";
+function versionOf(text) {
+  return text === null ? ABSENT : createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+async function readEditable(path) {
+  try {
+    const text = await readFile(path, "utf8");
+    return { text, version: versionOf(text) };
+  } catch (error) {
+    if (error.code === "ENOENT") return { text: null, version: ABSENT };
+    throw error;
+  }
+}
+var saving = /* @__PURE__ */ new Map();
+function saveEditable(path, text, expected) {
+  const next = (saving.get(path) ?? Promise.resolve()).catch(() => {
+  }).then(() => saveNow(path, text, expected));
+  saving.set(path, next);
+  void next.finally(() => {
+    if (saving.get(path) === next) saving.delete(path);
+  }).catch(() => {
+  });
+  return next;
+}
+async function saveNow(path, text, expected) {
+  const current = await readEditable(path);
+  if (current.version !== expected) return { saved: false, ...current };
+  const normalised = text.endsWith("\n") ? text : `${text}
+`;
+  const temp = tempPathFor(path);
+  await writeFile(temp, normalised, "utf8");
+  await rename(temp, path);
+  return { saved: true, version: versionOf(normalised) };
+}
+var FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---[ \t]*(\r?\n|$)/;
+function oneLine(value) {
+  return (value ?? "").replace(/\s*\r?\n\s*/g, " ").trim();
+}
+function setFocusFields(text, fields, template) {
+  const source = text ?? template;
+  const wanted = { objective: oneLine(fields.objective), blocker: oneLine(fields.blocker) };
+  const line = (key) => wanted[key] === "" ? `${key}:` : `${key}: ${wanted[key]}`;
+  const match = FRONTMATTER.exec(source);
+  if (!match) return `---
+${line("objective")}
+${line("blocker")}
+---
+
+${source}`;
+  const seen = /* @__PURE__ */ new Set();
+  const lines = (match[1] ?? "").split(/\r?\n/).map((existing) => {
+    const key = existing.slice(0, existing.indexOf(":")).trim().toLowerCase();
+    if (existing.includes(":") && (key === "objective" || key === "blocker")) {
+      seen.add(key);
+      return line(key);
+    }
+    return existing;
+  });
+  for (const key of ["objective", "blocker"]) {
+    if (!seen.has(key)) lines.push(line(key));
+  }
+  return `---
+${lines.join("\n")}
+---${match[2] ?? "\n"}${source.slice(match[0].length)}`;
+}
+
+// src/board.ts
+import { readFile as readFile2 } from "node:fs/promises";
+
+// src/failure.ts
+var MAX_DETAIL = 4e3;
+function extend(streak, at = Date.now()) {
+  return streak ? { since: streak.since, attempts: streak.attempts + 1 } : { since: at, attempts: 1 };
+}
+function toReadFailure(failure, streak, retryAt, retrying) {
+  return {
+    message: failure.message,
+    detail: failure.detail,
+    since: new Date(streak?.since ?? Date.now()).toISOString(),
+    attempts: streak?.attempts ?? 1,
+    retryAt: retrying || retryAt === null ? null : new Date(retryAt).toISOString(),
+    retrying
+  };
+}
+function errorDetail(err) {
+  const parts = [];
+  const own = err?.detail;
+  if (typeof own === "string" && own.trim() !== "") parts.push(own.trim());
+  let cause = err?.cause;
+  for (let depth = 0; cause !== void 0 && cause !== null && depth < 5; depth++) {
+    parts.push(`caused by ${describe(cause)}`);
+    cause = cause.cause;
+  }
+  return clip(parts.join("\n"));
+}
+function unexpectedDetail(err) {
+  const head = err instanceof Error ? err.stack ?? `${err.name}: ${err.message}` : String(err);
+  const rest = errorDetail(err);
+  return clip(rest ? `${head}
+${rest}` : head);
+}
+var FACTS = ["code", "syscall", "hostname", "address", "port"];
+function describe(value) {
+  if (!(value instanceof Error)) return String(value);
+  const record = value;
+  const facts = FACTS.flatMap((key) => {
+    const fact = record[key];
+    return typeof fact === "string" || typeof fact === "number" ? [`${key} ${fact}`] : [];
+  });
+  let line = `${value.name}: ${value.message}${facts.length > 0 ? ` (${facts.join(", ")})` : ""}`;
+  if (value instanceof AggregateError) line += value.errors.map((error) => `
+  - ${describe(error)}`).join("");
+  return line;
+}
+function clip(text) {
+  return text.length > MAX_DETAIL ? `${text.slice(0, MAX_DETAIL)}
+\u2026` : text;
+}
+function unreachable(err, host) {
+  const error = err;
+  if (error?.name === "TimeoutError") return `${host} did not answer in time`;
+  if (error?.name === "AbortError") return `the request to ${host} was cancelled`;
+  const cause = error?.cause;
+  const code = typeof cause?.code === "string" ? cause.code : firstCode(cause?.errors);
+  const why = code ? reasonFor(code) : null;
+  const fallback = typeof cause?.message === "string" && cause.message ? cause.message : String(error?.message ?? err);
+  return `couldn't reach ${host} (${why ?? fallback})`;
+}
+function firstCode(errors) {
+  if (!Array.isArray(errors)) return void 0;
+  const code = errors[0]?.code;
+  return typeof code === "string" ? code : void 0;
+}
+function reasonFor(code) {
+  switch (code) {
+    case "ENOTFOUND":
+    case "EAI_AGAIN":
+    case "EAI_NONAME":
+      return "the DNS lookup failed \u2014 is this machine online?";
+    case "ENETUNREACH":
+    case "ENETDOWN":
+    case "EHOSTUNREACH":
+    case "EHOSTDOWN":
+      return "no network route to it \u2014 is this machine online?";
+    case "ETIMEDOUT":
+    case "UND_ERR_CONNECT_TIMEOUT":
+      return "the connection timed out";
+    case "ECONNREFUSED":
+      return "the connection was refused";
+    case "ECONNRESET":
+    case "EPIPE":
+    case "UND_ERR_SOCKET":
+      return "the connection was cut off";
+  }
+  if (/CERT|SELF_SIGNED|UNABLE_TO_(GET|VERIFY)|ERR_TLS/.test(code)) {
+    return `its certificate was refused, ${code} \u2014 a proxy in the way?`;
+  }
+  return null;
+}
+
+// src/github.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+var GH_TIMEOUT_MS = 15e3;
+var FETCH_TIMEOUT_MS = 3e4;
+var GRAPHQL_URL = "https://api.github.com/graphql";
+var PAGE_SIZE = 25;
+var MAX_PAGES = 12;
+var GH_ENV = { ...process.env, GH_PROMPT_DISABLED: "1", GH_NO_UPDATE_NOTIFIER: "1", NO_COLOR: "1" };
+var GhMissingError = class extends Error {
+  constructor(ghPath) {
+    super(`could not run \`${ghPath}\` \u2014 install the GitHub CLI or set DAILY_FOCUS_GH to its path`);
+    this.name = "GhMissingError";
+  }
+};
+var GhAuthError = class extends Error {
+  detail;
+  constructor(message, detail = "") {
+    super(message);
+    this.name = "GhAuthError";
+    this.detail = detail;
+  }
+};
+async function gh(ghPath, args) {
+  try {
+    const { stdout, stderr } = await run(ghPath, args, { env: GH_ENV, timeout: GH_TIMEOUT_MS, maxBuffer: 1 << 20 });
+    return { stdout, stderr, code: 0 };
+  } catch (err) {
+    const failure = err;
+    if (failure.code === "ENOENT" || failure.code === "EACCES") throw new GhMissingError(ghPath);
+    const stderr = failure.killed || failure.signal ? `gh did not answer within ${GH_TIMEOUT_MS / 1e3}s \u2014 a keychain prompt or a slow network?` : failure.stderr || failure.message;
+    return { stdout: failure.stdout ?? "", stderr, code: typeof failure.code === "number" ? failure.code : 1 };
+  }
+}
+async function listGhAccounts(ghPath) {
+  const { stdout } = await gh(ghPath, ["auth", "status", "--hostname", "github.com", "--json", "hosts"]);
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return [];
+  }
+  const hosts = parsed?.hosts;
+  const entries = hosts?.["github.com"];
+  if (!Array.isArray(entries)) return [];
+  const accounts = [];
+  for (const entry of entries) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const { login, active } = entry;
+    if (typeof login !== "string" || login === "") continue;
+    accounts.push({ login, active: active === true });
+  }
+  return accounts;
+}
+async function ghToken(ghPath, login) {
+  const args = ["auth", "token", "--hostname", "github.com"];
+  if (login) args.push("--user", login);
+  const { stdout, stderr, code } = await gh(ghPath, args);
+  const token = stdout.trim();
+  if (code !== 0 || token === "") {
+    const lines = stderr.trim().split("\n");
+    const detail = lines[0] ?? "";
+    throw new GhAuthError(
+      login ? `gh has no login for ${login} on this machine (${detail || "no token"}) \u2014 run \`gh auth login\` as that account` : `gh is not logged in to github.com (${detail || "no token"}) \u2014 run \`gh auth login\``,
+      // The message quotes the first line; the rest is only worth sending when there is one.
+      lines.length > 1 ? stderr.trim() : ""
+    );
+  }
+  return token;
+}
+var GitHubRequestError = class extends Error {
+  status;
+  detail;
+  constructor(message, status = null, { cause, detail = "" } = {}) {
+    super(message, cause === void 0 ? void 0 : { cause });
+    this.name = "GitHubRequestError";
+    this.status = status;
+    this.detail = detail;
+  }
+};
+function isSamlError(error) {
+  if (error.extensions?.saml_failure === true) return true;
+  return /SAML enforcement/i.test(error.message);
+}
+async function graphql(token, query, variables, signal) {
+  const timeout = AbortSignal.timeout(FETCH_TIMEOUT_MS);
+  const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
+  let res;
+  try {
+    res = await fetch(GRAPHQL_URL, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json",
+        accept: "application/vnd.github+json",
+        "user-agent": "daily-focus"
+      },
+      body: JSON.stringify({ query, variables }),
+      signal: combined
+    });
+  } catch (err) {
+    throw new GitHubRequestError(unreachable(err, new URL(GRAPHQL_URL).host), null, { cause: err });
+  }
+  const remaining = Number(res.headers.get("x-ratelimit-remaining"));
+  const rateLimitRemaining = Number.isFinite(remaining) && res.headers.has("x-ratelimit-remaining") ? remaining : null;
+  if (res.status === 401) throw new GitHubRequestError("GitHub rejected the token (401) \u2014 run `gh auth login` again", 401);
+  if (!res.ok) {
+    const reply = await res.text().catch(() => "");
+    const text = reply.slice(0, 200);
+    const id = res.headers.get("x-github-request-id");
+    const detail = [id ? `x-github-request-id: ${id}` : "", reply.length > text.length ? reply.trim() : ""].filter(Boolean).join("\n\n");
+    throw new GitHubRequestError(`GitHub answered ${res.status}${text ? `: ${text}` : ""}`, res.status, { detail });
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch (err) {
+    throw new GitHubRequestError(`GitHub returned unreadable JSON: ${err.message}`, res.status, { cause: err });
+  }
+  return { data: body.data ?? null, errors: body.errors ?? [], rateLimitRemaining };
+}
+function buildSearchQuery(scope) {
+  return ["is:pr", "is:open", "archived:false", "author:@me", ...scope].join(" ");
+}
+var CONTEXT_PAGE_SIZE = 100;
+var MAX_CONTEXT_PAGES = 16;
+var MAX_CONTEXT_REQUESTS = 200;
+var CHECKS_BATCH_SIZE = 6;
+var CHECK_CONTEXTS = `
+  totalCount
+  pageInfo { hasNextPage endCursor }
+  nodes {
+    __typename
+    ... on CheckRun {
+      databaseId name status conclusion detailsUrl startedAt completedAt
+      checkSuite { app { id } workflowRun { databaseId runNumber runAttempt workflow { id } } }
+    }
+    ... on StatusContext { context state targetUrl createdAt }
+  }`;
+var SEARCH_QUERY = `
+query($q: String!, $first: Int!, $after: String) {
+  search(query: $q, type: ISSUE, first: $first, after: $after) {
+    pageInfo { hasNextPage endCursor }
+    nodes {
+      ... on PullRequest {
+        id
+        number
+        title
+        url
+        isDraft
+        createdAt
+        updatedAt
+        headRefName
+        baseRefName
+        repository { nameWithOwner }
+        reviewDecision
+        mergeable
+        autoMergeRequest { enabledAt }
+        commits(last: 1) { nodes { commit { oid committedDate } } }
+        readyEvents: timelineItems(itemTypes: [READY_FOR_REVIEW_EVENT], last: 1) {
+          nodes { ... on ReadyForReviewEvent { createdAt } }
+        }
+        reviewRequests(first: 20) {
+          nodes { requestedReviewer { __typename ... on User { login } ... on Team { slug } } }
+        }
+        reviews(last: 50) {
+          nodes { author { __typename login } state submittedAt }
+        }
+        comments(last: 50) {
+          nodes { author { __typename login } createdAt }
+        }
+      }
+    }
+  }
+}`;
+var MERGE_STATE_QUERY = `
+query($ids: [ID!]!) {
+  nodes(ids: $ids) {
+    ... on PullRequest { id mergeStateStatus }
+  }
+}`;
+var CHECKS_QUERY = `
+query($ids: [ID!]!) {
+  nodes(ids: $ids) {
+    ... on PullRequest {
+      id
+      commits(last: 1) {
+        nodes {
+          commit {
+            oid
+            statusCheckRollup {
+              state
+              contexts(first: ${CONTEXT_PAGE_SIZE}) { ${CHECK_CONTEXTS} }
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
+async function fetchChecks(token, ids, signal) {
+  const heads = /* @__PURE__ */ new Map();
+  if (ids.length === 0) return { heads, rateLimitRemaining: null };
+  const result = await graphql(token, CHECKS_QUERY, { ids }, signal);
+  const fatal = result.errors.filter((error) => !isSamlError(error));
+  if (result.data?.nodes === void 0 && fatal.length > 0) {
+    throw new GitHubRequestError(`GitHub wouldn't list the checks: ${fatal.map((error) => error.message).join("; ")}`);
+  }
+  for (const node of result.data?.nodes ?? []) {
+    if (!node || typeof node.id !== "string" || node.id === "") continue;
+    const head = node.commits?.nodes?.[0]?.commit;
+    heads.set(node.id, { oid: head?.oid ?? null, rollup: head?.statusCheckRollup ?? null });
+  }
+  return { heads, rateLimitRemaining: result.rateLimitRemaining };
+}
+function applyChecks(pull, rollup) {
+  const ci = summarizeChecks(rollup);
+  pull.checks = ci.checks;
+  pull.failingChecks = ci.failing;
+  pull.pendingChecks = ci.pending;
+  pull.cancelledChecks = ci.cancelled;
+}
+function mergeStatesFromNodes(nodes) {
+  const states = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (!node || typeof node.id !== "string" || node.id === "") continue;
+    states.set(node.id, toMergeState(node.mergeStateStatus));
+  }
+  return states;
+}
+function isBot(actor) {
+  if (!actor) return true;
+  if (actor.__typename === "Bot") return true;
+  return typeof actor.login === "string" && actor.login.endsWith("[bot]");
+}
+function sameLogin(a, b) {
+  return typeof a === "string" && a.toLowerCase() === b.toLowerCase();
+}
+function toCheckState(state) {
+  switch (state) {
+    case "SUCCESS":
+      return "success";
+    case "FAILURE":
+    case "ERROR":
+      return "failure";
+    case "PENDING":
+    case "EXPECTED":
+      return "pending";
+    default:
+      return null;
+  }
+}
+var CHECK_RANK = { success: 1, pending: 2, failure: 3 };
+function worse(a, b) {
+  if (a === null) return b;
+  if (b === null) return a;
+  return CHECK_RANK[b] > CHECK_RANK[a] ? b : a;
+}
+var FAILED_CONCLUSIONS = /* @__PURE__ */ new Set(["FAILURE", "ERROR", "TIMED_OUT", "ACTION_REQUIRED", "STARTUP_FAILURE"]);
+var PASSED_CONCLUSIONS = /* @__PURE__ */ new Set(["SUCCESS", "NEUTRAL", "SKIPPED"]);
+function safeUrl(url) {
+  return typeof url === "string" && /^https?:\/\//i.test(url) ? url : null;
+}
+function rollupTruncated(rollup) {
+  const more = rollup.contexts?.pageInfo?.hasNextPage;
+  if (typeof more === "boolean") return more;
+  const total = rollup.contexts?.totalCount;
+  return typeof total === "number" && total > (rollup.contexts?.nodes?.length ?? 0);
+}
+function checkSlot(node) {
+  if (node.__typename === "StatusContext") return `status\0${node.context ?? ""}`;
+  const workflow = node.checkSuite?.workflowRun?.workflow?.id;
+  if (typeof workflow === "string" && workflow !== "") return `workflow\0${workflow}\0${node.name ?? ""}`;
+  const app = node.checkSuite?.app?.id;
+  if (typeof app === "string" && app !== "") return `app\0${app}\0${node.name ?? ""}`;
+  return `check\0${node.name ?? ""}`;
+}
+function checkGeneration(node) {
+  const run6 = node.checkSuite?.workflowRun;
+  const sequence = run6?.runNumber ?? run6?.databaseId;
+  if (typeof sequence === "number") return [sequence, run6?.runAttempt ?? 0];
+  const at = node.completedAt ?? node.startedAt ?? node.createdAt ?? null;
+  const time = at ? Date.parse(at) : Number.NaN;
+  return [Number.isFinite(time) ? time : 0, 0];
+}
+function latestChecks(nodes) {
+  const slots = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const node of nodes) {
+    if (!node) continue;
+    const slot = checkSlot(node);
+    const generation = checkGeneration(node);
+    const held = slots.get(slot);
+    if (!held) {
+      slots.set(slot, { generation, nodes: [node] });
+      order.push(slot);
+      continue;
+    }
+    if (generation[0] === held.generation[0] && generation[1] === held.generation[1]) {
+      held.nodes.push(node);
+    } else if (generation[0] > held.generation[0] || generation[0] === held.generation[0] && generation[1] > held.generation[1]) {
+      slots.set(slot, { generation, nodes: [node] });
+    }
+  }
+  return order.flatMap((slot) => slots.get(slot)?.nodes ?? []);
+}
+function summarizeChecks(rollup) {
+  if (!rollup) return { checks: null, failing: [], pending: [], cancelled: [] };
+  const failing = [];
+  const pending = [];
+  const cancelled = [];
+  const read = rollup.contexts?.nodes ?? [];
+  const nodes = latestChecks(read);
+  let derived = null;
+  for (const node of nodes) {
+    if (node.__typename === "CheckRun") {
+      const name = node.name ?? "unnamed check";
+      const waiting = { name, kind: "check-run", detailsUrl: safeUrl(node.detailsUrl) };
+      if (typeof node.databaseId === "number") waiting.checkRunId = node.databaseId;
+      if (node.status !== "COMPLETED" || !node.conclusion) {
+        pending.push(waiting);
+        derived = worse(derived, "pending");
+      } else if (node.conclusion === "CANCELLED") {
+        cancelled.push(waiting);
+      } else if (FAILED_CONCLUSIONS.has(node.conclusion)) {
+        failing.push(name);
+        derived = worse(derived, "failure");
+      } else if (PASSED_CONCLUSIONS.has(node.conclusion)) {
+        derived = worse(derived, "success");
+      } else {
+        pending.push(waiting);
+        derived = worse(derived, "pending");
+      }
+    } else if (node.__typename === "StatusContext") {
+      const name = node.context ?? "unnamed status";
+      if (node.state === "FAILURE" || node.state === "ERROR") {
+        failing.push(name);
+        derived = worse(derived, "failure");
+      } else if (node.state === "SUCCESS") {
+        derived = worse(derived, "success");
+      } else {
+        pending.push({ name, kind: "status-context", detailsUrl: safeUrl(node.targetUrl) });
+        derived = worse(derived, "pending");
+      }
+    }
+  }
+  const unread = read.length === 0 || rollupTruncated(rollup);
+  return { checks: unread ? worse(derived, toCheckState(rollup.state)) : derived, failing, pending, cancelled };
+}
+function toMergeable(state) {
+  return state === "MERGEABLE" || state === "CONFLICTING" ? state : "UNKNOWN";
+}
+var MERGE_STATES = [
+  "BEHIND",
+  "BLOCKED",
+  "CLEAN",
+  "DIRTY",
+  "HAS_HOOKS",
+  "UNKNOWN",
+  "UNSTABLE"
+];
+function toMergeState(state) {
+  if (typeof state !== "string" || state === "") return null;
+  return MERGE_STATES.includes(state) ? state : "UNKNOWN";
+}
+function toDecision(state) {
+  return state === "APPROVED" || state === "CHANGES_REQUESTED" || state === "REVIEW_REQUIRED" ? state : null;
+}
+function normalizePullRequest(raw, account) {
+  const repo = raw.repository?.nameWithOwner;
+  if (typeof raw.number !== "number" || typeof repo !== "string" || typeof raw.title !== "string") return null;
+  if (typeof raw.url !== "string" || typeof raw.createdAt !== "string") return null;
+  const head = raw.commits?.nodes?.[0]?.commit;
+  const ci = summarizeChecks(head?.statusCheckRollup);
+  const readyEvent = raw.readyEvents?.nodes?.find((node) => node?.createdAt)?.createdAt;
+  const readyAt = raw.isDraft ? raw.createdAt : readyEvent ?? raw.createdAt;
+  let lastByYou = raw.createdAt;
+  lastByYou = laterISO(lastByYou, readyAt);
+  lastByYou = laterISO(lastByYou, head?.committedDate);
+  let lastByOthers = null;
+  const consider = (actor, at, kind) => {
+    if (!at || isBot(actor)) return;
+    if (sameLogin(actor?.login, account)) {
+      lastByYou = laterISO(lastByYou, at);
+      return;
+    }
+    if (!lastByOthers || at > lastByOthers.at) lastByOthers = { at, login: actor?.login ?? "someone", kind };
+  };
+  const latestReview = /* @__PURE__ */ new Map();
+  for (const review of raw.reviews?.nodes ?? []) {
+    const at = review.submittedAt ?? null;
+    consider(review.author, at, "review");
+    if (!at || isBot(review.author) || sameLogin(review.author?.login, account)) continue;
+    const login = review.author?.login;
+    if (!login || typeof review.state !== "string") continue;
+    const verdict = review.state === "APPROVED" || review.state === "CHANGES_REQUESTED" || review.state === "DISMISSED";
+    if (verdict || !latestReview.has(login)) latestReview.set(login, { login, state: review.state, at });
+  }
+  for (const comment of raw.comments?.nodes ?? []) {
+    consider(comment.author, comment.createdAt ?? null, "comment");
+  }
+  const requestedReviewers = [];
+  for (const request of raw.reviewRequests?.nodes ?? []) {
+    const who = request.requestedReviewer;
+    const name = who?.login ?? who?.slug;
+    if (typeof name === "string" && name !== "") requestedReviewers.push(name);
+  }
+  return {
+    id: `github:pr:${repo}#${raw.number}`,
+    account,
+    repo,
+    number: raw.number,
+    title: raw.title,
+    url: raw.url,
+    isDraft: raw.isDraft === true,
+    createdAt: raw.createdAt,
+    readyAt,
+    updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : raw.createdAt,
+    headRef: typeof raw.headRefName === "string" ? raw.headRefName : "",
+    baseRef: typeof raw.baseRefName === "string" ? raw.baseRefName : "",
+    reviewDecision: toDecision(raw.reviewDecision),
+    checks: ci.checks,
+    failingChecks: ci.failing,
+    mergeable: toMergeable(raw.mergeable),
+    mergeStateStatus: toMergeState(raw.mergeStateStatus),
+    pendingChecks: ci.pending,
+    cancelledChecks: ci.cancelled,
+    autoMerge: Boolean(raw.autoMergeRequest?.enabledAt),
+    requestedReviewers,
+    reviews: [...latestReview.values()].filter((review) => review.state !== "DISMISSED"),
+    lastActivityByYou: lastByYou,
+    lastActivityByOthers: lastByOthers
+  };
+}
+function buildProbeQuery(scope) {
+  const orgs = scope.filter((qualifier) => qualifier.startsWith("org:")).map((qualifier) => qualifier.slice("org:".length));
+  const fields = orgs.map(
+    (org, i) => `o${i}: repositoryOwner(login: ${JSON.stringify(org)}) { login repositories(first: 1) { totalCount } }`
+  );
+  return { query: `{ viewer { login } ${fields.join(" ")} }`, orgs };
+}
+function buildRemainingChecksQuery(batch) {
+  const fields = batch.map((walk, i) => {
+    const after = walk.cursor === null ? "null" : JSON.stringify(walk.cursor);
+    return `w${i}: node(id: ${JSON.stringify(walk.id)}) {
+    ... on PullRequest {
+      commits(last: 1) {
+        nodes {
+          commit {
+            oid
+            statusCheckRollup { contexts(first: ${CONTEXT_PAGE_SIZE}, after: ${after}) { ${CHECK_CONTEXTS} } }
+          }
+        }
+      }
+    }
+  }`;
+  });
+  return `{
+  ${fields.join("\n  ")}
+}`;
+}
+async function walkRemainingChecks(token, walks, budget, signal) {
+  let requests = 0;
+  let rateLimitRemaining = null;
+  let failure = null;
+  let exhausted = false;
+  for (let round = 0; round < MAX_CONTEXT_PAGES && !exhausted; round++) {
+    const active = walks.filter((walk) => !walk.done);
+    if (active.length === 0) break;
+    for (let from = 0; from < active.length; from += CHECKS_BATCH_SIZE) {
+      if (requests >= budget) {
+        exhausted = true;
+        break;
+      }
+      const batch = active.slice(from, from + CHECKS_BATCH_SIZE);
+      requests++;
+      let result;
+      try {
+        result = await graphql(token, buildRemainingChecksQuery(batch), {}, signal);
+      } catch (err) {
+        failure ??= err.message;
+        for (const walk of batch) walk.done = true;
+        continue;
+      }
+      rateLimitRemaining = result.rateLimitRemaining ?? rateLimitRemaining;
+      const fatal = result.errors.filter((error) => !isSamlError(error));
+      if (result.data === null && fatal.length > 0) {
+        failure ??= fatal.map((error) => error.message).join("; ");
+        for (const walk of batch) walk.done = true;
+        continue;
+      }
+      batch.forEach((walk, i) => {
+        const head = result.data?.[`w${i}`]?.commits?.nodes?.[0]?.commit;
+        if (walk.oid && head?.oid && head.oid !== walk.oid) {
+          walk.stale = true;
+          walk.done = true;
+          return;
+        }
+        const contexts = head?.statusCheckRollup?.contexts;
+        if (!contexts) {
+          walk.done = true;
+          return;
+        }
+        if (typeof contexts.totalCount === "number") walk.totalCount = contexts.totalCount;
+        for (const node of contexts.nodes ?? []) if (node) walk.nodes.push(node);
+        if (contexts.pageInfo?.hasNextPage === true && contexts.pageInfo.endCursor) {
+          walk.cursor = contexts.pageInfo.endCursor;
+        } else {
+          walk.complete = true;
+          walk.done = true;
+        }
+      });
+    }
+  }
+  return { requests, rateLimitRemaining, failure, exhausted };
+}
+async function fetchMergeStates(token, ids, signal) {
+  if (ids.length === 0) return { states: /* @__PURE__ */ new Map(), rateLimitRemaining: null };
+  const result = await graphql(token, MERGE_STATE_QUERY, { ids }, signal);
+  const fatal = result.errors.filter((error) => !isSamlError(error));
+  if (result.data?.nodes === void 0 && fatal.length > 0) {
+    throw new GitHubRequestError(fatal.map((error) => error.message).join("; "));
+  }
+  return { states: mergeStatesFromNodes(result.data?.nodes ?? []), rateLimitRemaining: result.rateLimitRemaining };
+}
+async function fetchPulls(token, scope, expectedLogin, signal) {
+  const warnings = [];
+  const probe = buildProbeQuery(scope);
+  const who = await graphql(token, probe.query, {}, signal);
+  const login = who.data?.viewer?.login ?? expectedLogin ?? "unknown";
+  const orgs = {};
+  let samlWarned = false;
+  probe.orgs.forEach((org, i) => {
+    const error = who.errors.find((candidate) => candidate.path?.[0] === `o${i}`);
+    if (error && isSamlError(error)) {
+      orgs[org] = "saml";
+      samlWarned = true;
+      warnings.push(
+        `${login} can't see ${org}: the token isn't authorised for that organisation's single sign-on. Run \`gh auth refresh\` as ${login}, or authorise the GitHub CLI app for ${org} under GitHub's SSO settings.`
+      );
+    } else if (!error && who.data?.[`o${i}`] === null) {
+      orgs[org] = "not-found";
+    } else {
+      orgs[org] = "ok";
+    }
+  });
+  const pulls = [];
+  let after = null;
+  let rateLimitRemaining = who.rateLimitRemaining;
+  let mergeStateWarned = false;
+  let contextsWarned = false;
+  let contextBudgetWarned = false;
+  let contextRequests = 0;
+  for (let page = 0; page < MAX_PAGES; page++) {
+    const result = await graphql(token, SEARCH_QUERY, { q: buildSearchQuery(scope), first: PAGE_SIZE, after }, signal);
+    rateLimitRemaining = result.rateLimitRemaining ?? rateLimitRemaining;
+    const fatal = result.errors.filter((error) => !isSamlError(error));
+    if (result.data?.search === void 0 && fatal.length > 0) {
+      throw new GitHubRequestError(`GitHub search failed: ${fatal.map((error) => error.message).join("; ")}`);
+    }
+    if (!samlWarned && result.errors.some(isSamlError)) {
+      samlWarned = true;
+      warnings.push(`${login}: some results were withheld by an organisation's single sign-on policy.`);
+    }
+    const found = /* @__PURE__ */ new Map();
+    for (const node of result.data?.search?.nodes ?? []) {
+      if (!node) continue;
+      const pull = normalizePullRequest(node, login);
+      if (!pull) continue;
+      if (typeof node.id !== "string" || node.id === "") continue;
+      pulls.push(pull);
+      found.set(node.id, pull);
+    }
+    try {
+      const states = await fetchMergeStates(token, [...found.keys()], signal);
+      rateLimitRemaining = states.rateLimitRemaining ?? rateLimitRemaining;
+      for (const [nodeId, pull] of found) {
+        if (states.states.has(nodeId)) pull.mergeStateStatus = states.states.get(nodeId) ?? null;
+      }
+    } catch (err) {
+      if (!mergeStateWarned) {
+        mergeStateWarned = true;
+        warnings.push(
+          `${login}: GitHub wouldn't say whether these pull requests can be merged (${err.message}). Ready to merge falls back to the reviews and checks until the next poll.`
+        );
+      }
+    }
+    const partial = [];
+    const ids = [...found.keys()];
+    for (let from = 0; from < ids.length; from += CHECKS_BATCH_SIZE) {
+      const batch = ids.slice(from, from + CHECKS_BATCH_SIZE);
+      const checks = await fetchChecks(token, batch, signal);
+      rateLimitRemaining = checks.rateLimitRemaining ?? rateLimitRemaining;
+      for (const [nodeId, head] of checks.heads) {
+        const pull = found.get(nodeId);
+        if (!pull) continue;
+        applyChecks(pull, head.rollup);
+        if (head.rollup && rollupTruncated(head.rollup)) {
+          partial.push({ id: nodeId, pull, oid: head.oid, rollup: head.rollup });
+        }
+      }
+    }
+    if (partial.length > 0) {
+      const walks = partial.map((entry) => ({
+        ...entry,
+        nodes: [],
+        cursor: entry.rollup.contexts?.pageInfo?.endCursor ?? null,
+        totalCount: entry.rollup.contexts?.totalCount,
+        complete: false,
+        stale: false,
+        done: false
+      }));
+      const walked = await walkRemainingChecks(token, walks, MAX_CONTEXT_REQUESTS - contextRequests, signal);
+      contextRequests += walked.requests;
+      rateLimitRemaining = walked.rateLimitRemaining ?? rateLimitRemaining;
+      for (const walk of walks) {
+        if (walk.stale || walk.nodes.length === 0) continue;
+        applyChecks(walk.pull, {
+          state: walk.rollup.state,
+          contexts: {
+            totalCount: walk.totalCount,
+            // What the walk found out, said in the one field that outranks the
+            // count: complete means the checks themselves have the last word.
+            pageInfo: { hasNextPage: !walk.complete },
+            nodes: [...walk.rollup.contexts?.nodes ?? [], ...walk.nodes]
+          }
+        });
+      }
+      if (walked.failure && !contextsWarned) {
+        contextsWarned = true;
+        warnings.push(
+          `${login}: GitHub wouldn't list all the checks on some pull requests (${walked.failure}). Their CI state comes from GitHub's own summary until the next poll.`
+        );
+      }
+      if (walked.exhausted && !contextBudgetWarned) {
+        contextBudgetWarned = true;
+        warnings.push(
+          `${login}: some pull requests have more checks than the board reads in one poll, so their CI state comes from GitHub's own summary rather than the checks themselves.`
+        );
+      }
+    }
+    const pageInfo = result.data?.search?.pageInfo;
+    if (!pageInfo?.hasNextPage || !pageInfo.endCursor) break;
+    after = pageInfo.endCursor;
+    if (page === MAX_PAGES - 1) {
+      warnings.push(`${login} has more open pull requests than the board reads (${MAX_PAGES * PAGE_SIZE}); narrow the scope.`);
+    }
+  }
+  return { login, pulls, warnings, orgs, rateLimitRemaining };
+}
+
+// src/prs.ts
+var NUDGE_AFTER_MS = 24 * 36e5;
+var STALE_DRAFT_AFTER_MS = 14 * 864e5;
+var COURT_ORDER = ["you", "ready", "reviewers", "gate", "blocked", "checks", "draft"];
+function courtOrder(court) {
+  return COURT_ORDER.indexOf(court);
+}
+function ms(iso) {
+  const parsed = parseISO(iso);
+  return parsed ? parsed.getTime() : null;
+}
+function deriveDecision(pr) {
+  if (pr.reviewDecision) return pr.reviewDecision;
+  if (pr.reviews.some((review) => review.state === "CHANGES_REQUESTED")) return "CHANGES_REQUESTED";
+  if (pr.reviews.some((review) => review.state === "APPROVED")) return "APPROVED";
+  return null;
+}
+function matchMergeGates(pr, gates) {
+  if (gates.length === 0) return [];
+  return (pr.pendingChecks ?? []).filter((check) => gates.includes(check.name));
+}
+function newest(pr, state) {
+  return pr.reviews.filter((review) => review.state === state).sort((a, b) => a.at < b.at ? 1 : -1)[0];
+}
+function judge(pr, now, lastNoteAt, gates = []) {
+  const decision = deriveDecision(pr);
+  const you = pr.lastActivityByYou ?? null;
+  const others = pr.lastActivityByOthers ?? null;
+  const mergeState = pr.mergeStateStatus ?? null;
+  if (pr.isDraft) {
+    const touched = you ?? pr.createdAt;
+    const idle = now.getTime() - (ms(touched) ?? now.getTime());
+    return { court: "draft", decision, reasons: [], stale: idle >= STALE_DRAFT_AFTER_MS, nudge: false, since: touched };
+  }
+  const reasons = [];
+  if (decision === "CHANGES_REQUESTED") {
+    const request = newest(pr, "CHANGES_REQUESTED");
+    reasons.push({ kind: "changes-requested", login: request?.login, at: request?.at });
+  }
+  if (pr.checks === "failure") reasons.push({ kind: "ci-failing" });
+  if (pr.mergeable === "CONFLICTING" || mergeState === "DIRTY") reasons.push({ kind: "conflicts" });
+  if (mergeState === "BEHIND") reasons.push({ kind: "behind" });
+  const theirMove = others !== null && (you === null || others.at > you);
+  const approval = newest(pr, "APPROVED");
+  const afterApproval = others !== null && approval !== void 0 && others.at > approval.at;
+  const approved = decision === "APPROVED" && !afterApproval;
+  if (theirMove && others && !approved) {
+    reasons.push({ kind: "activity", login: others.login, at: others.at, activity: others.kind });
+  }
+  if (reasons.length > 0) {
+    const since = theirMove && others ? others.at : pr.updatedAt;
+    return { court: "you", decision, reasons, stale: false, nudge: false, since };
+  }
+  const waitingSince = laterISO(pr.readyAt, you) ?? pr.createdAt;
+  const settled = (court, reason) => ({
+    court,
+    decision,
+    reasons: [reason],
+    stale: false,
+    nudge: false,
+    since: waitingSince
+  });
+  if (decision !== "REVIEW_REQUIRED") {
+    const gate = matchMergeGates(pr, gates);
+    if (gate.length > 0) return settled("gate", { kind: "merge-gate", checks: gate });
+    const pending = pr.pendingChecks ?? [];
+    const running = { kind: "checks-pending" };
+    if (pending.length > 0) running.checks = pending;
+    if (mergeState === "BLOCKED" && pending.length === 0) {
+      return settled("blocked", { kind: "merge-blocked" });
+    }
+    if (mergeState === "BLOCKED" || mergeState === "UNSTABLE") return settled("checks", running);
+    if (mergeState === "UNKNOWN") return settled("checks", { kind: "mergeability-unknown" });
+    if (approved) {
+      if (mergeState === "CLEAN" || mergeState === "HAS_HOOKS") {
+        return { court: "ready", decision, reasons: [], stale: false, nudge: false, since: approval?.at ?? pr.updatedAt };
+      }
+      if (mergeState === null) {
+        const unfinished = pr.checks === "pending" || pending.length > 0;
+        if (!unfinished) {
+          return { court: "ready", decision, reasons: [], stale: false, nudge: false, since: approval?.at ?? pr.updatedAt };
+        }
+        return settled("checks", running);
+      }
+    }
+  }
+  const quietSince = laterISO(waitingSince, lastNoteAt) ?? waitingSince;
+  const waited = now.getTime() - (ms(quietSince) ?? now.getTime());
+  return { court: "reviewers", decision, reasons, stale: false, nudge: waited >= NUDGE_AFTER_MS, since: waitingSince };
+}
+function resolveBoard(pulls, actions, now, gates = []) {
+  const folded = foldActionLog(actions, now);
+  const rows = pulls.map((pr) => {
+    const log = folded.get(canonicalId(pr.id));
+    const notes = log?.notes ?? [];
+    const lastNoteAt = notes.length > 0 ? notes[notes.length - 1].at : null;
+    const verdict = judge(pr, now, lastNoteAt, gates);
+    const row = { ...pr, ...verdict, status: log?.status === "snoozed" ? "snoozed" : "open", notes };
+    if (row.status === "snoozed" && log?.snoozedUntil) row.snoozedUntil = log.snoozedUntil;
+    return row;
+  });
+  return rows.sort((a, b) => {
+    const court = courtOrder(a.court) - courtOrder(b.court);
+    if (court !== 0) return court;
+    if (a.since !== b.since) return a.since < b.since ? -1 : 1;
+    return a.id < b.id ? -1 : 1;
+  });
+}
+function countBoard(rows) {
+  const counts = {
+    you: 0,
+    ready: 0,
+    reviewers: 0,
+    gate: 0,
+    blocked: 0,
+    checks: 0,
+    draft: 0,
+    parked: 0
+  };
+  for (const row of rows) {
+    if (row.status === "snoozed") counts.parked++;
+    else counts[row.court]++;
+  }
+  return counts;
+}
+
+// src/board.ts
+var MAX_BACKOFF_MS = 30 * 6e4;
+var RATE_LIMIT_FLOOR = 100;
+var realDeps = { listAccounts: listGhAccounts, token: ghToken, fetch: fetchPulls };
+var Board = class {
+  #config;
+  #deps;
+  #onChange;
+  /** The last successful fetch, as on disk. */
+  #file = null;
+  /**
+   * What the last attempt found out, successful or not. Replaced when an attempt
+   * ends rather than cleared when one starts, so a banner stays where it is
+   * through a poll — and one somebody opened to press Retry stays open to show
+   * how the retry went.
+   */
+  #accounts = [];
+  #accountDetails = /* @__PURE__ */ new Map();
+  #attemptWarnings = [];
+  /** Why nothing can be polled at all right now, when that's the case. */
+  #reason = null;
+  /** Polls in a row that read nothing at all, which also spaces the next one out. */
+  #streak = null;
+  /** Each failing account's own run, by lowercased login: one can fail while the other answers. */
+  #accountStreaks = /* @__PURE__ */ new Map();
+  #fetching = null;
+  #timer = null;
+  #audience = 0;
+  #stopped = false;
+  /** When the last poll finished, success or not. Zero until one has. */
+  #lastPollAt = 0;
+  /** When the rate limit says to leave GitHub alone until. */
+  #holdUntil = 0;
+  #abort = new AbortController();
+  constructor(config, onChange, deps = realDeps) {
+    this.#config = config;
+    this.#deps = deps;
+    this.#onChange = onChange;
+  }
+  get enabled() {
+    return this.#config.github.enabled;
+  }
+  /** Load what the last run left on disk, then fetch once regardless of audience. */
+  async start() {
+    if (!this.enabled) return;
+    this.#file = await readPullsFile(this.#config.pullsFile);
+    await this.refresh();
+  }
+  /** Stop polling and cancel a fetch in flight, so nothing lands after close. */
+  stop() {
+    this.#stopped = true;
+    if (this.#timer) clearTimeout(this.#timer);
+    this.#timer = null;
+    this.#abort.abort();
+  }
+  /**
+   * How many browsers are watching. Polling pauses at zero, and a tab opening on
+   * a board that is already older than one interval fetches straight away rather
+   * than waiting one out.
+   */
+  setAudience(count) {
+    this.#audience = count;
+    if (count === 0) {
+      if (this.#timer) clearTimeout(this.#timer);
+      this.#timer = null;
+      return;
+    }
+    if (this.#timer || this.#fetching) return;
+    if (this.#dueIn() === 0) void this.refresh();
+    else this.#schedule();
+  }
+  /** Fetch now. Joins a fetch already in flight rather than starting a second. Never rejects. */
+  async refresh() {
+    if (!this.enabled || this.#stopped) return;
+    if (this.#fetching) return this.#fetching;
+    if (this.#timer) clearTimeout(this.#timer);
+    this.#timer = null;
+    this.#fetching = this.#poll().catch((err) => {
+      this.#reason = { message: `The board hit an unexpected error: ${err.message}`, detail: unexpectedDetail(err) };
+      this.#streak = extend(this.#streak);
+      console.error(`[daily-focus] pull request poll failed: ${err.stack ?? String(err)}`);
+    }).finally(() => {
+      this.#fetching = null;
+      this.#lastPollAt = Date.now();
+      this.#schedule();
+      this.#onChange();
+    });
+    this.#onChange();
+    return this.#fetching;
+  }
+  /** The board joined with the action log, ready to render. Never throws. */
+  view(actions, now) {
+    const warnings = this.enabled ? [...this.#attemptWarnings] : [];
+    let rows = [];
+    if (this.enabled) {
+      try {
+        rows = resolveBoard(this.#file?.pulls ?? [], actions, now, this.#config.github.mergeGateChecks);
+      } catch (err) {
+        warnings.push(`Could not judge the pull requests on file: ${err.message}`);
+      }
+    }
+    const accounts = this.#reason ? [] : this.#accounts.length > 0 ? this.#accounts : this.#file?.accounts ?? [];
+    const retrying = this.#fetching !== null;
+    const retryAt = this.#stopped ? null : Date.now() + this.#dueIn();
+    return {
+      enabled: this.enabled,
+      reason: this.enabled && this.#reason ? toReadFailure(this.#reason, this.#streak, retryAt, retrying) : null,
+      failures: this.enabled && !this.#reason ? this.#accountFailures(retryAt, retrying) : [],
+      fetchedAt: this.#file?.fetchedAt ?? null,
+      fetching: this.#fetching !== null,
+      accounts: accounts.map((account) => ({ ...account })),
+      scope: [...this.#config.github.scope],
+      warnings,
+      pollMinutes: this.#config.github.pollMinutes,
+      rows,
+      counts: countBoard(rows)
+    };
+  }
+  /**
+   * The accounts the last poll couldn't read, one failure per distinct error.
+   * Two accounts cut off by the same outage are one problem, and two banners
+   * saying so only make it look like two.
+   */
+  #accountFailures(retryAt, retrying) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const account of this.#accounts) {
+      if (account.ok || !account.error) continue;
+      groups.set(account.error, [...groups.get(account.error) ?? [], account]);
+    }
+    return [...groups].map(([error, members]) => {
+      const details = members.map((account) => this.#accountDetails.get(account.login) ?? "");
+      const detail = new Set(details).size === 1 ? details[0] : members.map((account, i) => `${account.login}:
+${details[i] || "(nothing more)"}`).join("\n\n");
+      const streaks = members.flatMap((account) => this.#accountStreaks.get(account.login.toLowerCase()) ?? []);
+      const streak = streaks.length > 0 ? { since: Math.min(...streaks.map((s) => s.since)), attempts: Math.max(...streaks.map((s) => s.attempts)) } : null;
+      const message = `${listNames(members.map((account) => account.login))}: ${error}`;
+      return toReadFailure({ message, detail }, streak, retryAt, retrying);
+    });
+  }
+  /** Milliseconds until the next poll is due, from the last one, backoff and any hold. */
+  #dueIn() {
+    const base = this.#config.github.pollMinutes * 6e4;
+    const backoff = Math.min(MAX_BACKOFF_MS, base * 2 ** (this.#streak?.attempts ?? 0));
+    const due = Math.max(this.#lastPollAt + backoff, this.#holdUntil);
+    return Math.max(0, due - Date.now());
+  }
+  #schedule() {
+    if (this.#stopped || this.#audience === 0 || this.#timer || this.#fetching) return;
+    this.#timer = setTimeout(() => {
+      this.#timer = null;
+      void this.refresh();
+    }, this.#dueIn());
+    this.#timer.unref();
+  }
+  /**
+   * Which logins to poll as, and with what.
+   *
+   * Configured accounts are each named to gh explicitly; one that gh doesn't know
+   * becomes a warning and the rest carry on. With nothing configured the active
+   * account is used, and a second account being present is worth saying, since
+   * "active" is whichever one was last switched to in a terminal.
+   */
+  async #identities(attempt) {
+    const { ghPath, accounts } = this.#config.github;
+    if (accounts.length > 0) {
+      const tokens = await Promise.allSettled(accounts.map((login) => this.#deps.token(ghPath, login)));
+      const found = [];
+      tokens.forEach((token2, i) => {
+        const login = accounts[i];
+        if (token2.status === "fulfilled") {
+          const account2 = { login, ok: true, error: null };
+          attempt.accounts.push(account2);
+          found.push({ account: account2, token: token2.value });
+        } else if (token2.reason instanceof GhMissingError) {
+          throw token2.reason;
+        } else {
+          attempt.accounts.push({ login, ok: false, error: token2.reason.message });
+          attempt.details.set(login, errorDetail(token2.reason));
+        }
+      });
+      return found;
+    }
+    const known = await this.#deps.listAccounts(ghPath);
+    const active = known.find((account2) => account2.active) ?? known[0] ?? null;
+    if (!active) {
+      throw new Error("gh is not logged in to github.com \u2014 run `gh auth login`, or set DAILY_FOCUS_GITHUB=off");
+    }
+    if (known.length > 1) {
+      attempt.warnings.push(
+        `gh holds ${known.length} github.com accounts on this machine; polling only the active one, ${active.login}. Set DAILY_FOCUS_GITHUB_ACCOUNTS to poll more than one.`
+      );
+    }
+    const token = await this.#deps.token(ghPath, null);
+    const account = { login: active.login, ok: true, error: null };
+    attempt.accounts.push(account);
+    return [{ account, token }];
+  }
+  async #poll() {
+    if (Date.now() < this.#holdUntil) {
+      const until = new Date(this.#holdUntil).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+      const notice = `Paused near GitHub's rate limit until ${until}.`;
+      if (!this.#attemptWarnings.includes(notice)) this.#attemptWarnings.push(notice);
+      return;
+    }
+    const previous = this.#file;
+    const attempt = { accounts: [], details: /* @__PURE__ */ new Map(), warnings: [] };
+    const publish = (reason) => {
+      this.#accounts = attempt.accounts;
+      this.#accountDetails = attempt.details;
+      this.#attemptWarnings = attempt.warnings;
+      this.#reason = reason;
+    };
+    let identities;
+    try {
+      identities = await this.#identities(attempt);
+    } catch (err) {
+      publish({ message: err.message, detail: errorDetail(err) });
+      this.#streak = extend(this.#streak);
+      return;
+    }
+    const pulls = [];
+    const warnings = [];
+    const visibility = /* @__PURE__ */ new Map();
+    let lowestRemaining = null;
+    const results = await Promise.allSettled(
+      identities.map(
+        (identity2) => this.#deps.fetch(identity2.token, this.#config.github.scope, identity2.account.login, this.#abort.signal)
+      )
+    );
+    results.forEach((result, i) => {
+      const { account } = identities[i];
+      if (result.status === "rejected") {
+        account.ok = false;
+        account.error = result.reason.message;
+        attempt.details.set(account.login, errorDetail(result.reason));
+        return;
+      }
+      account.login = result.value.login;
+      pulls.push(...result.value.pulls);
+      warnings.push(...result.value.warnings);
+      for (const [org, seen] of Object.entries(result.value.orgs)) {
+        visibility.set(org, [...visibility.get(org) ?? [], seen]);
+      }
+      if (result.value.rateLimitRemaining !== null) {
+        lowestRemaining = Math.min(lowestRemaining ?? Infinity, result.value.rateLimitRemaining);
+      }
+    });
+    const failed = new Set(attempt.accounts.filter((account) => !account.ok).map((account) => account.login.toLowerCase()));
+    for (const pull of previous?.pulls ?? []) {
+      if (failed.has(pull.account.toLowerCase())) pulls.push(pull);
+    }
+    for (const [org, seen] of visibility) {
+      if (seen.length > 0 && seen.every((state) => state === "not-found")) {
+        warnings.push(
+          seen.length === 1 ? `Can't find an organisation or user called ${org} \u2014 check DAILY_FOCUS_GITHUB_SCOPE.` : `None of the polled accounts can find an organisation or user called ${org} \u2014 check DAILY_FOCUS_GITHUB_SCOPE.`
+        );
+      }
+    }
+    this.#accountStreaks = new Map(
+      [...failed].map((login) => [login, extend(this.#accountStreaks.get(login) ?? null)])
+    );
+    attempt.warnings.push(...warnings);
+    if (!attempt.accounts.some((account) => account.ok)) {
+      publish(null);
+      this.#streak = extend(this.#streak);
+      return;
+    }
+    if (lowestRemaining !== null && lowestRemaining < RATE_LIMIT_FLOOR) {
+      this.#holdUntil = Date.now() + MAX_BACKOFF_MS;
+      attempt.warnings.push("Close to GitHub's rate limit; pausing the board for half an hour.");
+    }
+    publish(null);
+    this.#streak = null;
+    this.#file = {
+      version: 1,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      accounts: attempt.accounts.map((account) => ({ ...account })),
+      scope: [...this.#config.github.scope],
+      warnings,
+      pulls
+    };
+    try {
+      await writeJsonAtomic(this.#config.pullsFile, this.#file);
+    } catch (err) {
+      console.warn(`[daily-focus] could not write prs.json: ${err.message}`);
+    }
+  }
+};
+function listNames(names) {
+  return names.length < 2 ? names[0] ?? "" : `${names.slice(0, -1).join(", ")} and ${names.at(-1)}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}
+function strings(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function oneOf(value, allowed, fallback) {
+  return typeof value === "string" && allowed.includes(value) ? value : fallback;
+}
+function namedChecks(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => {
+    if (!isRecord(entry) || typeof entry.name !== "string" || entry.name === "") return [];
+    const check = {
+      name: entry.name,
+      kind: entry.kind === "status-context" ? "status-context" : "check-run",
+      // Re-checked on the way in as well as on the way out: the file is ours, but
+      // a link that reaches an anchor tag should never have been trusted twice.
+      detailsUrl: typeof entry.detailsUrl === "string" && /^https?:\/\//i.test(entry.detailsUrl) ? entry.detailsUrl : null
+    };
+    if (typeof entry.checkRunId === "number") check.checkRunId = entry.checkRunId;
+    return [check];
+  });
+}
+function normalizeStoredPull(raw) {
+  if (!isRecord(raw)) return null;
+  const { id, repo, number, title, url, createdAt } = raw;
+  if (typeof id !== "string" || typeof repo !== "string" || typeof number !== "number") return null;
+  if (typeof title !== "string" || typeof url !== "string" || typeof createdAt !== "string") return null;
+  const reviews = Array.isArray(raw.reviews) ? raw.reviews.flatMap(
+    (review) => isRecord(review) && typeof review.login === "string" && typeof review.state === "string" && typeof review.at === "string" ? [{ login: review.login, state: review.state, at: review.at }] : []
+  ) : [];
+  let lastActivityByOthers = null;
+  const others = raw.lastActivityByOthers;
+  if (isRecord(others) && typeof others.at === "string" && typeof others.login === "string") {
+    lastActivityByOthers = { at: others.at, login: others.login, kind: others.kind === "review" ? "review" : "comment" };
+  }
+  return {
+    id,
+    account: str(raw.account, ""),
+    repo,
+    number,
+    title,
+    url,
+    isDraft: raw.isDraft === true,
+    createdAt,
+    readyAt: str(raw.readyAt, createdAt),
+    updatedAt: str(raw.updatedAt, createdAt),
+    headRef: str(raw.headRef, ""),
+    baseRef: str(raw.baseRef, ""),
+    reviewDecision: oneOf(raw.reviewDecision, ["APPROVED", "CHANGES_REQUESTED", "REVIEW_REQUIRED"], null),
+    checks: oneOf(raw.checks, ["success", "failure", "pending"], null),
+    failingChecks: strings(raw.failingChecks),
+    mergeable: oneOf(raw.mergeable, ["MERGEABLE", "CONFLICTING", "UNKNOWN"], "UNKNOWN") ?? "UNKNOWN",
+    // Read through the same normaliser a fresh fetch uses, so the file and the API
+    // can't come to different conclusions about what a merge state means: absent
+    // is null and falls back to the older reading of ready, and a value the enum
+    // doesn't have is `UNKNOWN` rather than anything resembling a clean merge.
+    mergeStateStatus: toMergeState(raw.mergeStateStatus),
+    pendingChecks: namedChecks(raw.pendingChecks),
+    // Absent on a cache written before cancellations were told apart from
+    // failures, where they were folded into `failingChecks` instead. Nothing
+    // needs migrating: the next fetch overwrites both.
+    cancelledChecks: namedChecks(raw.cancelledChecks),
+    autoMerge: raw.autoMerge === true,
+    requestedReviewers: strings(raw.requestedReviewers),
+    reviews,
+    lastActivityByYou: typeof raw.lastActivityByYou === "string" ? raw.lastActivityByYou : null,
+    lastActivityByOthers
+  };
+}
+async function readPullsFile(path) {
+  let text;
+  try {
+    text = await readFile2(path, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const raw = JSON.parse(text);
+    if (!isRecord(raw) || raw.version !== 1 || typeof raw.fetchedAt !== "string" || !Array.isArray(raw.pulls)) return null;
+    const accounts = Array.isArray(raw.accounts) ? raw.accounts.flatMap(
+      (account) => isRecord(account) && typeof account.login === "string" ? [{ login: account.login, ok: account.ok === true, error: typeof account.error === "string" ? account.error : null }] : []
+    ) : [];
+    return {
+      version: 1,
+      fetchedAt: raw.fetchedAt,
+      accounts,
+      scope: strings(raw.scope),
+      warnings: strings(raw.warnings),
+      pulls: raw.pulls.flatMap((pull) => normalizeStoredPull(pull) ?? [])
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/calendar.ts
+import { execFile as execFile2 } from "node:child_process";
+import { readFile as readFile3, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify as promisify2 } from "node:util";
+var run2 = promisify2(execFile2);
+var HELPER_TIMEOUT_MS = 2e4;
+var POLL_MS = 150;
+var DECLINED = 3;
+var AVAILABILITY_FREE = 1;
+function str2(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function localDate(d) {
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function eventId(externalId, start, allDay) {
+  if (allDay) return `calendar:event:${externalId}:${localDate(start)}`;
+  const stamp = `${localDate(start).replace(/-/g, "")}T${String(start.getHours()).padStart(2, "0")}${String(start.getMinutes()).padStart(2, "0")}`;
+  return `calendar:event:${externalId}:${stamp}`;
+}
+function parseCalendarFacts(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const obj = raw;
+  if (str2(obj.error)) return null;
+  const calendars = [];
+  if (Array.isArray(obj.calendars)) {
+    for (const entry of obj.calendars) {
+      const id = str2(entry?.id);
+      const title = str2(entry?.title);
+      if (id && title) calendars.push({ id, title, source: str2(entry?.source) ?? "" });
+    }
+  }
+  return {
+    generatedAt: str2(obj.generatedAt) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    calendars,
+    events: Array.isArray(obj.events) ? obj.events : []
+  };
+}
+function selectEvents(facts, calendarNames) {
+  const wanted = calendarNames.map((n) => n.trim().toLowerCase()).filter((n) => n !== "");
+  const idsByName = /* @__PURE__ */ new Map();
+  for (const name of wanted) {
+    idsByName.set(
+      name,
+      facts.calendars.filter((c) => c.title.trim().toLowerCase() === name).map((c) => c.id)
+    );
+  }
+  const unmatched = [...idsByName.entries()].filter(([, ids]) => ids.length === 0).map(([name]) => name);
+  const keep = new Set([...idsByName.values()].flat());
+  const byId = /* @__PURE__ */ new Map();
+  for (const raw of facts.events) {
+    const calendarId = str2(raw.calendarId);
+    if (!calendarId || !keep.has(calendarId)) continue;
+    if (num(raw.selfStatus) === DECLINED) continue;
+    const externalId = str2(raw.externalId);
+    const startText = str2(raw.start);
+    if (!externalId || !startText) continue;
+    const start = new Date(startText);
+    if (Number.isNaN(start.getTime())) continue;
+    const allDay = raw.allDay === true;
+    const id = eventId(externalId, start, allDay);
+    if (byId.has(id)) continue;
+    const item = {
+      id,
+      source: "calendar",
+      kind: "event",
+      title: str2(raw.title) ?? "(untitled)",
+      start: allDay ? localDate(start) : start.toISOString()
+    };
+    const endText = str2(raw.end);
+    if (endText && !allDay) {
+      const end = new Date(endText);
+      if (!Number.isNaN(end.getTime())) item.end = end.toISOString();
+    }
+    if (num(raw.availability) === AVAILABILITY_FREE) item.blocking = false;
+    const url = str2(raw.url);
+    if (url && /^https?:\/\//i.test(url)) item.url = url;
+    byId.set(id, item);
+  }
+  return { events: [...byId.values()], unmatched, matched: keep.size };
+}
+var CalendarHelperError = class extends Error {
+  detail;
+  constructor(message, detail = "") {
+    super(message);
+    this.name = "CalendarHelperError";
+    this.detail = detail;
+  }
+};
+async function runHelper(appPath, selfAddresses) {
+  try {
+    await stat(appPath);
+  } catch {
+    throw new CalendarHelperError(
+      `the calendar helper isn't built at ${appPath} \u2014 run ${command("build-calendar")}, or point DAILY_FOCUS_CALENDAR_APP at an existing build`
+    );
+  }
+  const out = join(tmpdir(), `daily-focus-calendar-${process.pid}-${Date.now()}.json`);
+  try {
+    try {
+      await run2("/usr/bin/open", ["-n", "-a", appPath, "--args", out, selfAddresses.join(",")], {
+        timeout: HELPER_TIMEOUT_MS
+      });
+    } catch (err) {
+      console.warn(`[daily-focus] could not launch the calendar helper: ${err.message}`);
+      throw new CalendarHelperError(`macOS couldn't launch the calendar helper at ${appPath}`, err.message);
+    }
+    const deadline = Date.now() + HELPER_TIMEOUT_MS;
+    for (; ; ) {
+      let text = null;
+      try {
+        text = await readFile3(out, "utf8");
+      } catch {
+        text = null;
+      }
+      if (text !== null && text.trim() !== "") {
+        const raw = JSON.parse(text);
+        const facts = parseCalendarFacts(raw);
+        if (facts) return facts;
+        const detail = raw ?? {};
+        throw new CalendarHelperError(str2(detail.detail) ?? str2(detail.error) ?? "the calendar helper refused", text.trim());
+      }
+      if (Date.now() > deadline) {
+        throw new CalendarHelperError(
+          `the calendar helper wrote nothing within ${HELPER_TIMEOUT_MS / 1e3}s \u2014 is ${appPath} built?`
+        );
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, POLL_MS));
+    }
+  } finally {
+    await rm(out, { force: true });
+  }
+}
+
+// src/calendarboard.ts
+import { readFile as readFile4 } from "node:fs/promises";
+var MAX_BACKOFF_MS2 = 15 * 6e4;
+var realDeps2 = { run: runHelper };
+var CalendarBoard = class {
+  #config;
+  #deps;
+  #onChange;
+  #facts = null;
+  /** Why the last read failed, when it did. */
+  #failure = null;
+  /** Reads in a row that failed, which also spaces the next one out. */
+  #streak = null;
+  #warnings = [];
+  #reading = null;
+  #timer = null;
+  #audience = 0;
+  #stopped = false;
+  #lastReadAt = 0;
+  constructor(config, onChange, deps = realDeps2) {
+    this.#config = config;
+    this.#deps = deps;
+    this.#onChange = onChange;
+  }
+  /**
+   * Off when switched off, and off when no calendar has been named — an unnamed
+   * calendar list isn't a broken setup, it's a feature nobody turned on, and it
+   * must not produce a banner every morning.
+   */
+  get enabled() {
+    return this.#config.calendar.enabled && this.#config.calendar.names.length > 0;
+  }
+  /** Load the last good read off disk, then read once regardless of audience. */
+  async start() {
+    if (!this.enabled) return;
+    this.#facts = await readCalendarFile(this.#config.calendarFile);
+    await this.refresh();
+  }
+  stop() {
+    this.#stopped = true;
+    if (this.#timer) clearTimeout(this.#timer);
+    this.#timer = null;
+  }
+  setAudience(count) {
+    this.#audience = count;
+    if (count === 0) {
+      if (this.#timer) clearTimeout(this.#timer);
+      this.#timer = null;
+      return;
+    }
+    if (this.#timer || this.#reading) return;
+    if (this.#dueIn() === 0) void this.refresh();
+    else this.#schedule();
+  }
+  /** Read now. Joins a read already running rather than starting a second. Never rejects. */
+  async refresh() {
+    if (!this.enabled || this.#stopped) return;
+    if (this.#reading) return this.#reading;
+    if (this.#timer) clearTimeout(this.#timer);
+    this.#timer = null;
+    this.#reading = this.#read().catch((err) => {
+      this.#failure = { message: `The calendar read hit an unexpected error: ${err.message}`, detail: unexpectedDetail(err) };
+      this.#streak = extend(this.#streak);
+      console.error(`[daily-focus] calendar read failed: ${err.stack ?? String(err)}`);
+    }).finally(() => {
+      this.#reading = null;
+      this.#lastReadAt = Date.now();
+      if (this.#audience > 0 && !this.#stopped) this.#schedule();
+      this.#onChange();
+    });
+    this.#onChange();
+    return this.#reading;
+  }
+  async #read() {
+    const { appPath, addresses } = this.#config.calendar;
+    try {
+      const facts = await this.#deps.run(appPath, addresses);
+      this.#facts = facts;
+      this.#failure = null;
+      this.#streak = null;
+      await writeJsonAtomic(this.#config.calendarFile, facts);
+    } catch (err) {
+      this.#streak = extend(this.#streak);
+      const message = err instanceof CalendarHelperError ? err.message : `could not read the calendar: ${err.message}`;
+      this.#failure = {
+        message: this.#facts ? `${message}. Showing the last good read.` : `${message}. Showing the events from this morning's brief instead.`,
+        detail: errorDetail(err)
+      };
+    }
+  }
+  /** The agenda as it stands, derived on every read rather than stored. */
+  state() {
+    if (!this.enabled) {
+      return { events: [], live: false, fetchedAt: null, problem: null, failure: null, warnings: [] };
+    }
+    const reading = this.#reading !== null;
+    const failure = this.#failure ? toReadFailure(this.#failure, this.#streak, this.#stopped ? null : this.#lastReadAt + this.#intervalMs(), reading) : null;
+    if (!this.#facts) {
+      return {
+        events: [],
+        live: false,
+        fetchedAt: null,
+        // A failure says why there is nothing; with none, there just hasn't been a read.
+        problem: failure ? null : "The calendar has not been read yet.",
+        failure,
+        warnings: this.#warnings
+      };
+    }
+    const { events, unmatched, matched } = selectEvents(this.#facts, this.#config.calendar.names);
+    const warnings = [...this.#warnings];
+    if (unmatched.length > 0) {
+      warnings.push(
+        `No calendar named ${unmatched.map((n) => `"${n}"`).join(", ")}. Check DAILY_FOCUS_CALENDARS against the names in Calendar.app.`
+      );
+    }
+    if (this.#config.calendar.addresses.length === 0) {
+      warnings.push(
+        "DAILY_FOCUS_CALENDAR_ADDRESSES is unset, so meetings you declined still show and still block time."
+      );
+    }
+    if (matched === 0) {
+      return {
+        events: [],
+        live: false,
+        fetchedAt: this.#facts.generatedAt,
+        problem: "None of the configured calendars exist in Calendar.app, so the brief\u2019s events are being shown instead.",
+        failure,
+        warnings
+      };
+    }
+    return { events, live: true, fetchedAt: this.#facts.generatedAt, problem: null, failure, warnings };
+  }
+  #intervalMs() {
+    const base = this.#config.calendar.pollMinutes * 6e4;
+    const failures = this.#streak?.attempts ?? 0;
+    if (failures === 0) return base;
+    return Math.min(base * 2 ** Math.min(failures, 6), MAX_BACKOFF_MS2);
+  }
+  #dueIn() {
+    if (this.#lastReadAt === 0) return 0;
+    return Math.max(0, this.#lastReadAt + this.#intervalMs() - Date.now());
+  }
+  #schedule() {
+    if (this.#timer || this.#stopped || this.#audience === 0) return;
+    this.#timer = setTimeout(() => {
+      this.#timer = null;
+      void this.refresh();
+    }, this.#dueIn() || this.#intervalMs());
+    this.#timer.unref?.();
+  }
+};
+async function readCalendarFile(path) {
+  try {
+    return parseCalendarFacts(JSON.parse(await readFile4(path, "utf8")));
+  } catch {
+    return null;
+  }
+}
+
+// src/ticketboard.ts
+import { readFile as readFile5 } from "node:fs/promises";
+
+// src/jira.ts
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+var run3 = promisify3(execFile3);
+var ACLI_TIMEOUT_MS = 45e3;
+var PAGE_LIMIT = 200;
+var ACLI_ENV = { ...process.env, NO_COLOR: "1" };
+var AcliMissingError = class extends Error {
+  constructor(acliPath) {
+    super(
+      `could not run \`${acliPath}\` \u2014 install the Atlassian CLI or set DAILY_FOCUS_ACLI to its path`
+    );
+    this.name = "AcliMissingError";
+  }
+};
+var AcliAuthError = class extends Error {
+  detail;
+  constructor(message, detail = "") {
+    super(message);
+    this.name = "AcliAuthError";
+    this.detail = detail;
+  }
+};
+var JiraSearchError = class extends Error {
+  detail;
+  constructor(message, detail = "") {
+    super(message);
+    this.name = "JiraSearchError";
+    this.detail = detail;
+  }
+};
+var JiraTransitionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "JiraTransitionError";
+  }
+};
+async function acli(acliPath, args) {
+  try {
+    const { stdout, stderr } = await run3(acliPath, args, {
+      env: ACLI_ENV,
+      timeout: ACLI_TIMEOUT_MS,
+      // A hundred tickets of raw Jira issue JSON measured 135 KB; this is room
+      // for a board several times that before the buffer becomes the limit.
+      maxBuffer: 8 << 20
+    });
+    return { stdout, stderr, code: 0 };
+  } catch (err) {
+    const failure = err;
+    if (failure.code === "ENOENT" || failure.code === "EACCES") throw new AcliMissingError(acliPath);
+    const stderr = failure.killed || failure.signal ? `acli did not answer within ${ACLI_TIMEOUT_MS / 1e3}s \u2014 a slow network, or an OAuth refresh waiting on something?` : failure.stderr || failure.message;
+    return { stdout: failure.stdout ?? "", stderr, code: typeof failure.code === "number" ? failure.code : 1 };
+  }
+}
+function transcript(acliPath, args, { stdout, stderr }) {
+  const command3 = [acliPath, ...args].map((word) => /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replace(/'/g, "'\\''")}'`);
+  return [`$ ${command3.join(" ")}`, stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+}
+function firstLine(stderr) {
+  return stderr.split("\n").map((line) => line.replace(/^\s*[✗✓]\s*/u, "").replace(/^Error:\s*/i, "").trim()).find((line) => line !== "") ?? "";
+}
+async function acliIdentity(acliPath) {
+  const args = ["jira", "auth", "status"];
+  const { stdout, stderr, code } = await acli(acliPath, args);
+  if (code !== 0) {
+    const detail = firstLine(stderr) || firstLine(stdout) || "no Jira session";
+    throw new AcliAuthError(
+      `acli has no Jira session (${detail}) \u2014 run \`acli jira auth login\``,
+      transcript(acliPath, args, { stdout, stderr })
+    );
+  }
+  const site = /^\s*Site:\s*(\S+)\s*$/mu.exec(stdout)?.[1] ?? null;
+  const account = /^\s*Email:\s*(\S+)\s*$/mu.exec(stdout)?.[1] ?? null;
+  return { site: site ?? null, account };
+}
+var ANY_PR = "development[pullrequests].all > 0";
+var OPEN_PR = "development[pullrequests].open > 0";
+function quoteJql(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function buildJql(projects, predicate) {
+  const clauses = [
+    "statusCategory != Done",
+    "(assignee = currentUser() OR (reporter = currentUser() AND assignee IS EMPTY))"
+  ];
+  if (projects.length > 0) clauses.push(`project IN (${projects.map(quoteJql).join(", ")})`);
+  if (predicate) clauses.push(predicate);
+  return `${clauses.join(" AND ")} ORDER BY updated ASC`;
+}
+var FIELDS = "key,status,issuetype,summary";
+async function search(acliPath, jql, { limit = PAGE_LIMIT, paginate = true } = {}) {
+  const args = [
+    "jira",
+    "workitem",
+    "search",
+    "--jql",
+    jql,
+    "--fields",
+    FIELDS,
+    "--limit",
+    String(limit),
+    "--json"
+  ];
+  if (paginate) args.push("--paginate");
+  const { stdout, stderr, code } = await acli(acliPath, args);
+  if (code !== 0) {
+    throw new JiraSearchError(
+      firstLine(stderr) || firstLine(stdout) || "the Jira search failed",
+      transcript(acliPath, args, { stdout, stderr })
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    throw new JiraSearchError(
+      `could not read acli's answer as JSON (${stdout.trim().slice(0, 120) || "empty"})`,
+      transcript(acliPath, args, { stdout, stderr })
+    );
+  }
+  if (!Array.isArray(parsed)) throw new JiraSearchError("acli's answer was not a list of work items");
+  return parsed;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var CATEGORIES = ["new", "indeterminate", "done", "undefined"];
+function toCategory(value) {
+  return typeof value === "string" && CATEGORIES.includes(value) ? value : "undefined";
+}
+function issueKey(raw) {
+  if (!isRecord2(raw)) return null;
+  if (typeof raw.key === "string" && raw.key !== "") return raw.key;
+  const fields = isRecord2(raw.fields) ? raw.fields : null;
+  return typeof fields?.key === "string" && fields.key !== "" ? fields.key : null;
+}
+function browseUrl(site, key) {
+  return site ? `https://${site}/browse/${encodeURIComponent(key)}` : null;
+}
+function toTicket(raw, site, hasAnyPr, hasOpenPr, allPrsClosed = false) {
+  const key = issueKey(raw);
+  if (key === null || !isRecord2(raw)) return null;
+  const fields = isRecord2(raw.fields) ? raw.fields : {};
+  const issuetype = isRecord2(fields.issuetype) ? fields.issuetype : {};
+  const level = typeof issuetype.hierarchyLevel === "number" ? issuetype.hierarchyLevel : 0;
+  if (level > 0) return null;
+  const status = isRecord2(fields.status) ? fields.status : {};
+  const category = isRecord2(status.statusCategory) ? status.statusCategory : {};
+  return {
+    id: `jira:${key}`,
+    key,
+    summary: typeof fields.summary === "string" ? fields.summary : key,
+    workflowStatus: typeof status.name === "string" ? status.name : "",
+    statusCategory: toCategory(category.key),
+    issueType: typeof issuetype.name === "string" ? issuetype.name : "",
+    url: browseUrl(site, key),
+    // An open pull request is a pull request, whatever the other count said.
+    hasAnyPr: hasAnyPr || hasOpenPr,
+    hasOpenPr,
+    // Never inferred from the two above, which is the whole point of the field:
+    // they cannot tell "all closed" from "could not find out".
+    allPrsClosed: allPrsClosed && !hasOpenPr
+  };
+}
+var DEV_FIELD = "customfield_10000";
+var CLOSED_PR_STATES = ["MERGED", "DECLINED"];
+var DEV_CONCURRENCY = 5;
+function jsonObjectAt(text, from) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = from; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") depth++;
+    else if (ch === "}" && --depth === 0) return text.slice(from, i + 1);
+  }
+  return null;
+}
+function readDevPullRequests(field) {
+  if (typeof field !== "string") return null;
+  const marker = field.indexOf("json=");
+  if (marker === -1) return null;
+  const opens = field.indexOf("{", marker);
+  if (opens === -1) return null;
+  const body = jsonObjectAt(field, opens);
+  if (body === null) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return null;
+  }
+  const cached = isRecord2(parsed) && isRecord2(parsed.cachedValue) ? parsed.cachedValue : null;
+  if (!cached) return null;
+  if (Array.isArray(cached.errors) && cached.errors.length > 0) return null;
+  const summary = isRecord2(cached.summary) ? cached.summary : null;
+  const pullrequest = summary && isRecord2(summary.pullrequest) ? summary.pullrequest : null;
+  const overall = pullrequest && isRecord2(pullrequest.overall) ? pullrequest.overall : null;
+  if (!overall) return null;
+  const { count, stateCount, state } = overall;
+  if (typeof count !== "number" || typeof stateCount !== "number" || typeof state !== "string") return null;
+  return { count, state, stateCount };
+}
+function allPullRequestsClosed(dev) {
+  if (dev === null || dev.count < 1) return false;
+  if (dev.stateCount !== dev.count) return false;
+  return CLOSED_PR_STATES.includes(dev.state.toUpperCase());
+}
+async function fetchDevPullRequests(acliPath, key) {
+  const args = [
+    "jira",
+    "workitem",
+    "view",
+    key,
+    "--fields",
+    DEV_FIELD,
+    "--json"
+  ];
+  const { stdout, stderr, code } = await acli(acliPath, args);
+  if (code !== 0) {
+    throw new JiraSearchError(
+      firstLine(stderr) || firstLine(stdout) || `could not read the development panel for ${key}`,
+      transcript(acliPath, args, { stdout, stderr })
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    throw new JiraSearchError(`could not read acli's development panel answer for ${key} as JSON`);
+  }
+  const fields = isRecord2(parsed) && isRecord2(parsed.fields) ? parsed.fields : null;
+  if (!fields) throw new JiraSearchError(`acli's answer for ${key} carried no fields`);
+  return readDevPullRequests(fields[DEV_FIELD]);
+}
+async function mapLimit(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    for (; ; ) {
+      const i = next++;
+      if (i >= items.length) return;
+      out[i] = await fn(items[i]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return out;
+}
+async function fetchTickets(acliPath, opts) {
+  const [base, anyPr, openPr] = await Promise.all([
+    search(acliPath, buildJql(opts.projects, null)),
+    search(acliPath, buildJql(opts.projects, ANY_PR)),
+    search(acliPath, buildJql(opts.projects, OPEN_PR))
+  ]);
+  const keys = (issues, what) => {
+    const set = /* @__PURE__ */ new Set();
+    for (const issue of issues) {
+      const key = issueKey(issue);
+      if (key !== null) set.add(key);
+    }
+    if (issues.length > 0 && set.size === 0) {
+      throw new JiraSearchError(`the ${what} search returned ${issues.length} work items and no readable keys`);
+    }
+    return set;
+  };
+  const withAny = keys(anyPr, "linked pull request");
+  const withOpen = keys(openPr, "open pull request");
+  const warnings = [];
+  const tickets = [];
+  let unreadable = 0;
+  for (const raw of base) {
+    const key = issueKey(raw);
+    const ticket = toTicket(raw, opts.site, key !== null && withAny.has(key), key !== null && withOpen.has(key));
+    if (ticket) tickets.push(ticket);
+    else if (key === null) unreadable++;
+  }
+  if (unreadable > 0) {
+    warnings.push(`Skipped ${unreadable} work ${unreadable === 1 ? "item" : "items"} Jira described in a way this board could not read.`);
+  }
+  const candidates = tickets.filter((ticket) => ticket.hasAnyPr && !ticket.hasOpenPr);
+  const panels = await mapLimit(
+    candidates,
+    DEV_CONCURRENCY,
+    (ticket) => fetchDevPullRequests(acliPath, ticket.key).then(
+      (dev) => ({ asked: true, dev }),
+      () => ({ asked: false, dev: null })
+    )
+  );
+  const unanswered = [];
+  const unaccounted = [];
+  candidates.forEach((ticket, i) => {
+    const { asked, dev } = panels[i];
+    if (allPullRequestsClosed(dev)) {
+      ticket.allPrsClosed = true;
+    } else if (!asked) {
+      unanswered.push(ticket.key);
+    } else if (dev === null) {
+      unaccounted.push(ticket.key);
+    } else {
+      ticket.hasOpenPr = true;
+    }
+  });
+  const listed = (keys2) => keys2.map((key) => {
+    const url = browseUrl(opts.site, key);
+    return url === null ? key : `[${key}](${url})`;
+  }).join(", ");
+  const heldOut = (keys2) => `${keys2.length === 1 ? "it is" : "they are"} held out of "no open pull requests left" rather than guessed at`;
+  if (unanswered.length > 0) {
+    warnings.push(
+      `Could not read Jira's development panel for ${listed(unanswered)}, so ${heldOut(unanswered)}. The next read may well manage it.`
+    );
+  }
+  if (unaccounted.length > 0) {
+    warnings.push(
+      `Jira's search says ${listed(unaccounted)} ${unaccounted.length === 1 ? "has" : "have"} pull requests, but its own development panel names none, so ${heldOut(unaccounted)}. Jira is disagreeing with itself; the row comes back when one of its caches catches up.`
+    );
+  }
+  if (!opts.site) {
+    warnings.push(
+      "acli did not say which Atlassian site it is logged in to, so these rows have no links. Set DAILY_FOCUS_JIRA_SITE to your site host."
+    );
+  }
+  const projects = [...new Set(tickets.map((ticket) => projectOf(ticket.key)).filter((p) => p !== null))];
+  const finished = await Promise.all(projects.map((project) => fetchDoneStatuses(acliPath, project).catch(() => null)));
+  const unread = projects.filter((_, i) => finished[i] === null);
+  if (unread.length > 0) {
+    warnings.push(
+      `Could not read how work gets finished in ${unread.join(", ")}, so the status menu there may be missing a way out of the workflow.`
+    );
+  }
+  return {
+    tickets,
+    statuses: statusesByProject(base, ...finished.map((batch) => batch ?? [])),
+    warnings
+  };
+}
+async function fetchDoneStatuses(acliPath, project) {
+  const jql = `statusCategory = Done AND project = ${quoteJql(project)} ORDER BY updated DESC`;
+  return search(acliPath, jql, { limit: 25, paginate: false });
+}
+function projectOf(key) {
+  return /^([A-Za-z][A-Za-z0-9_]*)-\d+$/.exec(key.trim())?.[1]?.toUpperCase() ?? null;
+}
+function statusesByProject(...batches) {
+  const byProject = {};
+  for (const batch of batches) {
+    for (const raw of batch) {
+      const key = issueKey(raw);
+      if (key === null) continue;
+      const project = projectOf(key);
+      if (project === null) continue;
+      const fields = isRecord2(raw) && isRecord2(raw.fields) ? raw.fields : {};
+      const status = isRecord2(fields.status) && typeof fields.status.name === "string" ? fields.status.name : "";
+      if (status === "") continue;
+      const seen = byProject[project] ??= [];
+      if (!seen.includes(status)) seen.push(status);
+    }
+  }
+  for (const statuses of Object.values(byProject)) statuses.sort((a, b) => a.localeCompare(b));
+  return byProject;
+}
+async function transitionTicket(acliPath, key, status) {
+  const { stdout, stderr, code } = await acli(acliPath, [
+    "jira",
+    "workitem",
+    "transition",
+    "--key",
+    key,
+    "--status",
+    status,
+    "--yes",
+    "--json"
+  ]);
+  if (code !== 0) {
+    throw new JiraTransitionError(firstLine(stderr) || firstLine(stdout) || `Jira would not move ${key} to ${status}`);
+  }
+  readTransitionReport(stdout, key, status);
+}
+function readTransitionReport(stdout, key, status) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    throw new JiraTransitionError(
+      `acli did not say whether ${key} moved (${stdout.trim().slice(0, 120) || "no output"}) \u2014 check Jira`
+    );
+  }
+  const report = isRecord2(parsed) ? parsed : {};
+  const results = Array.isArray(report.results) ? report.results : [];
+  for (const entry of results) {
+    if (!isRecord2(entry)) continue;
+    const outcome = typeof entry.status === "string" ? entry.status.toUpperCase() : "";
+    if (outcome === "SUCCESS") continue;
+    const detail = typeof entry.message === "string" && entry.message !== "" ? entry.message : `Jira refused the move to ${status}`;
+    throw new JiraTransitionError(detail);
+  }
+  const succeeded = typeof report.successCount === "number" ? report.successCount : results.length;
+  if (succeeded < 1) {
+    throw new JiraTransitionError(`acli reported no successful move for ${key} \u2014 check Jira`);
+  }
+}
+
+// src/tickets.ts
+var COURT_ORDER2 = ["settled", "started", "idle"];
+function ticketCourtOrder(court) {
+  return COURT_ORDER2.indexOf(court);
+}
+function inStatus(ticket, statuses) {
+  const status = ticket.workflowStatus.trim().toLowerCase();
+  if (status === "") return false;
+  return statuses.some((listed) => listed.trim().toLowerCase() === status);
+}
+function judge2(ticket, holdStatuses = []) {
+  if (ticket.statusCategory === "done") return null;
+  if (ticket.hasAnyPr && !ticket.hasOpenPr && ticket.allPrsClosed) return "settled";
+  if (ticket.statusCategory === "new" && ticket.hasOpenPr) return "started";
+  if (ticket.statusCategory === "indeterminate" && !ticket.hasAnyPr && !inStatus(ticket, holdStatuses)) return "idle";
+  return null;
+}
+function resolveTickets(tickets, actions, now, holdStatuses = []) {
+  const folded = foldActionLog(actions, now);
+  const rows = [];
+  for (const ticket of tickets) {
+    const court = judge2(ticket, holdStatuses);
+    if (!court) continue;
+    const log = folded.get(canonicalId(ticket.id));
+    const row = {
+      ...ticket,
+      court,
+      status: log?.status === "snoozed" ? "snoozed" : "open",
+      notes: log?.notes ?? []
+    };
+    if (row.status === "snoozed" && log?.snoozedUntil) row.snoozedUntil = log.snoozedUntil;
+    rows.push(row);
+  }
+  return rows.sort((a, b) => ticketCourtOrder(a.court) - ticketCourtOrder(b.court));
+}
+function resolveInProgress(tickets, actions, now, inProgressStatuses = []) {
+  const folded = foldActionLog(actions, now);
+  return tickets.filter((ticket) => ticket.statusCategory === "indeterminate").filter((ticket) => inProgressStatuses.length === 0 || inStatus(ticket, inProgressStatuses)).map((ticket) => ({ ...ticket, notes: folded.get(canonicalId(ticket.id))?.notes ?? [] }));
+}
+function countTickets(rows) {
+  const counts = { settled: 0, started: 0, idle: 0, parked: 0 };
+  for (const row of rows) {
+    if (row.status === "snoozed") counts.parked++;
+    else counts[row.court]++;
+  }
+  return counts;
+}
+
+// src/ticketboard.ts
+var MAX_BACKOFF_MS3 = 30 * 6e4;
+var realDeps3 = { identity: acliIdentity, fetch: fetchTickets, transition: transitionTicket };
+var TicketBoard = class {
+  #config;
+  #deps;
+  #onChange;
+  /** The last successful read, as on disk. */
+  #file = null;
+  #warnings = [];
+  /** Why the last read failed, when it did. */
+  #reason = null;
+  /** Reads in a row that failed, which also spaces the next one out. */
+  #streak = null;
+  #reading = null;
+  #timer = null;
+  #audience = 0;
+  #stopped = false;
+  #lastReadAt = 0;
+  constructor(config, onChange, deps = realDeps3) {
+    this.#config = config;
+    this.#deps = deps;
+    this.#onChange = onChange;
+  }
+  get enabled() {
+    return this.#config.jira.enabled;
+  }
+  /** Load what the last run left on disk, then read once regardless of audience. */
+  async start() {
+    if (!this.enabled) return;
+    this.#file = await readTicketsFile(this.#config.ticketsFile);
+    await this.refresh();
+  }
+  stop() {
+    this.#stopped = true;
+    if (this.#timer) clearTimeout(this.#timer);
+    this.#timer = null;
+  }
+  /** How many browsers are watching. Polling pauses at zero. */
+  setAudience(count) {
+    this.#audience = count;
+    if (count === 0) {
+      if (this.#timer) clearTimeout(this.#timer);
+      this.#timer = null;
+      return;
+    }
+    if (this.#timer || this.#reading) return;
+    if (this.#dueIn() === 0) void this.refresh();
+    else this.#schedule();
+  }
+  /** Read now. Joins a read already in flight rather than starting a second. Never rejects. */
+  async refresh() {
+    if (!this.enabled || this.#stopped) return;
+    if (this.#reading) return this.#reading;
+    if (this.#timer) clearTimeout(this.#timer);
+    this.#timer = null;
+    this.#reading = this.#read().catch((err) => {
+      this.#reason = { message: `The ticket board hit an unexpected error: ${err.message}`, detail: unexpectedDetail(err) };
+      this.#streak = extend(this.#streak);
+      console.error(`[daily-focus] jira poll failed: ${err.stack ?? String(err)}`);
+    }).finally(() => {
+      this.#reading = null;
+      this.#lastReadAt = Date.now();
+      this.#schedule();
+      this.#onChange();
+    });
+    this.#onChange();
+    return this.#reading;
+  }
+  /** The board joined with the action log, ready to render. Never throws. */
+  view(actions, now) {
+    const warnings = this.enabled ? [...this.#warnings] : [];
+    let rows = [];
+    let inProgress = [];
+    if (this.enabled) {
+      const tickets = this.#file?.tickets ?? [];
+      const { holdStatuses, inProgressStatuses } = this.#config.jira;
+      try {
+        rows = resolveTickets(tickets, actions, now, holdStatuses);
+        inProgress = resolveInProgress(tickets, actions, now, inProgressStatuses);
+      } catch (err) {
+        warnings.push(`Could not judge the tickets on file: ${err.message}`);
+      }
+    }
+    const reading = this.#reading !== null;
+    return {
+      enabled: this.enabled,
+      reason: this.enabled && this.#reason ? toReadFailure(this.#reason, this.#streak, this.#stopped ? null : Date.now() + this.#dueIn(), reading) : null,
+      fetchedAt: this.#file?.fetchedAt ?? null,
+      fetching: reading,
+      // Suppressed alongside a reason, as the board's account list is: an
+      // account line beside "acli is not logged in" contradicts the banner.
+      account: this.#reason ? null : this.#file?.account ?? null,
+      projects: [...this.#config.jira.projects],
+      warnings,
+      pollMinutes: this.#config.jira.pollMinutes,
+      rows,
+      counts: countTickets(rows),
+      inProgress,
+      checked: this.#file?.tickets.length ?? 0,
+      statuses: this.#file?.statuses ?? {}
+    };
+  }
+  /**
+   * Move one ticket to a status, then read the board back.
+   *
+   * The only thing in this process that changes anything outside it, and it runs
+   * only from a click. It deliberately does *not* touch `#file` itself: the row
+   * on screen has to come from Jira having actually accepted the move, so the
+   * refresh is the confirmation. A refresh already in flight is joined rather
+   * than doubled, which is why this awaits `refresh` rather than `#read`.
+   *
+   * Unlike everything else on this class, it rejects — the caller is a request
+   * handler with somebody waiting on the answer, and a transition that silently
+   * did nothing is the one failure this must never present as success.
+   */
+  async transition(key, status) {
+    if (!this.enabled) throw new Error("the Jira ticket board is switched off (DAILY_FOCUS_JIRA=off)");
+    if (this.#stopped) throw new Error("the server is shutting down");
+    await this.#deps.transition(this.#config.jira.acliPath, key, status);
+    await this.refresh();
+  }
+  #intervalMs() {
+    const base = this.#config.jira.pollMinutes * 6e4;
+    const failures = this.#streak?.attempts ?? 0;
+    if (failures === 0) return base;
+    return Math.min(base * 2 ** Math.min(failures, 6), MAX_BACKOFF_MS3);
+  }
+  #dueIn() {
+    if (this.#lastReadAt === 0) return 0;
+    return Math.max(0, this.#lastReadAt + this.#intervalMs() - Date.now());
+  }
+  #schedule() {
+    if (this.#stopped || this.#audience === 0 || this.#timer || this.#reading) return;
+    this.#timer = setTimeout(() => {
+      this.#timer = null;
+      void this.refresh();
+    }, this.#dueIn());
+    this.#timer.unref?.();
+  }
+  async #read() {
+    const { acliPath, projects, site: configuredSite } = this.#config.jira;
+    let identity2;
+    try {
+      identity2 = await this.#deps.identity(acliPath);
+    } catch (err) {
+      this.#reason = { message: `${err.message}, or set DAILY_FOCUS_JIRA=off`, detail: errorDetail(err) };
+      this.#streak = extend(this.#streak);
+      return;
+    }
+    const site = configuredSite ?? identity2.site;
+    try {
+      const { tickets, statuses, warnings } = await this.#deps.fetch(acliPath, { projects, site });
+      this.#reason = null;
+      this.#warnings = warnings;
+      this.#streak = null;
+      this.#file = {
+        version: 1,
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        account: identity2.account,
+        projects: [...projects],
+        warnings,
+        tickets,
+        statuses
+      };
+      try {
+        await writeJsonAtomic(this.#config.ticketsFile, this.#file);
+      } catch (err) {
+        console.warn(`[daily-focus] could not write tickets.json: ${err.message}`);
+      }
+    } catch (err) {
+      this.#streak = extend(this.#streak);
+      const message = `could not read Jira: ${err.message}`;
+      this.#reason = { message: this.#file ? `${message}. Showing the last good read.` : message, detail: errorDetail(err) };
+    }
+  }
+};
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function strings2(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function normalizeStoredTicket(raw) {
+  if (!isRecord3(raw)) return null;
+  const { key, url, workflowStatus, statusCategory, issueType, summary } = raw;
+  if (typeof key !== "string" || key === "") return null;
+  const site = typeof url === "string" ? /^https:\/\/([^/]+)\/browse\//.exec(url)?.[1] ?? null : null;
+  return toTicket(
+    {
+      key,
+      fields: {
+        summary,
+        status: { name: workflowStatus, statusCategory: { key: statusCategory } },
+        issuetype: { name: issueType, hierarchyLevel: 0 }
+      }
+    },
+    site,
+    raw.hasAnyPr === true,
+    raw.hasOpenPr === true,
+    // Absent in a file written before the development panel was read — which
+    // must come back as "not confirmed" rather than as confirmed, since those
+    // files are exactly the ones whose settled court counted drafts as merges.
+    raw.allPrsClosed === true
+  );
+}
+async function readTicketsFile(path) {
+  let text;
+  try {
+    text = await readFile5(path, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const raw = JSON.parse(text);
+    if (!isRecord3(raw) || raw.version !== 1 || typeof raw.fetchedAt !== "string" || !Array.isArray(raw.tickets)) {
+      return null;
+    }
+    const statuses = {};
+    if (isRecord3(raw.statuses)) {
+      for (const [project, names] of Object.entries(raw.statuses)) {
+        const list = strings2(names);
+        if (list.length > 0) statuses[project] = list;
+      }
+    }
+    return {
+      version: 1,
+      fetchedAt: raw.fetchedAt,
+      account: typeof raw.account === "string" ? raw.account : null,
+      projects: strings2(raw.projects),
+      warnings: strings2(raw.warnings),
+      tickets: raw.tickets.flatMap((ticket) => normalizeStoredTicket(ticket) ?? []),
+      statuses
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/agent.ts
+import { spawn as spawn2 } from "node:child_process";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { appendFile as appendFile2, mkdir as mkdir2, readFile as readFile7 } from "node:fs/promises";
+import { homedir } from "node:os";
+import { createInterface as createInterface2 } from "node:readline";
+
+// src/assistant.ts
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, readFile as readFile6 } from "node:fs/promises";
+import { createInterface } from "node:readline";
+var TURN_TIMEOUT_MS = 10 * 6e4;
+var TURNS_SHOWN = 20;
+var QUICK_ACTIONS = [
+  {
+    id: "assess-review",
+    label: "Assess the review",
+    sources: ["github"],
+    request: "Read every review comment and requested change on this pull request against the diff. For each one say whether it is right, partly right or mistaken, with the evidence, and what I should do about it."
+  },
+  {
+    id: "explain-ci",
+    label: "Explain the CI failure",
+    sources: ["github"],
+    request: "Find the failing checks on this pull request and read their logs. Explain what is failing, why, and the smallest change that would fix it. Do not attempt the fix."
+  },
+  {
+    id: "summarise-pr",
+    label: "Summarise the change",
+    sources: ["github"],
+    request: "Summarise what this pull request changes and why, in a form I could paste as its description, and flag anything a reviewer is likely to push back on."
+  },
+  {
+    id: "reply-reviewer",
+    label: "Draft replies to reviewers",
+    sources: ["github"],
+    request: "Draft a reply to each open review comment on this pull request, in my voice, agreeing where the reviewer is right and explaining where they are not. Give me the text to post. Do not post it."
+  },
+  {
+    id: "draft-reply",
+    label: "Draft a reply",
+    sources: ["email"],
+    request: "Read the whole thread and draft a reply from me, in my voice, that answers what was asked. Create it as a Gmail draft on this thread so I can open it there. Never send it. If you cannot create drafts, give me the text instead and say so."
+  },
+  {
+    id: "summarise-thread",
+    label: "Summarise the thread",
+    sources: ["email"],
+    request: "Read the whole thread and summarise it: who wants what, what has been decided, and what is still open."
+  },
+  {
+    id: "what-they-need",
+    label: "What do they need from me?",
+    sources: ["email", "slack", "messages"],
+    request: "Read this and tell me exactly what is being asked of me, by whom, by when, and what the smallest adequate response would be."
+  },
+  {
+    id: "summarise-ticket",
+    label: "Summarise the ticket",
+    sources: ["jira"],
+    request: "Read this ticket, its comments and anything it links to, and summarise where it stands: what is done, what is left, and what is blocking it."
+  },
+  {
+    id: "status-comment",
+    label: "Draft a status comment",
+    sources: ["jira"],
+    request: "Read this ticket and its linked pull requests, and draft a short status comment from me for the ticket. Give me the text to post. Do not post it."
+  },
+  {
+    id: "next-steps",
+    label: "Break it into next steps",
+    sources: null,
+    request: "Read whatever this item points at and turn it into three to five concrete next steps I could start on today, smallest first."
+  }
+];
+function foldAssistantLog(text) {
+  const turns = /* @__PURE__ */ new Map();
+  for (const line of text.split("\n")) {
+    if (line.trim() === "") continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof record !== "object" || record === null || typeof record.turn !== "string") continue;
+    if (record.event === "started") {
+      if (typeof record.item !== "string" || typeof record.request !== "string") continue;
+      turns.set(record.turn, {
+        id: record.turn,
+        itemId: record.item,
+        agent: record.agent,
+        sessionId: null,
+        request: record.request,
+        action: typeof record.action === "string" ? record.action : null,
+        startedAt: record.at,
+        endedAt: null,
+        status: "running",
+        reply: "",
+        error: null
+      });
+      continue;
+    }
+    const turn = turns.get(record.turn);
+    if (!turn) continue;
+    turn.sessionId = typeof record.sessionId === "string" ? record.sessionId : turn.sessionId;
+    turn.reply = typeof record.reply === "string" ? record.reply : turn.reply;
+    turn.endedAt = record.at;
+    if (record.event === "finished") {
+      turn.status = "done";
+    } else if (record.event === "failed") {
+      turn.status = "failed";
+      turn.error = record.error;
+    } else if (record.event === "aborted") {
+      turn.status = "aborted";
+      turn.error = record.reason;
+    }
+  }
+  return turns;
+}
+function parseLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("{")) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+var claudeAdapter = {
+  args({ prompt, sessionId, model, effort, tools, denyEdits }) {
+    const args = [
+      "-p",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--permission-mode",
+      "dontAsk",
+      "--permission-prompts",
+      "none"
+    ];
+    if (denyEdits) args.push("--disallowedTools", "Edit", "Write", "NotebookEdit");
+    if (tools.length > 0) args.push("--allowedTools", ...tools);
+    if (model) args.push("--model", model);
+    if (effort) args.push("--effort", effort);
+    if (sessionId) args.push("--resume", sessionId);
+    args.push(prompt);
+    return args;
+  },
+  parse(line) {
+    const event = parseLine(line);
+    if (!event) return null;
+    const type = event.type;
+    if (type === "system" && typeof event.session_id === "string") {
+      return { sessionId: event.session_id };
+    }
+    if (type === "assistant") {
+      const message = event.message;
+      const content = Array.isArray(message?.content) ? message.content : [];
+      const text = content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n\n");
+      return text ? { text } : null;
+    }
+    if (type === "result") {
+      const ok = event.is_error !== true && event.subtype === "success";
+      const reply = typeof event.result === "string" ? event.result : void 0;
+      const parsed = { done: ok ? { ok, reply } : { ok, error: reply ?? String(event.subtype ?? "failed") } };
+      if (typeof event.session_id === "string") parsed.sessionId = event.session_id;
+      return parsed;
+    }
+    return null;
+  }
+};
+var codexAdapter = {
+  args({ prompt, sessionId, model, effort }) {
+    const args = ["exec"];
+    if (sessionId) args.push("resume");
+    args.push("--json", "--skip-git-repo-check");
+    args.push("-c", 'sandbox_mode="workspace-write"', "-c", "sandbox_workspace_write.network_access=true");
+    if (model) args.push("-c", `model=${JSON.stringify(model)}`);
+    if (effort) args.push("-c", `model_reasoning_effort=${JSON.stringify(effort)}`);
+    if (sessionId) args.push(sessionId);
+    args.push(prompt);
+    return args;
+  },
+  parse(line) {
+    const event = parseLine(line);
+    if (!event) return null;
+    const type = event.type;
+    if (type === "thread.started" && typeof event.thread_id === "string") {
+      return { sessionId: event.thread_id };
+    }
+    if (type === "item.completed") {
+      const item = event.item;
+      if (item?.type === "agent_message" && typeof item.text === "string") return { text: item.text };
+      return null;
+    }
+    if (type === "turn.completed") return { done: { ok: true } };
+    if (type === "turn.failed" || type === "error") {
+      const error = event.error;
+      const message = typeof event.message === "string" ? event.message : error?.message;
+      return { done: { ok: false, error: message ?? String(type) } };
+    }
+    return null;
+  }
+};
+var ADAPTERS = {
+  claude: claudeAdapter,
+  codex: codexAdapter
+};
+function composePrompt(instructions, context, request, profile) {
+  const now = /* @__PURE__ */ new Date();
+  const facts = [`- Profile: ${profile}`, `- Today: ${now.toISOString().slice(0, 10)}`];
+  const parts = [instructions.trim(), "", "## Context", "", ...facts, ""];
+  if (context.item) parts.push("### The item", "", "```json", JSON.stringify(context.item, null, 2), "```", "");
+  if (context.pull) parts.push("### The pull request, as the board last saw it", "", "```json", JSON.stringify(context.pull, null, 2), "```", "");
+  if (context.ticket) parts.push("### The ticket, as the board last saw it", "", "```json", JSON.stringify(context.ticket, null, 2), "```", "");
+  parts.push("## Request", "", request.trim());
+  return parts.join("\n");
+}
+var Assistant = class _Assistant {
+  turns = /* @__PURE__ */ new Map();
+  running = /* @__PURE__ */ new Map();
+  loaded = false;
+  config;
+  hooks;
+  spawnFn;
+  constructor(config, hooks, spawnFn = spawn) {
+    this.config = config;
+    this.hooks = hooks;
+    this.spawnFn = spawnFn;
+  }
+  get enabled() {
+    return this.config.assistant.agent !== null;
+  }
+  /** Whether any turn has a process going right now. */
+  get busy() {
+    return this.running.size > 0;
+  }
+  /**
+   * Read the log, and close whatever was left running when the last process
+   * died. Cheap when the assistant is off: the log is read only if it exists.
+   */
+  async start() {
+    if (this.loaded) return;
+    this.loaded = true;
+    let text = "";
+    try {
+      text = await readFile6(this.config.assistantLogFile, "utf8");
+    } catch {
+      return;
+    }
+    for (const [id, turn] of foldAssistantLog(text)) this.turns.set(id, turn);
+    for (const turn of this.turns.values()) {
+      if (turn.status !== "running") continue;
+      turn.status = "aborted";
+      turn.error = "the dashboard restarted while this was running";
+      turn.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.append({
+        event: "aborted",
+        turn: turn.id,
+        sessionId: turn.sessionId,
+        reason: turn.error,
+        reply: turn.reply,
+        at: turn.endedAt
+      });
+    }
+  }
+  view() {
+    const items = {};
+    for (const turn of this.turns.values()) {
+      const entry = items[turn.itemId] ??= { running: false, sessionId: null, turns: [] };
+      entry.turns.push(turn);
+      if (turn.status === "running") entry.running = true;
+      if (turn.sessionId && turn.agent === this.config.assistant.agent) entry.sessionId = turn.sessionId;
+    }
+    for (const entry of Object.values(items)) {
+      entry.turns.sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+      entry.turns = entry.turns.slice(-TURNS_SHOWN);
+    }
+    return {
+      enabled: this.enabled,
+      agent: this.config.assistant.agent,
+      quickActions: [...QUICK_ACTIONS],
+      items
+    };
+  }
+  /** The request text an ask resolves to, or null when there is nothing to send. */
+  static requestFor(ask) {
+    const action = ask.action ? QUICK_ACTIONS.find((candidate) => candidate.id === ask.action) : void 0;
+    if (ask.action && !action) return null;
+    const typed = (ask.text ?? "").trim();
+    if (!action && typed === "") return null;
+    const request = action ? typed ? `${action.request}
+
+${typed}` : action.request : typed;
+    return { request, action: action?.id ?? null };
+  }
+  /**
+   * Start a turn. Returns once the process is running, not once it has answered;
+   * the answer arrives through `onChange` and the next state.
+   */
+  async ask(ask, context) {
+    const agent = this.config.assistant.agent;
+    if (!agent) throw new Error("the assistant is off; set DAILY_FOCUS_ASSISTANT to claude or codex");
+    if (this.running.has(ask.itemId)) throw new Error("the assistant is already working on this item");
+    const resolved = _Assistant.requestFor(ask);
+    if (!resolved) throw new Error("nothing to ask: give a quick action or some text");
+    await this.start();
+    const previous = this.view().items[ask.itemId]?.sessionId ?? null;
+    const turn = {
+      id: randomUUID(),
+      itemId: ask.itemId,
+      agent,
+      // Null until the CLI says: a resumed session that fails must not be
+      // recorded as if this CLI had owned it.
+      sessionId: null,
+      request: resolved.request,
+      action: resolved.action,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      endedAt: null,
+      status: "running",
+      reply: "",
+      error: null
+    };
+    this.turns.set(turn.id, turn);
+    await this.append({
+      event: "started",
+      turn: turn.id,
+      item: turn.itemId,
+      agent,
+      request: turn.request,
+      action: turn.action,
+      at: turn.startedAt
+    });
+    const prompt = previous ? resolved.request : composePrompt(await this.instructions(), context, resolved.request, this.config.profile);
+    await mkdir(this.config.assistantDir, { recursive: true });
+    const adapter = ADAPTERS[agent];
+    const args = adapter.args({
+      prompt,
+      sessionId: previous,
+      model: this.config.assistant.model,
+      effort: this.config.assistant.effort,
+      tools: this.config.assistant.tools,
+      denyEdits: true
+    });
+    let child;
+    try {
+      child = this.spawnFn(this.config.assistant.binPath, args, {
+        cwd: this.config.assistantDir,
+        // Stdin closed: both CLIs wait on it otherwise, one of them for three seconds.
+        stdio: ["ignore", "pipe", "pipe"],
+        env: process.env
+      });
+    } catch (err) {
+      await this.finish(turn, { ok: false, error: this.spawnError(err) });
+      return turn;
+    }
+    const timer = setTimeout(() => this.stop(turn.itemId, "gave up after ten minutes"), TURN_TIMEOUT_MS);
+    timer.unref();
+    const run6 = { turn, child, timer, abortReason: null };
+    this.running.set(turn.itemId, run6);
+    this.hooks.onChange();
+    let done;
+    const stderr = [];
+    child.stderr?.on("data", (chunk) => {
+      stderr.push(chunk.toString("utf8"));
+      if (stderr.length > 50) stderr.shift();
+    });
+    if (child.stdout) {
+      const lines = createInterface({ input: child.stdout });
+      lines.on("line", (line) => {
+        const event = adapter.parse(line);
+        if (!event) return;
+        if (event.sessionId) turn.sessionId = event.sessionId;
+        if (event.text) {
+          turn.reply = turn.reply ? `${turn.reply}
+
+${event.text}` : event.text;
+          this.hooks.onChange();
+        }
+        if (event.done) done = event.done;
+      });
+    }
+    child.on("error", (err) => {
+      done = { ok: false, error: this.spawnError(err) };
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      this.running.delete(turn.itemId);
+      const outcome = run6.abortReason ? { ok: false, error: run6.abortReason } : done ?? {
+        ok: false,
+        error: `${agent} exited with code ${code}${stderr.length ? `: ${stderr.join("").trim().split("\n").slice(-3).join(" ")}` : ""}`
+      };
+      void this.finish(turn, outcome, run6.abortReason !== null);
+    });
+    return turn;
+  }
+  /** Kill the turn running on an item, if any. */
+  async stop(itemId, reason = "stopped") {
+    const run6 = this.running.get(itemId);
+    if (!run6) return false;
+    run6.abortReason = reason;
+    run6.child.kill("SIGTERM");
+    return true;
+  }
+  /** Kill everything, for shutdown. The exit handlers write the aborted lines. */
+  async close() {
+    for (const itemId of [...this.running.keys()]) await this.stop(itemId, "the dashboard shut down");
+  }
+  async finish(turn, outcome, aborted = false) {
+    const at = (/* @__PURE__ */ new Date()).toISOString();
+    const reply = outcome.reply ?? turn.reply;
+    turn.reply = reply;
+    turn.endedAt = at;
+    if (outcome.ok) {
+      turn.status = "done";
+      await this.append({ event: "finished", turn: turn.id, sessionId: turn.sessionId, reply, at });
+    } else if (aborted) {
+      turn.status = "aborted";
+      turn.error = outcome.error ?? "stopped";
+      await this.append({ event: "aborted", turn: turn.id, sessionId: turn.sessionId, reason: turn.error, reply, at });
+    } else {
+      turn.status = "failed";
+      turn.error = outcome.error ?? "failed";
+      await this.append({ event: "failed", turn: turn.id, sessionId: turn.sessionId, error: turn.error, reply, at });
+    }
+    this.hooks.onChange();
+  }
+  spawnError(err) {
+    const code = err.code;
+    const bin = this.config.assistant.binPath;
+    if (code === "ENOENT") return `could not find ${bin}; install it or set DAILY_FOCUS_ASSISTANT_BIN to its path`;
+    return `could not run ${bin}: ${err instanceof Error ? err.message : String(err)}`;
+  }
+  /** The store's copy, or the repo's before `npm run init` has linked it. */
+  async instructions() {
+    for (const path of [this.config.assistantPromptFile, this.config.assistantPromptSource]) {
+      try {
+        return await readFile6(path, "utf8");
+      } catch {
+      }
+    }
+    return "You are helping with one item from a personal dashboard. Read only; never send, post or edit anything.";
+  }
+  /**
+   * The log records what happened; the turn in memory is updated by the caller
+   * first. Only this process writes the file, so the memory never has to be
+   * re-read from it.
+   */
+  async append(record) {
+    await mkdir(this.config.dataDir, { recursive: true });
+    await appendFile(this.config.assistantLogFile, `${JSON.stringify(record)}
+`, "utf8");
+  }
+};
+
+// src/agent.ts
+var RUN_TIMEOUT_MS = 60 * 6e4;
+var TURN_TIMEOUT_MS2 = 10 * 6e4;
+var RUNS_SHOWN = 30;
+function agentPrompt(promptPath) {
+  return [
+    "Run my morning brief for today.",
+    "",
+    "Your full instructions are in this file \u2014 read it now and follow it exactly,",
+    "including every step it lists and the verification checks it ends with:",
+    "",
+    `  ${promptPath}`,
+    "",
+    "That file is the source of truth and it changes over time. Re-read it on every",
+    "run; never work from your memory of a previous run.",
+    "",
+    "Finish by reporting back as that file asks you to."
+  ].join("\n");
+}
+function followUpPrompt(question) {
+  return [
+    "A follow-up question about the brief you wrote in this session. Answer it here.",
+    "Read whatever you need to, but do not write or change any file, and do not",
+    "rewrite the brief: if something in it should change, say what and why, and I",
+    "will run you again.",
+    "",
+    question.trim()
+  ].join("\n");
+}
+function displayPath(path, home = homedir()) {
+  return path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
+}
+function foldAgentLog(text) {
+  const runs = /* @__PURE__ */ new Map();
+  for (const line of text.split("\n")) {
+    if (line.trim() === "") continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof record !== "object" || record === null || typeof record.run !== "string") continue;
+    if (record.event === "started") {
+      runs.set(record.run, {
+        id: record.run,
+        cli: record.cli,
+        // Runs logged before the dashboard had a clock were all started by hand.
+        trigger: record.trigger === "schedule" ? "schedule" : "hand",
+        sessionId: null,
+        startedAt: record.at,
+        endedAt: null,
+        status: "running",
+        report: "",
+        messages: [],
+        error: null,
+        turns: [],
+        resumable: false
+      });
+      continue;
+    }
+    const run6 = runs.get(record.run);
+    if (!run6) continue;
+    if (record.event === "asked") {
+      if (typeof record.turn !== "string" || typeof record.question !== "string") continue;
+      run6.turns.push({
+        id: record.turn,
+        question: record.question,
+        startedAt: record.at,
+        endedAt: null,
+        status: "running",
+        reply: "",
+        error: null
+      });
+      continue;
+    }
+    if (record.event === "replied" || record.event === "turn-failed" || record.event === "turn-aborted") {
+      const turn = run6.turns.find((candidate) => candidate.id === record.turn);
+      if (!turn) continue;
+      turn.reply = typeof record.reply === "string" ? record.reply : turn.reply;
+      turn.endedAt = record.at;
+      if (record.event === "replied") {
+        turn.status = "done";
+      } else if (record.event === "turn-failed") {
+        turn.status = "failed";
+        turn.error = record.error;
+      } else {
+        turn.status = "aborted";
+        turn.error = record.reason;
+      }
+      continue;
+    }
+    run6.sessionId = typeof record.sessionId === "string" ? record.sessionId : run6.sessionId;
+    run6.report = typeof record.report === "string" ? record.report : run6.report;
+    run6.messages = Array.isArray(record.messages) ? record.messages.filter((message) => typeof message === "string") : run6.report ? [run6.report] : [];
+    run6.endedAt = record.at;
+    if (record.event === "finished") {
+      run6.status = "done";
+    } else if (record.event === "failed") {
+      run6.status = "failed";
+      run6.error = record.error;
+    } else if (record.event === "aborted") {
+      run6.status = "aborted";
+      run6.error = record.reason;
+    }
+  }
+  return [...runs.values()].sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+}
+var AgentRunner = class {
+  /** Every run in the log, oldest first. */
+  runs = [];
+  running = null;
+  loaded = false;
+  config;
+  hooks;
+  spawnFn;
+  constructor(config, hooks, spawnFn = spawn2) {
+    this.config = config;
+    this.hooks = hooks;
+    this.spawnFn = spawnFn;
+  }
+  get enabled() {
+    return this.config.agent.cli !== null;
+  }
+  /**
+   * Read the log, and close whatever was left going when the last process died:
+   * its child died with it, so a spinner would never stop.
+   */
+  async start() {
+    if (this.loaded) return;
+    this.loaded = true;
+    let text = "";
+    try {
+      text = await readFile7(this.config.agentLogFile, "utf8");
+    } catch {
+      return;
+    }
+    this.runs = foldAgentLog(text);
+    const at = (/* @__PURE__ */ new Date()).toISOString();
+    const reason = "the dashboard restarted while this was running";
+    for (const run6 of this.runs) {
+      if (run6.status === "running") {
+        run6.status = "aborted";
+        run6.error = reason;
+        run6.endedAt = at;
+        await this.append({ event: "aborted", run: run6.id, sessionId: run6.sessionId, reason, report: run6.report, messages: run6.messages, at });
+      }
+      for (const turn of run6.turns) {
+        if (turn.status !== "running") continue;
+        turn.status = "aborted";
+        turn.error = reason;
+        turn.endedAt = at;
+        await this.append({ event: "turn-aborted", run: run6.id, turn: turn.id, reason, reply: turn.reply, at });
+      }
+    }
+  }
+  /** Whether a run, or a question about one, has a process going right now. */
+  get busy() {
+    return this.running !== null;
+  }
+  /** The newest run, whatever became of it. */
+  get last() {
+    return this.runs.at(-1) ?? null;
+  }
+  view(now = /* @__PURE__ */ new Date()) {
+    const runs = this.runs.slice(-RUNS_SHOWN).reverse().map((run6) => ({ ...run6, resumable: this.resumable(run6) }));
+    return {
+      enabled: this.enabled,
+      cli: this.config.agent.cli,
+      schedule: this.scheduleView(now),
+      last: runs[0] ?? null,
+      runs
+    };
+  }
+  scheduleView(now) {
+    const at = this.config.agent.at;
+    if (!at || !this.enabled) return null;
+    return { at: describeTime(at), nextRunAt: this.nextRunAt?.toISOString() ?? null };
+  }
+  /** Worked out by the last tick, since it needs the log. */
+  nextRunAt = null;
+  /**
+   * The clock. Called every so often by the server, and once at startup: if a
+   * run is due and none has started today, start one.
+   */
+  async tick(now = /* @__PURE__ */ new Date()) {
+    const at = this.config.agent.at;
+    if (!at || !this.enabled) return;
+    await this.start();
+    const input = {
+      at,
+      schedule: resolveSchedule(this.config),
+      lastRunStartedAt: this.last?.startedAt ?? null,
+      now
+    };
+    const next = nextScheduledRun(input);
+    if ((next?.getTime() ?? null) !== (this.nextRunAt?.getTime() ?? null)) {
+      this.nextRunAt = next;
+      this.hooks.onChange();
+    }
+    if (!scheduledRunDue(input) || this.running) return;
+    console.log(`[daily-focus] starting the morning agent, due ${describeTime(at)}`);
+    await this.run("schedule", now);
+  }
+  /**
+   * Start a run. Returns once the process is running, not once the brief is
+   * written; the report arrives through `onChange`, the brief through the store.
+   * `now` is the clock's, so a run it starts is stamped with the moment it
+   * decided on.
+   */
+  async run(trigger = "hand", now = /* @__PURE__ */ new Date()) {
+    const cli = this.config.agent.cli;
+    if (!cli) throw new Error("running the morning agent is off; set DAILY_FOCUS_AGENT to codex or claude");
+    if (this.running) {
+      throw new Error(
+        this.running.turn ? "the morning agent is still answering a question" : "the morning agent is already running"
+      );
+    }
+    await this.start();
+    const run6 = {
+      id: randomUUID2(),
+      cli,
+      trigger,
+      sessionId: null,
+      startedAt: now.toISOString(),
+      endedAt: null,
+      status: "running",
+      report: "",
+      messages: [],
+      error: null,
+      turns: [],
+      resumable: false
+    };
+    this.runs.push(run6);
+    await this.append({ event: "started", run: run6.id, cli, trigger, at: run6.startedAt });
+    const adapter = ADAPTERS[cli];
+    const args = adapter.args({
+      prompt: agentPrompt(displayPath(this.config.promptFile)),
+      sessionId: null,
+      model: this.config.agent.model,
+      effort: this.config.agent.effort,
+      tools: [...briefWritingTools(), ...this.config.agent.tools],
+      denyEdits: false
+    });
+    await this.spawnInto(run6, null, args, RUN_TIMEOUT_MS, "gave up after an hour");
+    return run6;
+  }
+  /**
+   * Ask a finished run a question, in its own session. Returns once the process
+   * is running; the answer arrives through `onChange` and the next state.
+   */
+  async ask(runId, question) {
+    const cli = this.config.agent.cli;
+    if (!cli) throw new Error("running the morning agent is off; set DAILY_FOCUS_AGENT to codex or claude");
+    await this.start();
+    const run6 = this.runs.find((candidate) => candidate.id === runId);
+    if (!run6) throw new Error("no such run");
+    if (this.running) {
+      throw new Error(
+        this.running.turn ? "the morning agent is still answering a question" : "the morning agent is still running"
+      );
+    }
+    if (!this.resumable(run6)) {
+      throw new Error(
+        run6.sessionId === null ? "this run left no session to continue" : `this run was made by ${run6.cli}, and the agent is ${cli} now`
+      );
+    }
+    const text = question.trim();
+    if (text === "") throw new Error("nothing to ask");
+    const turn = {
+      id: randomUUID2(),
+      question: text,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      endedAt: null,
+      status: "running",
+      reply: "",
+      error: null
+    };
+    run6.turns.push(turn);
+    await this.append({ event: "asked", run: run6.id, turn: turn.id, question: text, at: turn.startedAt });
+    const adapter = ADAPTERS[cli];
+    const args = adapter.args({
+      prompt: followUpPrompt(text),
+      sessionId: run6.sessionId,
+      model: this.config.agent.model,
+      effort: this.config.agent.effort,
+      // The sources, and not the brief: a chat is given nothing to write.
+      tools: this.config.agent.tools,
+      denyEdits: true
+    });
+    await this.spawnInto(run6, turn, args, TURN_TIMEOUT_MS2, "gave up after ten minutes");
+    return turn;
+  }
+  /**
+   * Start the CLI in the store and read what it says into `turn`, or into the
+   * run when there is none. The store in both cases: Claude Code files a
+   * session under the directory it was started in, and looks for it there.
+   */
+  async spawnInto(run6, turn, args, timeoutMs, timeoutReason) {
+    const cli = run6.cli;
+    const adapter = ADAPTERS[cli];
+    await mkdir2(this.config.dataDir, { recursive: true });
+    let child;
+    try {
+      child = this.spawnFn(this.config.agent.binPath, args, {
+        cwd: this.config.dataDir,
+        // Stdin closed: both CLIs wait on it otherwise.
+        stdio: ["ignore", "pipe", "pipe"],
+        env: process.env
+      });
+    } catch (err) {
+      await this.finish(run6, turn, { ok: false, error: this.spawnError(err) });
+      return;
+    }
+    const timer = setTimeout(() => void this.stop(timeoutReason), timeoutMs);
+    timer.unref();
+    const running = { run: run6, turn, child, timer, abortReason: null };
+    this.running = running;
+    this.hooks.onChange();
+    let done;
+    const stderr = [];
+    child.stderr?.on("data", (chunk) => {
+      stderr.push(chunk.toString("utf8"));
+      if (stderr.length > 50) stderr.shift();
+    });
+    if (child.stdout) {
+      const lines = createInterface2({ input: child.stdout });
+      lines.on("line", (line) => {
+        const event = adapter.parse(line);
+        if (!event) return;
+        if (event.sessionId && !turn) run6.sessionId = event.sessionId;
+        if (event.text) {
+          if (turn) {
+            turn.reply = turn.reply ? `${turn.reply}
+
+${event.text}` : event.text;
+          } else {
+            run6.messages.push(event.text);
+            run6.report = event.text;
+          }
+          this.hooks.onChange();
+        }
+        if (event.done) done = event.done;
+      });
+    }
+    child.on("error", (err) => {
+      done = { ok: false, error: this.spawnError(err) };
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      this.running = null;
+      const outcome = running.abortReason ? { ok: false, error: running.abortReason } : done ?? {
+        ok: false,
+        error: `${cli} exited with code ${code}${stderr.length ? `: ${stderr.join("").trim().split("\n").slice(-3).join(" ")}` : ""}`
+      };
+      void this.finish(run6, turn, outcome, running.abortReason !== null);
+    });
+  }
+  /**
+   * Kill whatever is going, run or follow-up. What a run already renamed into
+   * place stays: the brief it replaced is gone either way, and the archive has it.
+   */
+  async stop(reason = "stopped") {
+    if (!this.running) return false;
+    this.running.abortReason = reason;
+    this.running.child.kill("SIGTERM");
+    return true;
+  }
+  /** Kill the run, for shutdown. The exit handler writes the aborted line. */
+  async close() {
+    await this.stop("the dashboard shut down");
+  }
+  resumable(run6) {
+    return run6.status !== "running" && run6.sessionId !== null && run6.cli === this.config.agent.cli;
+  }
+  async finish(run6, turn, outcome, aborted = false) {
+    const at = (/* @__PURE__ */ new Date()).toISOString();
+    if (turn) {
+      const reply = outcome.reply ?? turn.reply;
+      turn.reply = reply;
+      turn.endedAt = at;
+      if (outcome.ok) {
+        await this.append({ event: "replied", run: run6.id, turn: turn.id, reply, at });
+        turn.status = "done";
+      } else if (aborted) {
+        turn.error = outcome.error ?? "stopped";
+        await this.append({ event: "turn-aborted", run: run6.id, turn: turn.id, reason: turn.error, reply, at });
+        turn.status = "aborted";
+      } else {
+        turn.error = outcome.error ?? "failed";
+        await this.append({ event: "turn-failed", run: run6.id, turn: turn.id, error: turn.error, reply, at });
+        turn.status = "failed";
+      }
+      this.hooks.onChange();
+      return;
+    }
+    const report = outcome.reply ?? run6.report;
+    run6.report = report;
+    run6.endedAt = at;
+    const messages = run6.messages;
+    if (outcome.ok) {
+      await this.append({ event: "finished", run: run6.id, sessionId: run6.sessionId, report, messages, at });
+      run6.status = "done";
+    } else if (aborted) {
+      run6.error = outcome.error ?? "stopped";
+      await this.append({ event: "aborted", run: run6.id, sessionId: run6.sessionId, reason: run6.error, report, messages, at });
+      run6.status = "aborted";
+    } else {
+      run6.error = outcome.error ?? "failed";
+      await this.append({ event: "failed", run: run6.id, sessionId: run6.sessionId, error: run6.error, report, messages, at });
+      run6.status = "failed";
+    }
+    this.hooks.onChange();
+  }
+  spawnError(err) {
+    const code = err.code;
+    const bin = this.config.agent.binPath;
+    if (code === "ENOENT") return `could not find ${bin}; install it or set DAILY_FOCUS_AGENT_BIN to its path`;
+    return `could not run ${bin}: ${err instanceof Error ? err.message : String(err)}`;
+  }
+  async append(record) {
+    await mkdir2(this.config.dataDir, { recursive: true });
+    await appendFile2(this.config.agentLogFile, `${JSON.stringify(record)}
+`, "utf8");
+  }
+};
+
+// src/watch.ts
+import { watch } from "node:fs";
+function watchDataDir(dir, onChange, { debounceMs = 120, ignore = [] } = {}) {
+  let timer = null;
+  const fire = (_event, filename) => {
+    if (filename !== null && ignore.includes(String(filename))) return;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      onChange();
+    }, debounceMs);
+    timer.unref?.();
+  };
+  let watcher = null;
+  try {
+    watcher = watch(dir, { persistent: false }, fire);
+    watcher.on("error", (err) => {
+      console.warn(`[daily-focus] stopped watching ${dir}: ${err.message}`);
+    });
+  } catch (err) {
+    console.warn(`[daily-focus] could not watch ${dir}: ${err.message}`);
+  }
+  return () => {
+    if (timer) clearTimeout(timer);
+    watcher?.close();
+  };
+}
+
+// src/assets.ts
+import { readdir, stat as stat2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+async function computeAssetVersion(dir) {
+  const parts = [];
+  async function walk(current) {
+    let entries;
+    try {
+      entries = await readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      const path = join2(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(path);
+      } else {
+        const info = await stat2(path);
+        parts.push(`${entry.name}:${info.size}:${info.mtimeMs}`);
+      }
+    }
+  }
+  await walk(dir);
+  let hash = 0;
+  const joined = parts.join("|");
+  for (let i = 0; i < joined.length; i++) {
+    hash = Math.imul(31, hash) + joined.charCodeAt(i) | 0;
+  }
+  return (hash >>> 0).toString(36);
+}
+
+// src/favicon.ts
+var FAVICONS = {
+  work: `<path d="M34 30V20a8 8 0 0 1 8-8h16a8 8 0 0 1 8 8v10" fill="none" stroke="#2a78d6" stroke-width="9"/><path fill="#2a78d6" fill-rule="evenodd" d="M16 30h68a10 10 0 0 1 10 10v38a10 10 0 0 1-10 10H16A10 10 0 0 1 6 78V40a10 10 0 0 1 10-10ZM40 46v14h20V46Z"/>`,
+  personal: `<path fill="#1baf7a" fill-rule="evenodd" d="M50 8 96 48H84v44H16V48H4ZM41 92V66h18v26Z"/>`
+};
+function faviconSvg(profile) {
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">${FAVICONS[profile]}</svg>`;
+}
+
+// src/guard.ts
+import { isIP } from "node:net";
+var HOST_HEADER = /^(?:\[([0-9a-f:.]+)\]|([^\s:@/[\]]+))(?::\d{1,5})?$/i;
+function hostnameOf(header) {
+  const match = HOST_HEADER.exec(header);
+  if (!match) return null;
+  return (match[1] ?? match[2]).toLowerCase().replace(/\.$/, "");
+}
+function isTrustedHostname(hostname, listenHost) {
+  if (isIP(hostname) !== 0) return true;
+  if (hostname === "localhost" || hostname.endsWith(".localhost")) return true;
+  if (hostname.endsWith(".ts.net")) return true;
+  return hostname === listenHost.toLowerCase().replace(/\.$/, "");
+}
+function refusal(req, listenHost) {
+  const hostname = hostnameOf(req.headers.host ?? "");
+  if (hostname === null || !isTrustedHostname(hostname, listenHost)) {
+    return {
+      status: 403,
+      error: `this dashboard answers only to localhost, IP addresses, Tailscale names and DAILY_FOCUS_HOST, and was reached as ${JSON.stringify(req.headers.host ?? "")}`
+    };
+  }
+  if (req.method === "POST") {
+    const type = (req.headers["content-type"] ?? "").split(";")[0].trim().toLowerCase();
+    if (type !== "application/json") return { status: 415, error: "send this as application/json" };
+  }
+  return null;
+}
+
+// src/presence.ts
+import { execFile as execFile4 } from "node:child_process";
+import { platform } from "node:os";
+import { promisify as promisify4 } from "node:util";
+var run4 = promisify4(execFile4);
+var PROBE_TIMEOUT_MS = 4e3;
+var HID_IDLE = /"HIDIdleTime"\s*=\s*(\d+)/;
+var readIdleSeconds = async () => {
+  if (platform() !== "darwin") return null;
+  try {
+    const { stdout } = await run4("ioreg", ["-c", "IOHIDSystem", "-d", "1", "-r"], {
+      timeout: PROBE_TIMEOUT_MS,
+      maxBuffer: 1024 * 1024
+    });
+    return parseIdleSeconds(stdout);
+  } catch {
+    return null;
+  }
+};
+function parseIdleSeconds(ioregOutput) {
+  const match = HID_IDLE.exec(ioregOutput);
+  if (!match) return null;
+  const nanoseconds = Number(match[1]);
+  if (!Number.isFinite(nanoseconds) || nanoseconds < 0) return null;
+  return nanoseconds / 1e9;
+}
+
+// src/settings.ts
+var SETTING_GROUPS = [
+  { id: "instance", title: "This dashboard" },
+  { id: "agent", title: "Morning agent" },
+  { id: "assistant", title: "Assistant" },
+  { id: "github", title: "Pull requests" },
+  { id: "jira", title: "Jira tickets" },
+  { id: "calendar", title: "Calendar" },
+  { id: "day", title: "Working day" },
+  { id: "sessions", title: "Focus sessions" }
+];
+var OFF_OR_CLI = [
+  { value: "off", label: "Off" },
+  { value: "claude", label: "Claude Code" },
+  { value: "codex", label: "Codex" }
+];
+var EFFORTS = ["low", "medium", "high", "xhigh", "max"].map((value) => ({ value, label: value }));
+var always = (text) => () => text;
+var SETTINGS = [
+  {
+    key: "DAILY_FOCUS_PROFILE",
+    group: "instance",
+    label: "What this dashboard briefs",
+    help: "Work or home. Picks the morning prompt and the defaults below: the personal profile switches off Jira, free time and away detection.",
+    kind: "choice",
+    choices: PROFILES.map((value) => ({ value, label: value === "work" ? "Work" : "Personal life" })),
+    fallback: always("Work")
+  },
+  {
+    key: "DAILY_FOCUS_AGENT",
+    group: "agent",
+    label: "Write the brief with",
+    help: "The coding-agent CLI the dashboard runs each morning to write your brief. It has to be installed and logged in.",
+    kind: "choice",
+    choices: OFF_OR_CLI,
+    fallback: always("Off")
+  },
+  {
+    key: "DAILY_FOCUS_AGENT_AT",
+    group: "agent",
+    label: "Run it at",
+    help: "Local time, such as 06:30, or off to run it only when you press refresh. If the dashboard was off at that time, it runs when it next starts that day.",
+    kind: "time",
+    fallback: always("07:00")
+  },
+  {
+    key: "DAILY_FOCUS_AGENT_DAYS",
+    group: "agent",
+    label: "On these days",
+    help: "Cron-style weekday numbers: 1-5 is Monday to Friday, 0-4 is Sunday to Thursday, 0,6 is the weekend.",
+    kind: "text",
+    fallback: always("1-5, Monday to Friday")
+  },
+  {
+    key: "DAILY_FOCUS_AGENT_MODEL",
+    group: "agent",
+    label: "Model",
+    help: "Passed to the CLI as it is, such as opus. Empty uses the CLI's own default.",
+    kind: "text",
+    fallback: always("The CLI's own")
+  },
+  {
+    key: "DAILY_FOCUS_AGENT_EFFORT",
+    group: "agent",
+    label: "Effort",
+    help: "A brief is worth a high effort.",
+    kind: "choice",
+    choices: EFFORTS,
+    fallback: always("The CLI's own")
+  },
+  {
+    key: "DAILY_FOCUS_AGENT_TOOLS",
+    group: "agent",
+    label: "Tools Claude Code may use",
+    help: "In Claude Code's permission syntax, comma-separated. Add your calendar, chat and document connectors by name, or the brief reports them as unreachable. Ignored by Codex.",
+    kind: "list",
+    fallback: always("Bash(gh *), Bash(acli *), WebFetch, mcp__claude_ai_Gmail"),
+    advanced: true
+  },
+  {
+    key: "DAILY_FOCUS_AGENT_BIN",
+    group: "agent",
+    label: "Path to the CLI",
+    help: "Only needed when the dashboard can't find the CLI on its own.",
+    kind: "text",
+    fallback: always("Found on PATH"),
+    advanced: true
+  },
+  {
+    key: "DAILY_FOCUS_STALE_AFTER_HOURS",
+    group: "agent",
+    label: "Expect a new brief every",
+    help: "Hours, counted only on the days above. After that, and 45 minutes more, the page says the agent may not have run.",
+    kind: "number",
+    fallback: always("24 hours"),
+    advanced: true
+  },
+  {
+    key: "DAILY_FOCUS_ASSISTANT",
+    group: "assistant",
+    label: "Answer questions with",
+    help: "Puts an assistant in every item's panel. It reads and drafts, and never sends, posts or edits.",
+    kind: "choice",
+    choices: OFF_OR_CLI,
+    fallback: always("Off")
+  },
+  {
+    key: "DAILY_FOCUS_ASSISTANT_MODEL",
+    group: "assistant",
+    label: "Model",
+    help: "Passed to the CLI as it is. Empty uses the CLI's own default.",
+    kind: "text",
+    fallback: always("The CLI's own")
+  },
+  {
+    key: "DAILY_FOCUS_ASSISTANT_EFFORT",
+    group: "assistant",
+    label: "Effort",
+    help: "Passed to the CLI as it is.",
+    kind: "choice",
+    choices: EFFORTS,
+    fallback: always("The CLI's own")
+  },
+  {
+    key: "DAILY_FOCUS_ASSISTANT_TOOLS",
+    group: "assistant",
+    label: "Tools Claude Code may use",
+    help: "In Claude Code's permission syntax, comma-separated. Editing tools are denied whatever this says. Ignored by Codex.",
+    kind: "list",
+    fallback: always("Bash(gh *), Bash(acli *), WebFetch, mcp__claude_ai_Gmail"),
+    advanced: true
+  },
+  {
+    key: "DAILY_FOCUS_ASSISTANT_BIN",
+    group: "assistant",
+    label: "Path to the CLI",
+    help: "Only needed when the dashboard can't find the CLI on its own.",
+    kind: "text",
+    fallback: always("Found on PATH"),
+    advanced: true
+  },
+  {
+    key: "DAILY_FOCUS_GITHUB",
+    group: "github",
+    label: "Pull request board",
+    help: "Reads your open pull requests through the GitHub CLI. Sign in with gh auth login.",
+    kind: "flag",
+    fallback: always("On")
+  },
+  {
+    key: "DAILY_FOCUS_GITHUB_ACCOUNTS",
+    group: "github",
+    label: "Accounts",
+    help: "GitHub logins to read as, comma-separated, when gh holds more than one. Empty uses the active one.",
+    kind: "list",
+    fallback: always("gh's active account")
+  },
+  {
+    key: "DAILY_FOCUS_GITHUB_SCOPE",
+    group: "github",
+    label: "Only these organisations or repositories",
+    help: "Comma-separated: acme, or acme/webapp for one repository. Empty counts every pull request you have open.",
+    kind: "list",
+    fallback: always("Everything")
+  },
+  {
+    key: "DAILY_FOCUS_GITHUB_MERGE_GATE_CHECKS",
+    group: "github",
+    label: "Merge gate checks",
+    help: "Exact names of checks that stand for a repository's whole merge policy, comma-separated. Pending ones get their own bucket.",
+    kind: "list",
+    fallback: always("None"),
+    advanced: true
+  },
+  {
+    key: "DAILY_FOCUS_GITHUB_POLL_MINUTES",
+    group: "github",
+    label: "Read every",
+    help: "Minutes between reads while a tab is open.",
+    kind: "number",
+    fallback: always("5 minutes"),
+    advanced: true
+  },
+  {
+    key: "DAILY_FOCUS_GH",
+    group: "github",
+    label: "Path to gh",
+    help: "Only needed when the dashboard can't find the GitHub CLI on its own.",
+    kind: "text",
+    fallback: always("Found on PATH"),
+    advanced: true
+  },
+  {
+    key: "DAILY_FOCUS_JIRA",
+    group: "jira",
+    label: "Jira ticket board",
+    help: "Flags tickets whose status disagrees with their pull requests, through the Atlassian CLI. Sign in with acli jira auth login.",
+    kind: "flag",
+    fallback: (profile) => profile === "personal" ? "Off" : "On"
+  },
+  {
+    key: "DAILY_FOCUS_JIRA_PROJECTS",
+    group: "jira",
+    label: "Only these projects",
+    help: "Project keys, comma-separated. Empty means every project you can see.",
+    kind: "list",
+    fallback: always("Every project")
+  },
+  {
+    key: "DAILY_FOCUS_JIRA_HOLD_STATUSES",
+    group: "jira",
+    label: "Statuses that mean on hold",
+    help: "Spelled as your Jira spells them, comma-separated, such as Blocked, On Hold. Tickets in them are not flagged for having no code linked.",
+    kind: "list",
+    fallback: always("None")
+  },
+  {
+    key: "DAILY_FOCUS_JIRA_IN_PROGRESS_STATUSES",
+    group: "jira",
+    label: "Statuses that mean working on it",
+    help: "What the Working on view shows, comma-separated. Use In Progress to leave out In Review.",
+    kind: "list",
+    fallback: always("Everything Jira calls in progress")
+  },
+  {
+    key: "DAILY_FOCUS_JIRA_SITE",
+    group: "jira",
+    label: "Atlassian site",
+    help: "The host links are built from, such as acme.atlassian.net. Empty uses the one acli signed in to.",
+    kind: "text",
+    fallback: always("acli's own"),
+    advanced: true
+  },
+  {
+    key: "DAILY_FOCUS_JIRA_POLL_MINUTES",
+    group: "jira",
+    label: "Read every",
+    help: "Minutes between reads while a tab is open.",
+    kind: "number",
+    fallback: always("15 minutes"),
+    advanced: true
+  },
+  {
+    key: "DAILY_FOCUS_ACLI",
+    group: "jira",
+    label: "Path to acli",
+    help: "Only needed when the dashboard can't find the Atlassian CLI on its own.",
+    kind: "text",
+    fallback: always("Found on PATH"),
+    advanced: true
+  },
+  {
+    key: "DAILY_FOCUS_CALENDAR",
+    group: "calendar",
+    label: "Live agenda",
+    help: "Reads today's events from Calendar.app on a Mac, so a meeting declined at eleven frees the slot. Off uses the events in the brief.",
+    kind: "flag",
+    fallback: always("On")
+  },
+  {
+    key: "DAILY_FOCUS_CALENDARS",
+    group: "calendar",
+    label: "Calendars",
+    help: "Names as Calendar.app shows them, comma-separated. Empty reads none, and the agenda uses the brief.",
+    kind: "list",
+    fallback: always("None")
+  },
+  {
+    key: "DAILY_FOCUS_CALENDAR_ADDRESSES",
+    group: "calendar",
+    label: "Your email addresses",
+    help: "Comma-separated. Used only to find your reply on an invitation, so a meeting you declined stops blocking your time.",
+    kind: "list",
+    fallback: always("None")
+  },
+  {
+    key: "DAILY_FOCUS_CALENDAR_POLL_MINUTES",
+    group: "calendar",
+    label: "Read every",
+    help: "Minutes between reads while a tab is open.",
+    kind: "number",
+    fallback: always("5 minutes"),
+    advanced: true
+  },
+  {
+    key: "DAILY_FOCUS_CALENDAR_APP",
+    group: "calendar",
+    label: "Path to the calendar helper",
+    help: "Only needed when the helper is somewhere other than where it was built.",
+    kind: "text",
+    fallback: always("The built copy"),
+    advanced: true
+  },
+  {
+    key: "DAILY_FOCUS_FREE_WINDOWS",
+    group: "day",
+    label: "Show free time",
+    help: "Find focus windows between meetings in your working hours. Off shows events only.",
+    kind: "flag",
+    fallback: (profile) => profile === "personal" ? "Off" : "On"
+  },
+  {
+    key: "DAILY_FOCUS_WORK_START",
+    group: "day",
+    label: "Working day starts at",
+    help: "Hour of the day, 0 to 23, when the brief doesn't say.",
+    kind: "number",
+    fallback: always("9")
+  },
+  {
+    key: "DAILY_FOCUS_WORK_END",
+    group: "day",
+    label: "Working day ends at",
+    help: "Hour of the day, 0 to 23, when the brief doesn't say.",
+    kind: "number",
+    fallback: always("17")
+  },
+  {
+    key: "DAILY_FOCUS_MIN_FREE_WINDOW",
+    group: "day",
+    label: "Shortest focus window",
+    help: "Minutes a gap has to last to count as time for focused work.",
+    kind: "number",
+    fallback: always("45 minutes")
+  },
+  {
+    key: "DAILY_FOCUS_SESSION_MINUTES",
+    group: "sessions",
+    label: "Session length",
+    help: "Minutes a focus session is set for when you start one.",
+    kind: "number",
+    fallback: always("25 minutes")
+  },
+  {
+    key: "DAILY_FOCUS_AWAY_AFTER",
+    group: "sessions",
+    label: "End a session when away for",
+    help: "Minutes without touching the Mac before a session is closed where you left. 0 turns it off.",
+    kind: "number",
+    fallback: (profile) => profile === "personal" ? "0, off" : "10 minutes"
+  }
+];
+var BY_KEY = new Map(SETTINGS.map((def) => [def.key, def]));
+function present(record, key) {
+  const value = record[key];
+  return value === void 0 || value.trim() === "" ? null : value.trim();
+}
+function profileOf(sources, settings = sources.settings) {
+  const raw = (present(layerEnv(sources, settings), "DAILY_FOCUS_PROFILE") ?? "work").toLowerCase();
+  return PROFILES.includes(raw) ? raw : "work";
+}
+function describeSettings(sources) {
+  const profile = profileOf(sources);
+  const settings = SETTINGS.map((def) => {
+    const fromEnv = present(sources.process, def.key);
+    const fromSettings = present(sources.settings, def.key);
+    const fromDotenv = present(sources.dotenv, def.key);
+    const [value, source] = fromEnv !== null ? [fromEnv, "environment"] : fromSettings !== null ? [fromSettings, "settings"] : fromDotenv !== null ? [fromDotenv, "dotenv"] : [null, "default"];
+    return {
+      key: def.key,
+      group: def.group,
+      label: def.label,
+      help: def.help,
+      kind: def.kind,
+      choices: def.choices ?? null,
+      advanced: def.advanced === true,
+      value,
+      source,
+      fallback: def.fallback(profile)
+    };
+  });
+  return { groups: SETTING_GROUPS, settings, error: sources.settingsError };
+}
+function applySettingsChange(sources, change) {
+  const next = { ...sources.settings };
+  for (const [key, raw] of Object.entries(change)) {
+    if (LAUNCH_SETTINGS.includes(key)) {
+      return { error: `${key} says where the store is or how the server listens, so it is set in the environment, not here` };
+    }
+    if (!BY_KEY.has(key)) return { error: `${key} is not a setting` };
+    if (raw !== null && typeof raw !== "string") return { error: `${key} must be text, or null for the default` };
+    if (present(sources.process, key) !== null) {
+      return { error: `${key} is set in the environment the dashboard was started with, which wins over this page` };
+    }
+    const value = raw?.trim() ?? "";
+    if (value === "") delete next[key];
+    else next[key] = value;
+  }
+  try {
+    loadConfig(layerEnv(sources, next));
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+  return { settings: next };
+}
+async function saveSettings(path, settings) {
+  const sorted = {};
+  for (const key of Object.keys(settings).sort()) sorted[key] = settings[key];
+  await writeJsonAtomic(path, sorted);
+}
+
+// src/setup.ts
+import { execFile as execFile5 } from "node:child_process";
+import { access, constants, readdir as readdir2, readFile as readFile8, stat as stat3 } from "node:fs/promises";
+import { delimiter, isAbsolute, join as join3 } from "node:path";
+import { promisify as promisify5 } from "node:util";
+var run5 = promisify5(execFile5);
+var PLACEHOLDERS = [
+  "Your Name",
+  "you@example.com",
+  "you@personal.example",
+  "your-github-login",
+  "Some Shared Calendar",
+  "Some Noisy Calendar",
+  "<where your colleagues are>",
+  "<where you are>",
+  "<where you live>",
+  "<document id>"
+];
+function placeholdersIn(text) {
+  return PLACEHOLDERS.filter((placeholder) => text.includes(placeholder)).length;
+}
+async function findExecutable(name, path = process.env.PATH ?? "") {
+  const candidates = isAbsolute(name) ? [name] : path.split(delimiter).filter(Boolean).map((dir) => join3(dir, name));
+  for (const candidate of candidates) {
+    try {
+      await access(candidate, constants.X_OK);
+      if ((await stat3(candidate)).isFile()) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function findClis(config) {
+  const found = {};
+  for (const cli of CLI_NAMES) {
+    const candidates = [
+      config.agent.cli === cli ? config.agent.binPath : null,
+      config.assistant.agent === cli ? config.assistant.binPath : null,
+      cli
+    ].filter((candidate) => candidate !== null);
+    found[cli] = null;
+    for (const candidate of candidates) {
+      found[cli] = await findExecutable(candidate);
+      if (found[cli]) break;
+    }
+  }
+  return found;
+}
+async function hasArchive(config) {
+  try {
+    return (await readdir2(config.archiveDir)).some((name) => name.endsWith(".json"));
+  } catch {
+    return false;
+  }
+}
+async function exists(path) {
+  try {
+    await stat3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function firstBriefPending(config) {
+  return !await exists(config.itemsFile) && !await hasArchive(config);
+}
+async function setupState(config, opts) {
+  let sources = null;
+  try {
+    sources = await readFile8(config.sourcesFile, "utf8");
+  } catch {
+    sources = null;
+  }
+  const supported = process.platform === "darwin";
+  return {
+    // The file, not whether it parsed: a brief that is there but broken is a
+    // problem for its banner to report, not a store to set up from scratch. The
+    // agent's clock asks the same question.
+    needed: await firstBriefPending(config),
+    profile: config.profile,
+    profileChosen: opts.profileChosen,
+    sources: { exists: sources !== null, placeholders: sources === null ? 0 : placeholdersIn(sources) },
+    clis: await findClis(config),
+    calendar: {
+      supported,
+      built: supported && await exists(config.calendar.appPath),
+      chosen: config.calendar.names.length,
+      buildCommand: command("build-calendar")
+    }
+  };
+}
+var identity = null;
+function detectIdentity(config) {
+  identity ??= (async () => {
+    const [user, email] = await Promise.all([
+      run5(config.github.ghPath, ["api", "user", "--jq", '[.login, .name // ""] | join("\\n")'], { timeout: 5e3 }).then(
+        ({ stdout }) => stdout.split("\n"),
+        () => []
+      ),
+      run5("git", ["config", "--global", "user.email"], { timeout: 2e3 }).then(
+        ({ stdout }) => stdout.trim() || null,
+        () => null
+      )
+    ]);
+    return {
+      login: config.github.accounts[0] ?? (user[0]?.trim() || null),
+      name: user[1]?.trim() || null,
+      email
+    };
+  })();
+  return identity;
+}
+function fillIdentity(template, who) {
+  let text = template;
+  if (who.name) text = text.replaceAll("`Your Name`", `\`${who.name}\``);
+  if (who.email) text = text.replaceAll("`you@example.com`", `\`${who.email}\``).replaceAll("`you@personal.example`", `\`${who.email}\``);
+  if (who.login) text = text.replaceAll("`your-github-login`", `\`${who.login}\``);
+  return text;
+}
+
+// src/shellpath.ts
+import { spawn as spawn3 } from "node:child_process";
+import { userInfo } from "node:os";
+var START = "__DAILY_FOCUS_PATH_START__";
+var END = "__DAILY_FOCUS_PATH_END__";
+var SHELL_TIMEOUT_MS = 5e3;
+var defaultExec = (file, args, { timeout }) => new Promise((resolve2, reject) => {
+  const child = spawn3(file, args, { detached: true, stdio: ["ignore", "pipe", "ignore"] });
+  let output = "";
+  let settled = false;
+  const finish = (error) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    if (error) reject(error);
+    else resolve2(output);
+  };
+  const timer = setTimeout(() => {
+    try {
+      if (child.pid) process.kill(-child.pid, "SIGKILL");
+    } catch {
+    }
+    finish(new Error(`${file} took longer than ${timeout} ms`));
+  }, timeout);
+  child.stdout.setEncoding("utf8").on("data", (chunk) => output += chunk);
+  child.on("error", (error) => finish(error));
+  child.on("close", () => finish(null));
+});
+function shellCandidates(envShell, loginShell, platform2) {
+  const fallback = platform2 === "darwin" ? "/bin/zsh" : platform2 === "linux" ? "/bin/bash" : void 0;
+  const shells = [];
+  for (const shell of [envShell, loginShell, fallback]) {
+    const trimmed = shell?.trim();
+    if (trimmed && !shells.includes(trimmed)) shells.push(trimmed);
+  }
+  return shells;
+}
+function pathBetweenMarkers(output) {
+  const start = output.indexOf(START);
+  if (start === -1) return null;
+  const from = start + START.length;
+  const end = output.indexOf(END, from);
+  if (end === -1) return null;
+  const value = output.slice(from, end).trim();
+  return value === "" ? null : value;
+}
+function mergePaths(preferred, inherited) {
+  const entries = [];
+  for (const value of [preferred, inherited]) {
+    for (const entry of (value ?? "").split(":")) {
+      if (entry !== "" && !entries.includes(entry)) entries.push(entry);
+    }
+  }
+  return entries.join(":");
+}
+async function readLoginShellPath(shell, exec) {
+  const command3 = `printf '%s\\n' '${START}'; printenv PATH || true; printf '%s\\n' '${END}'`;
+  return pathBetweenMarkers(await exec(shell, ["-ilc", command3], { timeout: SHELL_TIMEOUT_MS }));
+}
+async function readLaunchctlPath(exec) {
+  try {
+    const value = (await exec("/bin/launchctl", ["getenv", "PATH"], { timeout: 2e3 })).trim();
+    return value === "" ? null : value;
+  } catch {
+    return null;
+  }
+}
+function currentLoginShell() {
+  try {
+    return userInfo().shell ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function hydratePath(env = process.env, platform2 = process.platform, exec = defaultExec, loginShell = currentLoginShell()) {
+  if (platform2 === "win32") return null;
+  let found = null;
+  let from = null;
+  for (const shell of shellCandidates(env.SHELL, loginShell, platform2)) {
+    try {
+      found = await readLoginShellPath(shell, exec);
+    } catch {
+    }
+    if (found) {
+      from = shell;
+      break;
+    }
+  }
+  if (!found && platform2 === "darwin") {
+    found = await readLaunchctlPath(exec);
+    if (found) from = "launchctl";
+  }
+  const merged = mergePaths(found, env.PATH);
+  if (merged !== "") env.PATH = merged;
+  return from;
+}
+
+// src/server.ts
+var PUBLIC_DIR = resolve(fileURLToPath(new URL("../public", import.meta.url)));
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2"
+};
+var TEXT_FILES = {
+  "/api/text/focus": { file: "focusFile", name: "focus.md" },
+  "/api/text/sources": { file: "sourcesFile", name: "sources.md" }
+};
+var VALID_ACTIONS = /* @__PURE__ */ new Set([
+  "done",
+  "snooze",
+  "dismiss",
+  "reopen",
+  "note"
+]);
+var MAX_BODY_BYTES = 64 * 1024;
+var PRESENCE_POLL_MS = 3e4;
+var AGENT_CLOCK_MS = 3e4;
+function sendJSON(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": Buffer.byteLength(payload),
+    // The dashboard is a long-lived tab; never let it show a cached brief.
+    "cache-control": "no-store"
+  });
+  res.end(payload);
+}
+function sendState(res, state) {
+  sendJSON(res, 200, state);
+}
+async function readBody(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > MAX_BODY_BYTES) throw new Error("request body too large");
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function serveStatic(res, urlPath) {
+  const relative = normalize(decodeURIComponent(urlPath === "/" ? "/index.html" : urlPath));
+  const filePath = join4(PUBLIC_DIR, relative);
+  if (filePath !== PUBLIC_DIR && !filePath.startsWith(PUBLIC_DIR + sep)) {
+    res.writeHead(403).end("Forbidden");
+    return;
+  }
+  try {
+    const info = await stat4(filePath);
+    if (!info.isFile()) throw new Error("not a file");
+    res.writeHead(200, {
+      "content-type": MIME[extname(filePath)] ?? "application/octet-stream",
+      "content-length": info.size,
+      "cache-control": "no-cache"
+    });
+    createReadStream(filePath).pipe(res);
+  } catch {
+    res.writeHead(404, { "content-type": "text/plain; charset=utf-8" }).end("Not found");
+  }
+}
+async function readJsonObject(req, res) {
+  let body;
+  try {
+    body = JSON.parse(await readBody(req));
+  } catch (err) {
+    sendJSON(res, 400, { error: `invalid JSON body: ${err.message}` });
+    return null;
+  }
+  if (typeof body !== "object" || body === null || Array.isArray(body)) {
+    sendJSON(res, 400, { error: "body must be an object" });
+    return null;
+  }
+  return body;
+}
+function configure(sources) {
+  const warnings = [];
+  if (sources.settingsError) {
+    warnings.push(`${sources.settingsError}. The dashboard is ignoring it; saving on the settings page writes a fresh one.`);
+  }
+  try {
+    return { config: loadConfig(layerEnv(sources)), warnings };
+  } catch (error) {
+    if (Object.keys(sources.settings).length === 0) throw error;
+    warnings.push(
+      `\`${sources.settingsPath}\` has a value the dashboard can't use, so it is ignoring the whole file: ${error.message}. Fix it on the settings page.`
+    );
+    return { config: loadConfig(layerEnv(sources, {})), warnings };
+  }
+}
+function statusOf(state, config) {
+  const last = state.agentRun.last;
+  return {
+    dataDir: config.dataDir,
+    profile: config.profile,
+    setupNeeded: state.setup.needed,
+    restartPending: state.restart !== null,
+    brief: {
+      generatedAt: state.brief.generatedAt,
+      ageHours: state.brief.ageHours,
+      stale: state.brief.stale,
+      open: state.stats.open
+    },
+    agent: {
+      enabled: state.agentRun.enabled,
+      running: last?.status === "running",
+      nextRunAt: state.agentRun.schedule?.nextRunAt ?? null,
+      last: last ? { id: last.id, status: last.status, startedAt: last.startedAt, endedAt: last.endedAt, error: last.error } : null
+    },
+    waitingOnYou: state.board.enabled ? state.board.counts.you : 0
+  };
+}
+async function startServer(env, options = {}) {
+  const processEnv = env ?? process.env;
+  const dotenv = env ? {} : readDotEnv();
+  const readSources = () => envSources(processEnv, dotenv);
+  const { config, warnings: configWarnings } = configure(readSources());
+  for (const warning of configWarnings) console.warn(`[daily-focus] ${warning}`);
+  const store = new Store(config);
+  await store.ensureDataDir();
+  for (const outcome of await linkStore(config)) {
+    if (outcome.result === "linked") console.log(`[daily-focus] linked ${describeLink(config, outcome)}`);
+    if (outcome.result === "failed") console.warn(`[daily-focus] could not link ${outcome.name}: ${outcome.detail}`);
+  }
+  let restart = null;
+  let restarting = false;
+  let settingsWrites = Promise.resolve();
+  await stat4(join4(PUBLIC_DIR, "app.js")).catch(() => {
+    console.warn(
+      PACKAGED ? "[daily-focus] public/app.js is missing from the package: reinstall it" : "[daily-focus] public/app.js is missing: run `npm run build` (npm start does so on its own)"
+    );
+  });
+  const subscribers = /* @__PURE__ */ new Set();
+  let assetVersion = await computeAssetVersion(PUBLIC_DIR);
+  const board = new Board(config, () => void broadcast());
+  const calendar = new CalendarBoard(config, () => void broadcast());
+  const tickets = new TicketBoard(config, () => void broadcast());
+  const assistant = new Assistant(config, {
+    onChange: () => {
+      void broadcast();
+      restartWhenIdle();
+    }
+  });
+  const agent = new AgentRunner(config, {
+    onChange: () => {
+      void broadcast();
+      restartWhenIdle();
+    }
+  });
+  function requestRestart() {
+    restart = options.onRestart ? "waiting" : "manual";
+    restartWhenIdle();
+  }
+  function restartWhenIdle() {
+    if (restart !== "waiting" || restarting || agent.busy || assistant.busy) return;
+    restarting = true;
+    setImmediate(() => options.onRestart?.());
+  }
+  async function buildState() {
+    const actions = await store.readActions();
+    const now = /* @__PURE__ */ new Date();
+    const [state, linkWarning] = await Promise.all([
+      store.getState(now, actions, calendar.state()),
+      // A link that can't be read is no reason to withhold the page.
+      storeLinkWarning(config).catch(() => null)
+    ]);
+    const sources = readSources();
+    const setup = await setupState(config, {
+      profileChosen: Boolean(layerEnv(sources).DAILY_FOCUS_PROFILE?.trim())
+    });
+    return {
+      ...state,
+      board: board.view(actions, now),
+      tickets: tickets.view(actions, now),
+      assistant: assistant.view(),
+      agentRun: agent.view(now),
+      setupWarnings: [...configWarnings, ...linkWarning ? [linkWarning] : []],
+      restart,
+      setup,
+      assetVersion
+    };
+  }
+  async function broadcast(prebuilt) {
+    if (subscribers.size === 0) return;
+    let payload;
+    try {
+      payload = JSON.stringify(prebuilt ?? await buildState());
+    } catch (err) {
+      console.error(`[daily-focus] could not build state: ${err.message}`);
+      return;
+    }
+    const frame = `event: state
+data: ${payload}
+
+`;
+    for (const res of subscribers) res.write(frame);
+  }
+  await store.archiveCurrentBrief();
+  const stopWatching = watchDataDir(
+    config.dataDir,
+    () => {
+      void store.archiveCurrentBrief().then(() => broadcast());
+    },
+    // The timer re-stamps its own file every poll and the two boards rewrite
+    // prs.json and tickets.json every fetch; that's this process talking to
+    // itself, and all three already broadcast when something actually changed.
+    {
+      ignore: [
+        basename(config.sessionFile),
+        basename(tempPathFor(config.sessionFile)),
+        basename(config.pullsFile),
+        basename(tempPathFor(config.pullsFile)),
+        basename(config.ticketsFile),
+        basename(tempPathFor(config.ticketsFile)),
+        // Appended by this process, which broadcasts on its own.
+        basename(config.assistantLogFile),
+        basename(config.agentLogFile)
+      ]
+    }
+  );
+  const stopWatchingAssets = watchDataDir(PUBLIC_DIR, () => {
+    void computeAssetVersion(PUBLIC_DIR).then((next) => {
+      if (next === assetVersion) return;
+      assetVersion = next;
+      void broadcast();
+    });
+  });
+  let sessionTick = null;
+  function scheduleSessionTick(endsAt) {
+    if (sessionTick) clearTimeout(sessionTick);
+    sessionTick = null;
+    if (!endsAt) return;
+    const delay = new Date(endsAt).getTime() - Date.now();
+    if (delay <= 0 || delay > 36e5) return;
+    sessionTick = setTimeout(() => void broadcast(), delay);
+    sessionTick.unref();
+  }
+  async function checkPresence() {
+    let closed;
+    try {
+      closed = await reconcileSession(config, readIdleSeconds);
+    } catch (err) {
+      console.error(`[daily-focus] presence check failed: ${err.message}`);
+      return;
+    }
+    if (!closed) return;
+    console.log(
+      `[daily-focus] stopped "${closed.title}" at ${closed.endedAt} after ${closed.actualMinutes} min \u2014 machine untouched since then`
+    );
+    scheduleSessionTick(null);
+    await broadcast();
+  }
+  await checkPresence();
+  await assistant.start();
+  await agent.start();
+  async function clockTick() {
+    if (restart === "waiting" || await firstBriefPending(config)) return;
+    await agent.tick();
+  }
+  void clockTick();
+  const agentClock = setInterval(() => {
+    void clockTick();
+  }, AGENT_CLOCK_MS);
+  agentClock.unref();
+  scheduleSessionTick((await buildState()).session.active?.endsAt ?? null);
+  void board.start().catch((err) => {
+    console.error(`[daily-focus] pull request board failed to start: ${err.message}`);
+  });
+  void calendar.start().catch((err) => {
+    console.error(`[daily-focus] live agenda failed to start: ${err.message}`);
+  });
+  void tickets.start().catch((err) => {
+    console.error(`[daily-focus] jira ticket board failed to start: ${err.message}`);
+  });
+  const heartbeat = setInterval(() => {
+    void broadcast();
+  }, 6e4);
+  heartbeat.unref();
+  const presencePoll = setInterval(() => {
+    void checkPresence();
+  }, PRESENCE_POLL_MS);
+  presencePoll.unref();
+  const server = createServer((req, res) => {
+    void handle(req, res).catch((err) => {
+      console.error(`[daily-focus] ${req.method} ${req.url} failed:`, err);
+      if (!res.headersSent) sendJSON(res, 500, { error: err.message });
+      else res.end();
+    });
+  });
+  async function handle(req, res) {
+    const refused = refusal(req, config.host);
+    if (refused) {
+      sendJSON(res, refused.status, { error: refused.error });
+      return;
+    }
+    const url2 = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    const path = url2.pathname;
+    if (restart === "waiting" && req.method === "POST" && ["/api/agent/run", "/api/agent/ask", "/api/assistant/ask"].includes(path)) {
+      sendJSON(res, 409, { error: "the dashboard is restarting to apply new settings; try again in a moment" });
+      return;
+    }
+    if (path === "/api/state" && req.method === "GET") {
+      sendState(res, await buildState());
+      return;
+    }
+    if (path === "/api/events" && req.method === "GET") {
+      res.writeHead(200, {
+        "content-type": "text/event-stream",
+        "cache-control": "no-store",
+        connection: "keep-alive",
+        // Proxies aside, this stops any intermediary from buffering the stream.
+        "x-accel-buffering": "no"
+      });
+      res.write(`event: state
+data: ${JSON.stringify(await buildState())}
+
+`);
+      subscribers.add(res);
+      board.setAudience(subscribers.size);
+      calendar.setAudience(subscribers.size);
+      tickets.setAudience(subscribers.size);
+      const keepAlive = setInterval(() => res.write(": ping\n\n"), 25e3);
+      keepAlive.unref();
+      req.on("close", () => {
+        clearInterval(keepAlive);
+        subscribers.delete(res);
+        board.setAudience(subscribers.size);
+        calendar.setAudience(subscribers.size);
+        tickets.setAudience(subscribers.size);
+      });
+      return;
+    }
+    if (path === "/api/board/refresh" && req.method === "POST") {
+      await board.refresh();
+      sendState(res, await buildState());
+      return;
+    }
+    if (path === "/api/tickets/refresh" && req.method === "POST") {
+      await tickets.refresh();
+      sendState(res, await buildState());
+      return;
+    }
+    if (path === "/api/calendar/refresh" && req.method === "POST") {
+      await calendar.refresh();
+      sendState(res, await buildState());
+      return;
+    }
+    if (path === "/api/tickets/transition" && req.method === "POST") {
+      let body;
+      try {
+        body = JSON.parse(await readBody(req));
+      } catch (err) {
+        sendJSON(res, 400, { error: `invalid JSON body: ${err.message}` });
+        return;
+      }
+      if (typeof body !== "object" || body === null) {
+        sendJSON(res, 400, { error: "body must be an object" });
+        return;
+      }
+      const { key, status } = body;
+      if (typeof key !== "string" || !/^[A-Za-z][A-Za-z0-9_]*-\d+$/.test(key.trim())) {
+        sendJSON(res, 400, { error: '"key" must be a single Jira work item key, e.g. PROJ-8842' });
+        return;
+      }
+      if (typeof status !== "string" || status.trim() === "") {
+        sendJSON(res, 400, { error: '"status" is required' });
+        return;
+      }
+      try {
+        await tickets.transition(key.trim(), status.trim());
+      } catch (err) {
+        sendJSON(res, 409, { error: err.message });
+        return;
+      }
+      const state = await buildState();
+      sendState(res, state);
+      void broadcast(state);
+      return;
+    }
+    if (path === "/api/assistant/ask" && req.method === "POST") {
+      let body;
+      try {
+        body = JSON.parse(await readBody(req));
+      } catch (err) {
+        sendJSON(res, 400, { error: `invalid JSON body: ${err.message}` });
+        return;
+      }
+      if (typeof body !== "object" || body === null) {
+        sendJSON(res, 400, { error: "body must be an object" });
+        return;
+      }
+      const { id, action, text } = body;
+      if (typeof id !== "string" || id === "") {
+        sendJSON(res, 400, { error: '"id" is required' });
+        return;
+      }
+      if (action !== void 0 && typeof action !== "string") {
+        sendJSON(res, 400, { error: '"action" must be a quick action id' });
+        return;
+      }
+      if (text !== void 0 && typeof text !== "string") {
+        sendJSON(res, 400, { error: '"text" must be a string' });
+        return;
+      }
+      if (!assistant.enabled) {
+        sendJSON(res, 409, { error: "the assistant is off; set DAILY_FOCUS_ASSISTANT to claude or codex" });
+        return;
+      }
+      const current = await buildState();
+      const context = {
+        item: current.items.find((item) => item.id === id),
+        pull: current.board.rows.find((row) => row.id === id),
+        ticket: current.tickets.rows.find((row) => row.id === id) ?? current.tickets.inProgress.find((row) => row.id === id)
+      };
+      if (!context.item && !context.pull && !context.ticket) {
+        sendJSON(res, 404, { error: `no item with id ${id}` });
+        return;
+      }
+      try {
+        await assistant.ask({ itemId: id, action, text }, context);
+      } catch (err) {
+        sendJSON(res, 409, { error: err.message });
+        return;
+      }
+      const state = await buildState();
+      sendState(res, state);
+      void broadcast(state);
+      return;
+    }
+    if (path === "/api/agent/run" && req.method === "POST") {
+      try {
+        await agent.run();
+      } catch (err) {
+        sendJSON(res, 409, { error: err.message });
+        return;
+      }
+      const state = await buildState();
+      sendState(res, state);
+      void broadcast(state);
+      return;
+    }
+    if (path === "/api/agent/ask" && req.method === "POST") {
+      let body;
+      try {
+        body = JSON.parse(await readBody(req));
+      } catch (err) {
+        sendJSON(res, 400, { error: `invalid JSON body: ${err.message}` });
+        return;
+      }
+      const { run: run6, text } = typeof body === "object" && body !== null ? body : {};
+      if (typeof run6 !== "string" || run6 === "") {
+        sendJSON(res, 400, { error: "run must be a run id" });
+        return;
+      }
+      if (typeof text !== "string" || text.trim() === "") {
+        sendJSON(res, 400, { error: "text must be the question to ask" });
+        return;
+      }
+      try {
+        await agent.ask(run6, text);
+      } catch (err) {
+        sendJSON(res, 409, { error: err.message });
+        return;
+      }
+      const state = await buildState();
+      sendState(res, state);
+      void broadcast(state);
+      return;
+    }
+    if (path === "/api/agent/stop" && req.method === "POST") {
+      await agent.stop();
+      sendState(res, await buildState());
+      return;
+    }
+    if (path === "/api/assistant/stop" && req.method === "POST") {
+      let body;
+      try {
+        body = JSON.parse(await readBody(req));
+      } catch (err) {
+        sendJSON(res, 400, { error: `invalid JSON body: ${err.message}` });
+        return;
+      }
+      const { id } = typeof body === "object" && body !== null ? body : {};
+      if (typeof id !== "string" || id === "") {
+        sendJSON(res, 400, { error: '"id" is required' });
+        return;
+      }
+      await assistant.stop(id);
+      sendState(res, await buildState());
+      return;
+    }
+    if (path === "/api/actions" && req.method === "POST") {
+      let body;
+      try {
+        body = JSON.parse(await readBody(req));
+      } catch (err) {
+        sendJSON(res, 400, { error: `invalid JSON body: ${err.message}` });
+        return;
+      }
+      if (typeof body !== "object" || body === null) {
+        sendJSON(res, 400, { error: "body must be an object" });
+        return;
+      }
+      const { id, action, until, text } = body;
+      if (typeof id !== "string" || id === "") {
+        sendJSON(res, 400, { error: '"id" is required' });
+        return;
+      }
+      if (typeof action !== "string" || !VALID_ACTIONS.has(action)) {
+        sendJSON(res, 400, { error: `"action" must be one of ${[...VALID_ACTIONS].join(", ")}` });
+        return;
+      }
+      if (action === "snooze" && until !== void 0 && !/^\d{4}-\d{2}-\d{2}$/.test(String(until))) {
+        sendJSON(res, 400, { error: '"until" must be YYYY-MM-DD' });
+        return;
+      }
+      if (action === "note" && (typeof text !== "string" || text.trim() === "")) {
+        sendJSON(res, 400, { error: '"text" is required for a note' });
+        return;
+      }
+      const record = { id, action, at: (/* @__PURE__ */ new Date()).toISOString() };
+      if (action === "snooze" && typeof until === "string") record.until = until;
+      if (action === "note" && typeof text === "string") record.text = text.trim();
+      await store.appendAction(record);
+      const state = await buildState();
+      sendState(res, state);
+      void broadcast(state);
+      return;
+    }
+    if (path === "/api/session" && req.method === "POST") {
+      let body;
+      try {
+        body = JSON.parse(await readBody(req));
+      } catch (err) {
+        sendJSON(res, 400, { error: `invalid JSON body: ${err.message}` });
+        return;
+      }
+      if (typeof body !== "object" || body === null) {
+        sendJSON(res, 400, { error: "body must be an object" });
+        return;
+      }
+      const { action, id, minutes } = body;
+      if (action === "stop") {
+        await stopSession(config);
+      } else if (action === "start") {
+        if (typeof id !== "string" || id === "") {
+          sendJSON(res, 400, { error: '"id" is required to start a session' });
+          return;
+        }
+        const { brief } = await store.readBrief();
+        const item = brief?.items.find((candidate) => candidate.id === id);
+        if (!item) {
+          sendJSON(res, 404, { error: `no item with id ${id}` });
+          return;
+        }
+        const requested = typeof minutes === "number" && Number.isFinite(minutes) ? Math.round(minutes) : config.sessionMinutes;
+        if (requested < 1 || requested > 120) {
+          sendJSON(res, 400, { error: '"minutes" must be between 1 and 120' });
+          return;
+        }
+        await startSession(config, {
+          id,
+          title: item.title,
+          minutes: requested,
+          advancesObjective: item.advancesObjective === true
+        });
+      } else {
+        sendJSON(res, 400, { error: '"action" must be "start" or "stop"' });
+        return;
+      }
+      const state = await buildState();
+      sendState(res, state);
+      scheduleSessionTick(state.session.active?.endsAt ?? null);
+      void broadcast(state);
+      return;
+    }
+    if (path === "/api/settings" && req.method === "GET") {
+      sendJSON(res, 200, { ...describeSettings(readSources()), restart });
+      return;
+    }
+    if (path === "/api/settings" && req.method === "POST") {
+      const body = await readJsonObject(req, res);
+      if (!body) return;
+      const values = body.values;
+      if (typeof values !== "object" || values === null || Array.isArray(values)) {
+        sendJSON(res, 400, { error: '"values" must be an object of settings' });
+        return;
+      }
+      const saved = settingsWrites.then(async () => {
+        const sources = readSources();
+        const applied = applySettingsChange(sources, values);
+        if ("error" in applied) return applied.error;
+        const changed = JSON.stringify(Object.entries(applied.settings).sort()) !== JSON.stringify(Object.entries(sources.settings).sort());
+        if (changed) {
+          await saveSettings(sources.settingsPath, applied.settings);
+          requestRestart();
+        }
+        return null;
+      });
+      settingsWrites = saved.catch(() => {
+      });
+      const refused2 = await saved;
+      if (refused2) {
+        sendJSON(res, 400, { error: refused2 });
+        return;
+      }
+      sendJSON(res, 200, { ...describeSettings(readSources()), restart });
+      void broadcast();
+      return;
+    }
+    const textFile = TEXT_FILES[path];
+    if (textFile && req.method === "GET") {
+      const { text, version } = await readEditable(config[textFile.file]);
+      const template = textFile.file === "focusFile" ? FOCUS_TEMPLATE : text === null ? fillIdentity(sourcesTemplate(config.profile), await detectIdentity(config)) : sourcesTemplate(config.profile);
+      sendJSON(res, 200, { text, version, template });
+      return;
+    }
+    if (textFile && req.method === "POST") {
+      const body = await readJsonObject(req, res);
+      if (!body) return;
+      const { text, version } = body;
+      if (typeof text !== "string" || typeof version !== "string") {
+        sendJSON(res, 400, { error: '"text" and "version" are required: the text, and the version it was edited from' });
+        return;
+      }
+      const result = await saveEditable(config[textFile.file], text, version);
+      if (!result.saved) {
+        sendJSON(res, 409, {
+          error: `${textFile.name} changed ${result.version === ABSENT ? "on disk: it was deleted" : "on disk"} since you opened it`,
+          text: result.text,
+          version: result.version
+        });
+        return;
+      }
+      sendJSON(res, 200, { version: result.version });
+      void broadcast();
+      return;
+    }
+    if (path === "/api/focus/objective" && req.method === "POST") {
+      const body = await readJsonObject(req, res);
+      if (!body) return;
+      const { objective, blocker } = body;
+      for (const [name, value] of [["objective", objective], ["blocker", blocker]]) {
+        if (value !== void 0 && value !== null && typeof value !== "string") {
+          sendJSON(res, 400, { error: `"${name}" must be text, or null to clear it` });
+          return;
+        }
+      }
+      const current = await readEditable(config.focusFile);
+      const next = setFocusFields(
+        current.text,
+        { objective: objective ?? null, blocker: blocker ?? null },
+        FOCUS_TEMPLATE
+      );
+      const result = await saveEditable(config.focusFile, next, current.version);
+      if (!result.saved) {
+        sendJSON(res, 409, { error: "focus.md changed on disk while saving; try again" });
+        return;
+      }
+      const state = await buildState();
+      sendState(res, state);
+      void broadcast(state);
+      return;
+    }
+    if (path === "/api/calendars/list" && req.method === "POST") {
+      try {
+        const facts = await runHelper(config.calendar.appPath, []);
+        const seen = /* @__PURE__ */ new Set();
+        const calendars = facts.calendars.filter((entry) => !seen.has(`${entry.title}
+${entry.source}`) && seen.add(`${entry.title}
+${entry.source}`)).map(({ title, source }) => ({ title, source })).sort((a, b) => a.title.localeCompare(b.title));
+        sendJSON(res, 200, { calendars });
+      } catch (err) {
+        sendJSON(res, 409, { error: err.message });
+      }
+      return;
+    }
+    if (path === "/api/status" && req.method === "GET") {
+      sendJSON(res, 200, statusOf(await buildState(), config));
+      return;
+    }
+    if (path === "/api/health" && req.method === "GET") {
+      sendJSON(res, 200, { ok: true, dataDir: config.dataDir });
+      return;
+    }
+    if (path === "/favicon.svg" && (req.method === "GET" || req.method === "HEAD")) {
+      const svg = faviconSvg(config.profile);
+      res.writeHead(200, {
+        "content-type": "image/svg+xml",
+        "content-length": Buffer.byteLength(svg),
+        "cache-control": "no-cache"
+      });
+      res.end(req.method === "HEAD" ? void 0 : svg);
+      return;
+    }
+    if (req.method === "GET" || req.method === "HEAD") {
+      await serveStatic(res, path);
+      return;
+    }
+    sendJSON(res, 405, { error: "method not allowed" });
+  }
+  async function stopEverything() {
+    clearInterval(heartbeat);
+    clearInterval(presencePoll);
+    clearInterval(agentClock);
+    if (sessionTick) clearTimeout(sessionTick);
+    board.stop();
+    calendar.stop();
+    tickets.stop();
+    await assistant.close();
+    await agent.close();
+    stopWatching();
+    stopWatchingAssets();
+    for (const res of subscribers) res.end();
+    subscribers.clear();
+  }
+  try {
+    await new Promise((resolvePromise, reject) => {
+      server.once("error", reject);
+      server.listen(config.port, config.host, () => {
+        server.off("error", reject);
+        resolvePromise();
+      });
+    });
+  } catch (err) {
+    await stopEverything();
+    if (err.code === "EADDRINUSE") {
+      throw new PortInUseError(config.host, config.port);
+    }
+    throw err;
+  }
+  const address = server.address();
+  const port = typeof address === "object" && address !== null ? address.port : config.port;
+  const shown = config.host === "0.0.0.0" ? "127.0.0.1" : config.host === "::" ? "[::1]" : config.host.includes(":") ? `[${config.host}]` : config.host;
+  const url = `http://${shown}:${port}`;
+  console.log(`[daily-focus] dashboard  ${url}`);
+  console.log(`[daily-focus] store      ${config.dataDir}`);
+  return {
+    url,
+    async close() {
+      await stopEverything();
+      await new Promise((done, fail) => {
+        server.close((err) => err ? fail(err) : done());
+        server.closeIdleConnections();
+        setTimeout(() => server.closeAllConnections(), 1e3).unref();
+      });
+    }
+  };
+}
+var PortInUseError = class extends Error {
+  constructor(host, port) {
+    super(
+      `port ${port} on ${host} is already in use. If that is this dashboard, running as a service or in another terminal, open http://${host.includes(":") ? `[${host}]` : host}:${port}. To run this one beside it, give it another port with DAILY_FOCUS_PORT or --port.`
+    );
+    this.name = "PortInUseError";
+  }
+};
+async function runServer(options = {}) {
+  await hydratePath();
+  let current = null;
+  let stopping = false;
+  async function start() {
+    current = await startServer(void 0, { onRestart: () => void restart() });
+  }
+  async function restart() {
+    console.log("[daily-focus] restarting to apply new settings");
+    const previous = current;
+    current = null;
+    await previous?.close();
+    if (stopping) return;
+    try {
+      await start();
+    } catch (err) {
+      console.error(`[daily-focus] could not restart: ${err.message}`);
+      process.exit(1);
+    }
+  }
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.on(signal, () => {
+      stopping = true;
+      void (current?.close() ?? Promise.resolve()).then(() => process.exit(0));
+    });
+  }
+  try {
+    await start();
+  } catch (err) {
+    if (!(err instanceof PortInUseError)) throw err;
+    console.error(`[daily-focus] ${err.message}`);
+    process.exit(1);
+  }
+  options.onStarted?.(current?.url ?? "");
+}
+if (ranDirectly(import.meta.url)) {
+  await runServer();
+}
+export {
+  PortInUseError,
+  runServer,
+  startServer
+};