daily-focus 1.2.0-dev.10 → 1.2.0-dev.12

package/dist/{server-WQYUOKB3.js → server-RKEB6FDK.js}

@@ -3,10 +3,13 @@ import {
   Assistant,
   AutoAsk,
   CodexGate,
+  codexLatestModel,
   codexVersionWarning,
+  computerUseOff,
   countBoard,
+  refusalFor,
   resolveBoard
-} from "./chunk-ODJGQCM3.js";
+} from "./chunk-FPBY3TAW.js";
 import {
   FOCUS_TEMPLATE,
   sourcesTemplate
@@ -14,7 +17,7 @@ import {
 import {
   TimeZoneKeeper,
   validZone
-} from "./chunk-Z4SFMMRQ.js";
+} from "./chunk-HEP46XRX.js";
 import {
   describeLink,
   linkStore,
@@ -27,7 +30,7 @@ import {
   foldActionLog,
   tempPathFor,
   writeJsonAtomic
-} from "./chunk-RZNQJ6UG.js";
+} from "./chunk-D3JAWEF7.js";
 import {
   CLI_NAMES,
   LAUNCH_SETTINGS,
@@ -35,6 +38,7 @@ import {
   briefWritingTools,
   describeTime,
   envSources,
+  expandHome,
   laterISO,
   layerEnv,
   loadConfig,
@@ -42,7 +46,7 @@ import {
   readDotEnv,
   resolveSchedule,
   scheduledRunDue
-} from "./chunk-J7ZYVUG6.js";
+} from "./chunk-DPMHC72S.js";
 import {
   PACKAGED,
   command,
@@ -54,19 +58,259 @@ import {
 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 { basename, extname, join as join6, normalize, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 
+// src/clis.ts
+import { execFile as execFile2 } from "node:child_process";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/setup.ts
+import { execFile } from "node:child_process";
+import { access, constants, readdir, readFile, stat } from "node:fs/promises";
+import { delimiter, isAbsolute, join } from "node:path";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+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) => join(dir, name));
+  for (const candidate of candidates) {
+    try {
+      await access(candidate, constants.X_OK);
+      if ((await stat(candidate)).isFile()) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function findClis(config) {
+  const found = {};
+  for (const cli2 of CLI_NAMES) {
+    const candidates = [
+      config.agent.cli === cli2 ? config.agent.binPath : null,
+      config.assistant.agent === cli2 ? config.assistant.binPath : null,
+      cli2
+    ].filter((candidate) => candidate !== null);
+    found[cli2] = null;
+    for (const candidate of candidates) {
+      found[cli2] = await findExecutable(candidate);
+      if (found[cli2]) break;
+    }
+  }
+  return found;
+}
+async function hasArchive(config) {
+  try {
+    return (await readdir(config.archiveDir)).some((name) => name.endsWith(".json"));
+  } catch {
+    return false;
+  }
+}
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function firstBriefPending(config) {
+  return !await exists(config.itemsFile) && !await hasArchive(config);
+}
+async function setupState(config) {
+  let sources = null;
+  try {
+    sources = await readFile(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,
+    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 ghLogins(json) {
+  try {
+    const hosts = JSON.parse(json).hosts ?? {};
+    const accounts = Array.isArray(hosts["github.com"]) ? hosts["github.com"] : [];
+    return accounts.filter((account) => typeof account.login === "string" && account.state !== "error").sort((a, b) => Number(b.active === true) - Number(a.active === true)).map((account) => account.login);
+  } catch {
+    return [];
+  }
+}
+function detectIdentity(config) {
+  identity ??= (async () => {
+    const [user, logins, email] = await Promise.all([
+      run(config.github.ghPath, ["api", "user", "--jq", '[.login, .name // ""] | join("\\n")'], { timeout: 5e3 }).then(
+        ({ stdout }) => stdout.split("\n"),
+        () => []
+      ),
+      run(config.github.ghPath, ["auth", "status", "--json", "hosts"], { timeout: 5e3 }).then(
+        ({ stdout }) => ghLogins(stdout),
+        () => []
+      ),
+      run("git", ["config", "--global", "user.email"], { timeout: 2e3 }).then(
+        ({ stdout }) => stdout.trim() || null,
+        () => null
+      )
+    ]);
+    const login = config.github.accounts[0] ?? (user[0]?.trim() || null);
+    return {
+      login,
+      logins: logins.length ? logins : login ? [login] : [],
+      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/clis.ts
+var CLI_PREFERENCE = ["codex", "claude"];
+var PROBE_TIMEOUT_MS = 1e4;
+var defaultProbe = (file, args) => new Promise((resolve2, reject) => {
+  execFile2(file, [...args], { timeout: PROBE_TIMEOUT_MS, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+    const code = err ? typeof err.code === "number" ? err.code : null : 0;
+    if (err && err.code === "ENOENT") return reject(err);
+    resolve2({ code, out: `${stdout}
+${stderr}`.trim() });
+  });
+});
+var CLI_LABEL = { claude: "Claude Code", codex: "Codex" };
+function knownLocations(cli2, home = homedir()) {
+  const common = [join2(home, ".local", "bin", cli2), `/opt/homebrew/bin/${cli2}`, `/usr/local/bin/${cli2}`];
+  return cli2 === "codex" ? [join2(home, ".codex", "packages", "standalone", "current", "bin", "codex"), ...common] : [...common, join2(home, ".claude", "local", "claude")];
+}
+var VERSION = /(\d+\.\d+\.\d+)/;
+function identify(output) {
+  if (/claude code/i.test(output)) return "claude";
+  if (/\bcodex(-cli)?\b/i.test(output)) return "codex";
+  return null;
+}
+function loggedIn(cli2, result) {
+  if (cli2 === "claude") {
+    const json = /\{[\s\S]*\}/.exec(result.out)?.[0];
+    try {
+      const status = json ? JSON.parse(json) : null;
+      return typeof status?.loggedIn === "boolean" ? status.loggedIn : null;
+    } catch {
+      return null;
+    }
+  }
+  if (/not logged in|logged out/i.test(result.out)) return false;
+  if (/logged in/i.test(result.out)) return true;
+  return result.code !== null && result.code !== 0 ? false : null;
+}
+var LOGIN = {
+  claude: { args: ["auth", "status"], fix: "claude auth login" },
+  codex: { args: ["login", "status"], fix: "codex login" }
+};
+async function probeCli(path, expected, onPath, probe = defaultProbe) {
+  const missing = (problem) => ({
+    cli: expected,
+    found: { path, version: null, onPath, ready: false, problem, fix: null }
+  });
+  let version;
+  try {
+    version = await probe(path, ["--version"]);
+  } catch {
+    return missing(`Nothing runs at ${path}`);
+  }
+  const cli2 = identify(version.out) ?? expected;
+  if (version.code !== 0 || !cli2) {
+    const said = version.out.split("\n")[0]?.slice(0, 120) || "nothing";
+    return missing(cli2 ? `${path} didn't say its version` : `${path} isn't Codex or Claude Code: it says \u201C${said}\u201D`);
+  }
+  const number = VERSION.exec(version.out)?.[1] ?? null;
+  const tooOld = cli2 === "codex" ? refusalFor(number) : null;
+  if (tooOld) {
+    return { cli: cli2, found: { path, version: number, onPath, ready: false, problem: tooOld, fix: "codex update" } };
+  }
+  let login = null;
+  try {
+    login = loggedIn(cli2, await probe(path, LOGIN[cli2].args));
+  } catch {
+    login = null;
+  }
+  return {
+    cli: cli2,
+    found: login === false ? { path, version: number, onPath, ready: false, problem: `${CLI_LABEL[cli2]} is installed but not logged in`, fix: LOGIN[cli2].fix } : { path, version: number, onPath, ready: true, problem: null, fix: null }
+  };
+}
+async function detectClis(configured = {}, opts = {}) {
+  const report = {};
+  await Promise.all(
+    CLI_NAMES.map(async (cli2) => {
+      const onPath = await findExecutable(cli2, opts.path);
+      const candidates = [
+        ...configured[cli2] ? [await findExecutable(configured[cli2], opts.path)] : [],
+        onPath,
+        ...await Promise.all((opts.locations ?? knownLocations)(cli2).map((location) => findExecutable(location)))
+      ];
+      const seen = /* @__PURE__ */ new Set();
+      for (const candidate of candidates) {
+        if (!candidate || seen.has(candidate)) continue;
+        seen.add(candidate);
+        const { found } = await probeCli(candidate, cli2, candidate === onPath, opts.probe);
+        if (found.version !== null || found.ready) {
+          report[cli2] = found;
+          return;
+        }
+      }
+      report[cli2] = { path: null, version: null, onPath: false, ready: false, problem: `${CLI_LABEL[cli2]} isn't installed`, fix: null };
+    })
+  );
+  return report;
+}
+function preferredCli(report) {
+  return CLI_PREFERENCE.find((cli2) => report[cli2].ready) ?? null;
+}
+
 // src/editable.ts
 import { createHash } from "node:crypto";
-import { readFile, rename, writeFile } from "node:fs/promises";
+import { readFile as readFile2, 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");
+    const text = await readFile2(path, "utf8");
     return { text, version: versionOf(text) };
   } catch (error) {
     if (error.code === "ENOENT") return { text: null, version: ABSENT };
@@ -127,7 +371,7 @@ ${lines.join("\n")}
 }
 
 // src/board.ts
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 
 // src/failure.ts
 var MAX_DETAIL = 4e3;
@@ -221,9 +465,9 @@ function reasonFor(code) {
 }
 
 // src/github.ts
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var run = promisify(execFile);
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var run2 = promisify2(execFile3);
 var GH_TIMEOUT_MS = 15e3;
 var FETCH_TIMEOUT_MS = 3e4;
 var GRAPHQL_URL = "https://api.github.com/graphql";
@@ -246,7 +490,7 @@ var GhAuthError = class extends Error {
 };
 async function gh(ghPath, args) {
   try {
-    const { stdout, stderr } = await run(ghPath, args, { env: GH_ENV, timeout: GH_TIMEOUT_MS, maxBuffer: 1 << 20 });
+    const { stdout, stderr } = await run2(ghPath, args, { env: GH_ENV, timeout: GH_TIMEOUT_MS, maxBuffer: 1 << 20 });
     return { stdout, stderr, code: 0 };
   } catch (err) {
     const failure = err;
@@ -1178,7 +1422,7 @@ ${details[i] || "(nothing more)"}`).join("\n\n");
     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)
+        (identity3) => this.#deps.fetch(identity3.token, this.#config.github.scope, identity3.account.login, this.#abort.signal)
       )
     );
     results.forEach((result, i) => {
@@ -1323,7 +1567,7 @@ function normalizeStoredPull(raw) {
 async function readPullsFile(path) {
   let text;
   try {
-    text = await readFile2(path, "utf8");
+    text = await readFile3(path, "utf8");
   } catch {
     return null;
   }
@@ -1347,12 +1591,12 @@ async function readPullsFile(path) {
 }
 
 // src/calendar.ts
-import { execFile as execFile2 } from "node:child_process";
-import { readFile as readFile3, rm, stat } from "node:fs/promises";
+import { execFile as execFile4 } from "node:child_process";
+import { readFile as readFile4, rm, stat as stat2 } 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);
+import { join as join3 } from "node:path";
+import { promisify as promisify3 } from "node:util";
+var run3 = promisify3(execFile4);
 var HELPER_TIMEOUT_MS = 2e4;
 var POLL_MS = 150;
 var DECLINED = 3;
@@ -1375,17 +1619,17 @@ function parseCalendarFacts(raw) {
   if (typeof raw !== "object" || raw === null) return null;
   const obj = raw;
   if (str2(obj.error)) return null;
-  const calendars = [];
+  const calendars2 = [];
   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) ?? "" });
+      if (id && title) calendars2.push({ id, title, source: str2(entry?.source) ?? "" });
     }
   }
   return {
     generatedAt: str2(obj.generatedAt) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-    calendars,
+    calendars: calendars2,
     events: Array.isArray(obj.events) ? obj.events : []
   };
 }
@@ -1442,17 +1686,17 @@ var CalendarHelperError = class extends Error {
 };
 async function runHelper(appPath, selfAddresses) {
   try {
-    await stat(appPath);
+    await stat2(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`);
+  const out = join3(tmpdir(), `daily-focus-calendar-${process.pid}-${Date.now()}.json`);
   try {
     try {
       const zone = process.env.TZ ? ["--env", `TZ=${process.env.TZ}`] : [];
-      await run2("/usr/bin/open", ["-n", "-a", appPath, ...zone, "--args", out, selfAddresses.join(",")], {
+      await run3("/usr/bin/open", ["-n", "-a", appPath, ...zone, "--args", out, selfAddresses.join(",")], {
         timeout: HELPER_TIMEOUT_MS
       });
     } catch (err) {
@@ -1463,7 +1707,7 @@ async function runHelper(appPath, selfAddresses) {
     for (; ; ) {
       let text = null;
       try {
-        text = await readFile3(out, "utf8");
+        text = await readFile4(out, "utf8");
       } catch {
         text = null;
       }
@@ -1487,7 +1731,7 @@ async function runHelper(appPath, selfAddresses) {
 }
 
 // src/calendarboard.ts
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
 var MAX_BACKOFF_MS2 = 15 * 6e4;
 var realDeps2 = { run: runHelper };
 var CalendarBoard = class {
@@ -1639,18 +1883,18 @@ var CalendarBoard = class {
 };
 async function readCalendarFile(path) {
   try {
-    return parseCalendarFacts(JSON.parse(await readFile4(path, "utf8")));
+    return parseCalendarFacts(JSON.parse(await readFile5(path, "utf8")));
   } catch {
     return null;
   }
 }
 
 // src/ticketboard.ts
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 
 // src/jira.ts
-import { execFile as execFile3 } from "node:child_process";
-import { promisify as promisify3 } from "node:util";
+import { execFile as execFile5 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
 
 // src/linked.ts
 var CLOSED_LOOKBACK_DAYS = 60;
@@ -1732,7 +1976,7 @@ function reconcile(ticket, linked, jiraCount) {
 }
 
 // src/jira.ts
-var run3 = promisify3(execFile3);
+var run4 = promisify4(execFile5);
 var ACLI_TIMEOUT_MS = 45e3;
 var PAGE_LIMIT = 200;
 var ACLI_ENV = { ...process.env, NO_COLOR: "1" };
@@ -1768,7 +2012,7 @@ var JiraTransitionError = class extends Error {
 };
 async function acli(acliPath, args) {
   try {
-    const { stdout, stderr } = await run3(acliPath, args, {
+    const { stdout, stderr } = await run4(acliPath, args, {
       env: ACLI_ENV,
       timeout: ACLI_TIMEOUT_MS,
       // A hundred tickets of raw Jira issue JSON measured 135 KB; this is room
@@ -1914,13 +2158,13 @@ function jsonObjectAt(text, from) {
   }
   return null;
 }
-function readDevPullRequests(field) {
-  if (typeof field !== "string") return null;
-  const marker = field.indexOf("json=");
+function readDevPullRequests(field2) {
+  if (typeof field2 !== "string") return null;
+  const marker = field2.indexOf("json=");
   if (marker === -1) return null;
-  const opens = field.indexOf("{", marker);
+  const opens = field2.indexOf("{", marker);
   if (opens === -1) return null;
-  const body = jsonObjectAt(field, opens);
+  const body = jsonObjectAt(field2, opens);
   if (body === null) return null;
   let parsed;
   try {
@@ -2050,19 +2294,19 @@ async function fetchTickets(acliPath, opts) {
   const undecided = new Set(reconciled.filter((ticket) => !ticket.hasOpenPr && !ticket.allPrsClosed).map((ticket) => ticket.key));
   const unansweredNow = unanswered.filter((key) => undecided.has(key));
   const unaccountedNow = unaccounted.filter((key) => undecided.has(key));
-  const listed = (keys2) => keys2.map((key) => {
+  const listed2 = (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 (unansweredNow.length > 0) {
     warnings.push(
-      `Could not read Jira's development panel for ${listed(unansweredNow)}, so ${heldOut(unansweredNow)}. The next read may well manage it.`
+      `Could not read Jira's development panel for ${listed2(unansweredNow)}, so ${heldOut(unansweredNow)}. The next read may well manage it.`
     );
   }
   if (unaccountedNow.length > 0) {
     warnings.push(
-      `Jira's search says ${listed(unaccountedNow)} ${unaccountedNow.length === 1 ? "has" : "have"} pull requests, but its own development panel names none, so ${heldOut(unaccountedNow)}. Jira is disagreeing with itself; the row comes back when one of its caches catches up.`
+      `Jira's search says ${listed2(unaccountedNow)} ${unaccountedNow.length === 1 ? "has" : "have"} pull requests, but its own development panel names none, so ${heldOut(unaccountedNow)}. Jira is disagreeing with itself; the row comes back when one of its caches catches up.`
     );
   }
   if (!opts.site) {
@@ -2158,7 +2402,7 @@ function ticketCourtOrder(court) {
 function inStatus(ticket, statuses) {
   const status = ticket.workflowStatus.trim().toLowerCase();
   if (status === "") return false;
-  return statuses.some((listed) => listed.trim().toLowerCase() === status);
+  return statuses.some((listed2) => listed2.trim().toLowerCase() === status);
 }
 function judge(ticket, holdStatuses = []) {
   if (ticket.statusCategory === "done") return null;
@@ -2349,15 +2593,15 @@ var TicketBoard = class {
   }
   async #read() {
     const { acliPath, projects, site: configuredSite } = this.#config.jira;
-    let identity2;
+    let identity3;
     try {
-      identity2 = await this.#deps.identity(acliPath);
+      identity3 = 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;
+    const site = configuredSite ?? identity3.site;
     const githubWarnings = [];
     const linked = this.#config.github.enabled ? this.#deps.linked(this.#config.github, /* @__PURE__ */ new Date(), AbortSignal.any([this.#abort.signal, AbortSignal.timeout(GITHUB_DEADLINE_MS)])).then(
       (read) => {
@@ -2382,7 +2626,7 @@ var TicketBoard = class {
       this.#file = {
         version: 1,
         fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        account: identity2.account,
+        account: identity3.account,
         projects: [...projects],
         warnings,
         tickets,
@@ -2451,7 +2695,7 @@ function storedPulls(value) {
 async function readTicketsFile(path) {
   let text;
   try {
-    text = await readFile5(path, "utf8");
+    text = await readFile6(path, "utf8");
   } catch {
     return null;
   }
@@ -2484,8 +2728,8 @@ async function readTicketsFile(path) {
 // src/agent.ts
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { appendFile, mkdir, readFile as readFile6 } from "node:fs/promises";
-import { homedir } from "node:os";
+import { appendFile, mkdir, readFile as readFile7 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
 import { createInterface } from "node:readline";
 var RUN_TIMEOUT_MS = 60 * 6e4;
 var TURN_TIMEOUT_MS = 10 * 6e4;
@@ -2505,6 +2749,11 @@ function agentPrompt(promptPath) {
     "Finish by reporting back as that file asks you to."
   ].join("\n");
 }
+function agentSettings(config) {
+  return {
+    searchTrash: config.agent.searchTrash
+  };
+}
 function followUpPrompt(question) {
   return [
     "A follow-up question about the brief you wrote in this session. Answer it here.",
@@ -2515,7 +2764,7 @@ function followUpPrompt(question) {
     question.trim()
   ].join("\n");
 }
-function displayPath(path, home = homedir()) {
+function displayPath(path, home = homedir2()) {
   return path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
 }
 function foldAgentLog(text) {
@@ -2622,7 +2871,7 @@ var AgentRunner = class {
     this.loaded = true;
     let text = "";
     try {
-      text = await readFile6(this.config.agentLogFile, "utf8");
+      text = await readFile7(this.config.agentLogFile, "utf8");
     } catch {
       return;
     }
@@ -2700,8 +2949,8 @@ var AgentRunner = class {
    * 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");
+    const cli2 = this.config.agent.cli;
+    if (!cli2) 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"
@@ -2710,7 +2959,7 @@ var AgentRunner = class {
     await this.start();
     const run5 = {
       id: randomUUID(),
-      cli,
+      cli: cli2,
       trigger,
       sessionId: null,
       startedAt: now.toISOString(),
@@ -2723,8 +2972,14 @@ var AgentRunner = class {
       resumable: false
     };
     this.runs.push(run5);
-    await this.append({ event: "started", run: run5.id, cli, trigger, at: run5.startedAt });
-    const adapter = ADAPTERS[cli];
+    await this.append({ event: "started", run: run5.id, cli: cli2, trigger, at: run5.startedAt });
+    try {
+      await writeJsonAtomic(this.config.agentSettingsFile, agentSettings(this.config));
+    } catch (err) {
+      await this.finish(run5, null, { ok: false, error: `could not write ${displayPath(this.config.agentSettingsFile)}: ${err.message}` });
+      return run5;
+    }
+    const adapter = ADAPTERS[cli2];
     const args = adapter.args({
       prompt: agentPrompt(displayPath(this.config.promptFile)),
       sessionId: null,
@@ -2743,8 +2998,8 @@ var AgentRunner = class {
    * 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");
+    const cli2 = this.config.agent.cli;
+    if (!cli2) throw new Error("running the morning agent is off; set DAILY_FOCUS_AGENT to codex or claude");
     await this.start();
     const run5 = this.runs.find((candidate) => candidate.id === runId);
     if (!run5) throw new Error("no such run");
@@ -2755,7 +3010,7 @@ var AgentRunner = class {
     }
     if (!this.resumable(run5)) {
       throw new Error(
-        run5.sessionId === null ? "this run left no session to continue" : `this run was made by ${run5.cli}, and the agent is ${cli} now`
+        run5.sessionId === null ? "this run left no session to continue" : `this run was made by ${run5.cli}, and the agent is ${cli2} now`
       );
     }
     const text = question.trim();
@@ -2771,7 +3026,7 @@ var AgentRunner = class {
     };
     run5.turns.push(turn);
     await this.append({ event: "asked", run: run5.id, turn: turn.id, question: text, at: turn.startedAt });
-    const adapter = ADAPTERS[cli];
+    const adapter = ADAPTERS[cli2];
     const args = adapter.args({
       prompt: followUpPrompt(text),
       sessionId: run5.sessionId,
@@ -2792,10 +3047,10 @@ var AgentRunner = class {
    * session under the directory it was started in, and looks for it there.
    */
   async spawnInto(run5, turn, args, timeoutMs, timeoutReason) {
-    const cli = run5.cli;
-    const adapter = ADAPTERS[cli];
+    const cli2 = run5.cli;
+    const adapter = ADAPTERS[cli2];
     await mkdir(this.config.dataDir, { recursive: true });
-    const refusal2 = cli === "codex" ? await this.codexGate.refusal() : null;
+    const refusal2 = cli2 === "codex" ? await this.codexGate.refusal() : null;
     if (refusal2) {
       await this.finish(run5, turn, { ok: false, error: refusal2 });
       return;
@@ -2851,7 +3106,7 @@ ${event.text}` : event.text;
       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(" ")}` : ""}`
+        error: `${cli2} exited with code ${code}${stderr.length ? `: ${stderr.join("").trim().split("\n").slice(-3).join(" ")}` : ""}`
       };
       void this.finish(run5, turn, outcome, running.abortReason !== null);
     });
@@ -2954,23 +3209,23 @@ function watchDataDir(dir, onChange, { debounceMs = 120, ignore = [] } = {}) {
 }
 
 // src/assets.ts
-import { readdir, stat as stat2 } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { readdir as readdir2, stat as stat3 } from "node:fs/promises";
+import { join as join4 } from "node:path";
 async function computeAssetVersion(dir) {
   const parts = [];
   async function walk(current) {
     let entries;
     try {
-      entries = await readdir(current, { withFileTypes: true });
+      entries = await readdir2(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      const path = join2(current, entry.name);
+      const path = join4(current, entry.name);
       if (entry.isDirectory()) {
         await walk(path);
       } else {
-        const info = await stat2(path);
+        const info = await stat3(path);
         parts.push(`${entry.name}:${info.size}:${info.mtimeMs}`);
       }
     }
@@ -2989,8 +3244,8 @@ 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>`;
+function faviconSvg(profile2) {
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">${FAVICONS[profile2]}</svg>`;
 }
 
 // src/guard.ts
@@ -3022,6 +3277,542 @@ function refusal(req, listenHost) {
   return null;
 }
 
+// src/onboarding.ts
+import { spawn as spawn2 } from "node:child_process";
+import { mkdir as mkdir2, mkdtemp, readFile as readFile8, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join5 } from "node:path";
+import { createInterface as createInterface2 } from "node:readline";
+
+// src/questions.ts
+var INSTALL = {
+  codex: { label: "Install Codex", url: "https://developers.openai.com/codex/cli" },
+  claude: { label: "Install Claude Code", url: "https://code.claude.com/docs" }
+};
+function option(value, label, detail = null, group = null) {
+  return { value, label, detail, group };
+}
+function choice(id, options, selected, extra = {}) {
+  return { id, label: null, multiple: false, options, selected, custom: null, ...extra };
+}
+function field(id, label, value, extra = {}) {
+  return { id, label, value, placeholder: null, help: null, ...extra };
+}
+function card(parts) {
+  return { why: null, choices: [], fields: [], problem: null, ...parts };
+}
+function one(answer, id) {
+  return answer.choices[id]?.[0] ?? null;
+}
+function str3(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function proposalOf(ctx, id) {
+  const proposal = ctx.proposals[id];
+  return typeof proposal === "object" && proposal !== null && !Array.isArray(proposal) ? proposal : null;
+}
+function listed(names) {
+  if (names.length <= 1) return names.join("");
+  return `${names.slice(0, -1).join(", ")} and ${names.at(-1)}`;
+}
+function ticked(name) {
+  return `\`${name.replaceAll("`", "'")}\``;
+}
+function binFor(ctx, cli2) {
+  const found = cli2 ? ctx.clis?.[cli2] : null;
+  return found?.path && !found.onPath ? found.path : null;
+}
+var cli = {
+  id: "cli",
+  title: () => "Which agent should write your brief?",
+  topic: "your coding agent",
+  keys: ["DAILY_FOCUS_AGENT"],
+  later: { label: "Decide later", summary: "No agent yet: the boards work, and there is no brief until you choose one." },
+  card(ctx) {
+    if (!ctx.clis) return card({});
+    const report = ctx.clis;
+    const ready = CLI_PREFERENCE.filter((name) => report[name].ready);
+    if (ready.length === 0) {
+      const lines = CLI_PREFERENCE.map((name) => `${report[name].problem ?? `${CLI_LABEL[name]} can't be used`}.`);
+      const fix = CLI_PREFERENCE.map((name) => report[name].fix).find((command3) => command3) ?? null;
+      return card({
+        problem: {
+          message: `${lines.join(" ")} ${fix ? "Run this in a terminal, then check again." : "Install one, log in once in a terminal, then check again."}`,
+          command: fix,
+          blocking: true,
+          links: CLI_PREFERENCE.filter((name) => !report[name].path).map((name) => INSTALL[name])
+        },
+        fields: [
+          field("path", "Installed somewhere setup didn\u2019t look? Its path", "", {
+            placeholder: "/opt/homebrew/bin/codex",
+            help: "The program itself, codex or claude. Setup checks it before using it."
+          })
+        ]
+      });
+    }
+    const set = ctx.current.DAILY_FOCUS_AGENT;
+    const others = CLI_PREFERENCE.filter((name) => !report[name].ready && report[name].path).map((name) => `${report[name].problem}.`);
+    return card({
+      why: [
+        ready.length > 1 ? `Both are ready on this ${ctx.machine}, so it uses Codex unless you say otherwise.` : `${CLI_LABEL[ready[0]]} is the one ready on this ${ctx.machine}.`,
+        ...others
+      ].join(" "),
+      choices: [
+        choice(
+          "cli",
+          ready.map((name) => option(name, CLI_LABEL[name], [report[name].version, report[name].path].filter(Boolean).join(", at "))),
+          [set && ready.includes(set) ? set : ready[0]]
+        )
+      ]
+    });
+  },
+  summary: (answer) => {
+    const chosen = CLI_LABEL[one(answer, "cli")];
+    return chosen ? `${chosen} writes your brief.` : "No agent writes your brief yet.";
+  },
+  // The assistant comes with it, on the same CLI, unless it has been set: it
+  // only reads and drafts, and it is what the Ask button on every row needs.
+  settings: (answer, ctx) => {
+    const chosen = one(answer, "cli");
+    const bin = binFor(ctx, chosen);
+    const assistant = chosen && !ctx.current.DAILY_FOCUS_ASSISTANT;
+    return {
+      DAILY_FOCUS_AGENT: chosen,
+      ...bin ? { DAILY_FOCUS_AGENT_BIN: bin } : {},
+      ...assistant ? { DAILY_FOCUS_ASSISTANT: chosen, ...bin ? { DAILY_FOCUS_ASSISTANT_BIN: bin } : {} } : {}
+    };
+  }
+};
+var profile = {
+  id: "profile",
+  topic: "what it covers",
+  title: () => "What should your brief cover?",
+  keys: ["DAILY_FOCUS_PROFILE"],
+  later: null,
+  card: (ctx) => card({
+    choices: [
+      choice(
+        "profile",
+        [
+          option("work", "Your work", "Work mail and calendars, pull requests, tickets and meeting notes."),
+          option("personal", "Your personal life", "Personal mail, family calendars, reminders and messages.")
+        ],
+        [ctx.current.DAILY_FOCUS_PROFILE === "personal" ? "personal" : "work"]
+      )
+    ],
+    why: "One dashboard briefs one of them. For both, run a second dashboard with its own store."
+  }),
+  summary: (answer) => one(answer, "profile") === "personal" ? "It briefs your personal life." : "It briefs your work.",
+  settings: (answer) => ({ DAILY_FOCUS_PROFILE: one(answer, "profile") })
+};
+var TIMES = ["06:00", "06:30", "07:00", "07:30", "08:00"];
+var DAYS = { "1-5": "Weekdays", "0-6": "Every day" };
+var schedule = {
+  id: "schedule",
+  topic: "when it runs",
+  title: () => "When should your brief be ready?",
+  applies: (ctx) => ctx.cli !== null,
+  keys: ["DAILY_FOCUS_AGENT_AT", "DAILY_FOCUS_AGENT_DAYS"],
+  later: null,
+  card(ctx) {
+    const at = ctx.current.DAILY_FOCUS_AGENT_AT || "07:00";
+    const days = ctx.current.DAILY_FOCUS_AGENT_DAYS || "1-5";
+    const times = [.../* @__PURE__ */ new Set([...TIMES, ...at === "off" ? [] : [at]])].sort();
+    return card({
+      why: `It starts then and takes a few minutes. If the ${ctx.machine} is asleep or the dashboard isn't running then, it runs as soon as it is, that day.`,
+      choices: [
+        choice("at", [...times.map((time) => option(time, time)), option("off", "Only when I ask")], [at], {
+          label: "Time",
+          custom: "Another time, such as 05:45"
+        }),
+        choice("days", Object.entries({ ...DAYS, ...DAYS[days] ? {} : { [days]: days } }).map(([value, label]) => option(value, label)), [days], {
+          label: "Days"
+        })
+      ]
+    });
+  },
+  summary(answer) {
+    const at = one(answer, "at");
+    if (!at || at === "off") return "It runs only when you ask.";
+    const days = one(answer, "days") ?? "1-5";
+    return `It runs at ${at} ${days === "1-5" ? "on weekdays" : days === "0-6" ? "every day" : `on days ${days}`}.`;
+  },
+  settings: (answer) => ({ DAILY_FOCUS_AGENT_AT: one(answer, "at"), DAILY_FOCUS_AGENT_DAYS: one(answer, "days") })
+};
+function proposedAccounts(proposal) {
+  const raw = Array.isArray(proposal?.githubAccounts) ? proposal.githubAccounts : [];
+  return raw.flatMap((entry) => {
+    const account = typeof entry === "object" && entry !== null ? entry : {};
+    const login = str3(account.login);
+    return login ? [{ login, note: str3(account.note) }] : [];
+  });
+}
+function githubAccounts(ctx) {
+  const accounts = /* @__PURE__ */ new Map();
+  for (const login of ctx.identity.logins) accounts.set(login.toLowerCase(), { login, note: "" });
+  for (const { login, note } of proposedAccounts(proposalOf(ctx, "identity"))) {
+    accounts.set(login.toLowerCase(), { login: accounts.get(login.toLowerCase())?.login ?? login, note });
+  }
+  return [...accounts.values()];
+}
+var identity2 = {
+  id: "identity",
+  topic: "who you are",
+  title: () => "Is this you?",
+  keys: [],
+  // Clearing three fields and unticking the accounts is a chore; one button, named for what it does, isn't.
+  later: { label: "Leave this out", summary: "Who you are is left out, so the brief can\u2019t tell your to-dos from other people\u2019s." },
+  card(ctx) {
+    const proposal = proposalOf(ctx, "identity");
+    const names = Array.isArray(proposal?.names) ? proposal.names.map(str3).filter(Boolean) : [];
+    const name = names.length ? names.join(", ") : ctx.identity.name ?? "";
+    const email = str3(proposal?.email) || (ctx.identity.email ?? "");
+    const accounts = githubAccounts(ctx);
+    return card({
+      why: str3(proposal?.why) || "The brief tells your to-dos from everyone else\u2019s by these.",
+      fields: [
+        field("name", "Your name, as meeting notes write it", name, {
+          placeholder: "Robin Lark",
+          help: "Add short forms after a comma, such as Robin L."
+        }),
+        field("email", ctx.profile === "personal" ? "Your email" : "Your work email", email, { placeholder: "robin@example.com" })
+      ],
+      choices: [
+        choice(
+          "github",
+          accounts.map((account) => option(account.login, account.login, account.note || null)),
+          accounts.map((account) => account.login),
+          { label: "Your GitHub accounts", multiple: true, custom: "Add a GitHub login" }
+        )
+      ]
+    });
+  },
+  summary(answer) {
+    const name = answer.fields.name?.split(",")[0]?.trim();
+    const logins = answer.choices.github ?? [];
+    const rest = [answer.fields.email?.trim() ?? "", logins.length ? `${listed(logins)} on GitHub` : ""].filter(Boolean);
+    if (!name) return rest.length ? `You're ${listed(rest)}.` : "No details about you.";
+    return `You're ${name}${rest.length ? `, ${rest.join(", ")}` : ""}.`;
+  },
+  settings(answer, ctx) {
+    const values = {};
+    if (answer.fields.email?.trim()) values.DAILY_FOCUS_CALENDAR_ADDRESSES = answer.fields.email.trim();
+    const logins = answer.choices.github ?? [];
+    if (logins.length > 1 || logins.length === 1 && logins[0] !== ctx.identity.logins[0]) {
+      values.DAILY_FOCUS_GITHUB_ACCOUNTS = logins.join(", ");
+    }
+    return values;
+  },
+  sources(answer, ctx) {
+    const names = (answer.fields.name ?? "").split(",").map((n) => n.trim()).filter(Boolean);
+    const email = answer.fields.email?.trim();
+    const notes = new Map(githubAccounts(ctx).map((account) => [account.login, account.note]));
+    const logins = answer.choices.github ?? [];
+    const lines = [
+      names.length ? `- Name, as meeting notes and Doc assignments write it: ${ticked(names[0])}${names.length > 1 ? `, also ${listed(names.slice(1).map(ticked))}` : ""}` : null,
+      email ? `- ${ctx.profile === "personal" ? "Personal" : "Work"} email: ${ticked(email)}` : null,
+      logins.length ? [
+        `- GitHub ${logins.length > 1 ? "logins" : "login"}, which review requests and authorship are judged against:`,
+        ...logins.map((login) => `  - ${ticked(login)}${notes.get(login) ? ` \u2014 ${notes.get(login)}` : ""}`)
+      ].join("\n") : null
+    ].filter((line) => line !== null);
+    return lines.length ? [{ heading: "Identity", body: lines.join("\n") }] : [];
+  },
+  agent: {
+    brief: (ctx) => "Who the user is, as their morning brief needs to know them: their name as meeting notes and document assignments write it, with any short forms colleagues use, their " + (ctx.profile === "personal" ? "personal" : "work") + " email address, and every GitHub account they work as: gh may hold several, such as one for an employer\u2019s organisation. Give each account a few words on what it is for when you can tell. Start from what the dashboard found, below. Check the address they send mail from, how others address them, and `gh auth status`.",
+    facts: (ctx) => [
+      ctx.identity.name ? `- gh says their name is ${ctx.identity.name}` : null,
+      ctx.identity.logins.length ? `- gh is logged in to GitHub as ${listed(ctx.identity.logins)}; the first is active` : null,
+      ctx.identity.email ? `- git's global email is ${ctx.identity.email}` : null
+    ].filter(Boolean).join("\n") || null,
+    schema: {
+      type: "object",
+      properties: {
+        why: { type: "string", description: "One or two sentences on where these came from." },
+        names: { type: "array", items: { type: "string" }, description: "Full name first, then short forms." },
+        email: { type: "string" },
+        githubAccounts: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              login: { type: "string" },
+              note: { type: "string", description: "What the account is for, in a few words, or empty." }
+            },
+            required: ["login", "note"],
+            additionalProperties: false
+          }
+        }
+      },
+      required: ["why", "names", "email", "githubAccounts"],
+      additionalProperties: false
+    }
+  }
+};
+function healthText(board, via) {
+  if (board.reason) return board.reason;
+  if (board.fetchedAt) return `Connected through ${via}.`;
+  if (board.enabled) return `Checking ${via}\u2026`;
+  return null;
+}
+var boards = {
+  id: "boards",
+  topic: "the boards",
+  title: () => "What else should the dashboard show?",
+  keys: ["DAILY_FOCUS_GITHUB", "DAILY_FOCUS_JIRA"],
+  later: null,
+  card(ctx) {
+    const { github, jira } = ctx.boards;
+    const selected = [
+      github.enabled && !github.reason ? "github" : null,
+      jira.enabled && !jira.reason && ctx.profile === "work" ? "jira" : null
+    ].filter((value) => value !== null);
+    return card({
+      why: "Both are read live, beside the brief, so a merge or a status change shows up within minutes.",
+      choices: [
+        choice(
+          "boards",
+          [
+            option("github", "Your pull requests", healthText(github, "gh") ?? "Through the GitHub CLI, gh."),
+            option("jira", "Your Jira tickets", healthText(jira, "acli") ?? "Through the Atlassian CLI, acli.")
+          ],
+          selected,
+          { multiple: true }
+        )
+      ]
+    });
+  },
+  summary(answer) {
+    const on = answer.choices.boards ?? [];
+    const names = [on.includes("github") ? "your pull requests" : null, on.includes("jira") ? "your Jira tickets" : null].filter(
+      (name) => name !== null
+    );
+    return names.length ? `It shows ${listed(names)}.` : "No boards beside the brief.";
+  },
+  settings(answer) {
+    const on = answer.choices.boards ?? [];
+    return { DAILY_FOCUS_GITHUB: on.includes("github") ? "on" : "off", DAILY_FOCUS_JIRA: on.includes("jira") ? "on" : "off" };
+  }
+};
+var HOLIDAYS = "Holidays";
+function calendarEntries(ctx) {
+  const proposal = proposalOf(ctx, "calendars");
+  const verdicts = Array.isArray(proposal?.calendars) ? proposal.calendars.flatMap((raw) => {
+    const entry = typeof raw === "object" && raw !== null ? raw : {};
+    const title = str3(entry.title);
+    return title ? [{ title, account: str3(entry.account), include: entry.include === true, holiday: entry.holiday === true, briefName: str3(entry.briefName), note: str3(entry.note) }] : [];
+  }) : [];
+  const configured = new Set((ctx.current.DAILY_FOCUS_CALENDARS ?? "").split(",").map((name) => name.trim().toLowerCase()).filter(Boolean));
+  const used = /* @__PURE__ */ new Set();
+  const entries = [];
+  for (const calendar of Array.isArray(ctx.calendars) ? ctx.calendars : []) {
+    const key = calendar.title.toLowerCase();
+    const verdict = verdicts.find((v) => !used.has(v) && v.title.toLowerCase() === key && v.account.toLowerCase() === calendar.source.toLowerCase()) ?? verdicts.find((v) => !used.has(v) && v.title.toLowerCase() === key);
+    if (verdict) used.add(verdict);
+    entries.push({
+      value: `live:${calendar.source}:${calendar.title}`,
+      title: calendar.title,
+      group: verdict?.holiday ? HOLIDAYS : calendar.source || "Calendar.app",
+      live: true,
+      holiday: verdict?.holiday ?? false,
+      briefName: verdict?.briefName ?? "",
+      note: verdict?.note ?? "",
+      include: verdict ? verdict.include : configured.has(key)
+    });
+  }
+  for (const verdict of verdicts) {
+    if (used.has(verdict)) continue;
+    entries.push({
+      value: `brief:${verdict.account}:${verdict.title}`,
+      title: verdict.title,
+      group: verdict.holiday ? HOLIDAYS : verdict.account || "Your calendar account",
+      live: false,
+      holiday: verdict.holiday,
+      briefName: verdict.briefName,
+      note: verdict.note,
+      include: verdict.include
+    });
+  }
+  return entries.sort((a, b) => Number(a.group === HOLIDAYS) - Number(b.group === HOLIDAYS));
+}
+function chosenCalendars(answer, ctx) {
+  const all = new Map(calendarEntries(ctx).map((entry) => [entry.value, entry]));
+  const values = answer.choices.calendars ?? [];
+  return {
+    entries: values.flatMap((value) => all.get(value) ?? []),
+    typed: values.filter((value) => !all.has(value)).map((value) => value.trim()).filter(Boolean)
+  };
+}
+var calendars = {
+  id: "calendars",
+  topic: "your calendars",
+  title: (ctx) => ctx.profile === "personal" ? "Which calendars belong in your brief?" : "Which calendars belong in your work brief?",
+  keys: ["DAILY_FOCUS_CALENDARS"],
+  later: null,
+  card(ctx) {
+    const entries = calendarEntries(ctx);
+    const proposal = proposalOf(ctx, "calendars");
+    const problem = ctx.calendar.supported && !ctx.calendar.built ? {
+      message: "The live agenda reads Calendar.app through a small helper, built once with this command. Until then it uses the brief\u2019s events, so this list is from your calendar account.",
+      command: ctx.calendar.buildCommand,
+      blocking: false
+    } : typeof ctx.calendars === "string" ? { message: `Calendar.app couldn't be read: ${ctx.calendars}`, command: null, blocking: false } : null;
+    return card({
+      why: str3(proposal?.why) || null,
+      problem,
+      choices: [
+        choice(
+          "calendars",
+          entries.map((entry) => option(entry.value, entry.title, entry.note || null, entry.group)),
+          entries.filter((entry) => entry.include).map((entry) => entry.value),
+          { multiple: true, custom: "Add a calendar by name" }
+        )
+      ]
+    });
+  },
+  summary(answer, ctx) {
+    const { entries, typed } = chosenCalendars(answer, ctx);
+    const names = [...entries.map((entry) => entry.title), ...typed];
+    if (names.length === 0) return "No calendars.";
+    if (names.length <= 3) return `It reads ${listed(names)}.`;
+    return `It reads ${names.slice(0, 2).join(", ")} and ${names.length - 2} more calendars.`;
+  },
+  settings(answer, ctx) {
+    const { entries, typed } = chosenCalendars(answer, ctx);
+    const live = [.../* @__PURE__ */ new Set([...entries.filter((entry) => entry.live).map((entry) => entry.title), ...typed])];
+    return { DAILY_FOCUS_CALENDARS: live.filter((name) => !name.includes(",")).join(", ") || null };
+  },
+  sources(answer, ctx) {
+    const { entries, typed } = chosenCalendars(answer, ctx);
+    const line = (entry) => `- ${ticked(entry.briefName || entry.title)}${entry.group !== HOLIDAYS && entry.group ? ` (${entry.group})` : ""}`;
+    const own = [...entries.filter((entry) => !entry.holiday).map(line), ...typed.map((name) => `- ${ticked(name)}`)];
+    const holidays = entries.filter((entry) => entry.holiday).map(line);
+    return [
+      ...own.length ? [{ heading: "Calendars", body: `Query these, and treat their events as blocking time:
+
+${own.join("\n")}` }] : [],
+      ...holidays.length ? [{ heading: "Holiday calendars", body: `Call out a holiday today or within the next 14 days:
+
+${holidays.join("\n")}` }] : []
+    ];
+  },
+  agent: {
+    brief: (ctx) => `Which calendars the user's ${ctx.profile} brief should read. ` + (Array.isArray(ctx.calendars) ? "Below is every calendar Calendar.app on this Mac has, with the account it is on and how many events it has today. " : "List the calendars their calendar connector reaches. ") + "Include " + (ctx.profile === "personal" ? "their own personal and family calendars, " : "their own work calendar, team calendars whose events block their time, ") + "and the holiday calendars for where they and the people they work with are. Leave out " + (ctx.profile === "personal" ? "work calendars, " : "personal and family calendars, ") + "birthdays, and shared calendars that are mostly other people's events. If you can reach their calendar through a connector, look at the coming week for evidence, and give `briefName`, the name the connector uses where it differs from Calendar.app\u2019s. " + (Array.isArray(ctx.calendars) ? "List every calendar from the list below, and any your connector has that Calendar.app does not. " : "") + '`note` is a few words shown under the name, such as "Your primary calendar" or "12 of your meetings this week", or empty.',
+    facts(ctx) {
+      if (typeof ctx.calendars === "string") return `Calendar.app could not be read (${ctx.calendars}), so work from your calendar connector alone.`;
+      if (!Array.isArray(ctx.calendars)) return "There is no list from Calendar.app here, so work from your calendar connector alone.";
+      if (ctx.calendars.length === 0) return "Calendar.app has no calendars.";
+      return [
+        "Calendar.app has these, as title (account): events today.",
+        "",
+        ...ctx.calendars.map((calendar) => `- ${calendar.title} (${calendar.source || "no account"}): ${calendar.eventsToday}`)
+      ].join("\n");
+    },
+    schema: {
+      type: "object",
+      properties: {
+        why: { type: "string", description: "One or two sentences on which you ticked and why." },
+        calendars: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              title: { type: "string", description: "Exactly as Calendar.app spells it, or the connector's name for one Calendar.app lacks." },
+              account: { type: "string" },
+              include: { type: "boolean" },
+              holiday: { type: "boolean" },
+              briefName: { type: "string" },
+              note: { type: "string" }
+            },
+            required: ["title", "account", "include", "holiday", "briefName", "note"],
+            additionalProperties: false
+          }
+        }
+      },
+      required: ["why", "calendars"],
+      additionalProperties: false
+    }
+  }
+};
+function suggestedObjectives(proposal) {
+  const raw = Array.isArray(proposal?.suggestions) ? proposal.suggestions : [];
+  return raw.flatMap((entry) => {
+    const suggestion = typeof entry === "object" && entry !== null ? entry : {};
+    const text = str3(suggestion.objective);
+    return text ? [{ text, detail: str3(suggestion.evidence) || null }] : [];
+  });
+}
+var objective = {
+  id: "objective",
+  topic: "your objective",
+  title: () => "What are you trying to get done right now?",
+  keys: [],
+  // Left empty, Continue says so; see `empty` on its card.
+  later: null,
+  card(ctx) {
+    const proposal = proposalOf(ctx, "objective");
+    return card({
+      reply: "Tell it what you\u2019re working on, however roughly",
+      empty: "Continue without one",
+      why: str3(proposal?.why) || "The brief ranks the day against it. A next move works better than a project name. Tell it what you\u2019re working on, however roughly, and it will write it up.",
+      fields: [
+        field("objective", "Your objective", str3(proposal?.objective), {
+          placeholder: "Get the staging deploy working again",
+          suggestions: suggestedObjectives(proposal)
+        }),
+        field("blocker", "What\u2019s in the way, if anything", str3(proposal?.blocker), { placeholder: "Nobody can reproduce the failure" })
+      ]
+    });
+  },
+  summary: (answer) => {
+    const text = answer.fields.objective?.trim();
+    const blocker = answer.fields.blocker?.trim();
+    if (!text) return "No objective for now.";
+    return `Your objective: ${text}${blocker ? `. In the way: ${blocker}` : ""}`;
+  },
+  objective: (answer) => answer.fields.objective?.trim() ? { objective: answer.fields.objective.trim(), blocker: answer.fields.blocker?.trim() || null } : null,
+  agent: {
+    brief: (ctx) => `The user's current objective: the one thing they are trying to get done right now, which their ${ctx.profile} brief ranks the day against. Look at what they have been doing lately: their own recent and open pull requests, tickets assigned to them and in progress, and anything on the calendar that keeps coming back. Suggest up to three objectives, each only where there is a strong signal, with the evidence in a few words, such as "your 4 open pull requests on checkout". If nothing stands out, suggest none and say so. Leave \`objective\` and \`blocker\` empty until the user tells you what they are working on. When they do, write it up as one objective: a next move rather than a project name, in their own terms, under 12 words. Put what is in the way, if they mention anything, in \`blocker\`, as briefly.`,
+    schema: {
+      type: "object",
+      properties: {
+        why: { type: "string", description: "One or two sentences: what you looked at, or how you wrote up what they said." },
+        objective: { type: "string" },
+        blocker: { type: "string" },
+        suggestions: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              objective: { type: "string" },
+              evidence: { type: "string", description: "What it was drawn from, in a few words." }
+            },
+            required: ["objective", "evidence"],
+            additionalProperties: false
+          }
+        }
+      },
+      required: ["why", "objective", "blocker", "suggestions"],
+      additionalProperties: false
+    }
+  }
+};
+var QUESTIONS = [cli, profile, schedule, identity2, boards, calendars, objective];
+function questionById(id) {
+  return QUESTIONS.find((question) => question.id === id);
+}
+function composeSources(profile2, sections, today) {
+  const intro = [
+    "# Sources",
+    "",
+    `Who you are and where to look, for your ${profile2 === "personal" ? "personal" : "work"} morning brief. Written by setup on ${today}; change it freely. The prompt next to this file (\`prompt.md\`) says *what* to gather and how to judge it; this file says *who* and *where*. A section that is missing is fine: the agent falls back to your primary calendar and connected accounts, and says what it missed.`
+  ];
+  return [...intro, ...sections.flatMap((section) => ["", `## ${section.heading}`, "", section.body])].join("\n") + "\n";
+}
+function machineName(platform = process.platform) {
+  return platform === "darwin" ? "Mac" : platform === "win32" ? "PC" : "computer";
+}
+
 // src/settings.ts
 var SETTING_GROUPS = [
   { id: "instance", title: "This dashboard" },
@@ -3091,6 +3882,14 @@ var SETTINGS = [
     choices: EFFORTS,
     fallback: always("The CLI's own")
   },
+  {
+    key: "DAILY_FOCUS_AGENT_SEARCH_TRASH",
+    group: "agent",
+    label: "Search deleted mail",
+    help: "Lets the agent look in your mail\u2019s Trash as well as the inbox and archive. Off, it leaves out what you deleted.",
+    kind: "flag",
+    fallback: always("Off")
+  },
   {
     key: "DAILY_FOCUS_AGENT_TOOLS",
     group: "agent",
@@ -3244,7 +4043,7 @@ var SETTINGS = [
     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"
+    fallback: (profile2) => profile2 === "personal" ? "Off" : "On"
   },
   {
     key: "DAILY_FOCUS_JIRA_PROJECTS",
@@ -3345,7 +4144,7 @@ var SETTINGS = [
     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"
+    fallback: (profile2) => profile2 === "personal" ? "Off" : "On"
   },
   {
     key: "DAILY_FOCUS_WORK_START",
@@ -3382,7 +4181,7 @@ function profileOf(sources, settings = sources.settings) {
   return PROFILES.includes(raw) ? raw : "work";
 }
 function describeSettings(sources) {
-  const profile = profileOf(sources);
+  const profile2 = profileOf(sources);
   const settings = SETTINGS.map((def) => {
     const fromEnv = present(sources.process, def.key);
     const fromSettings = present(sources.settings, def.key);
@@ -3398,7 +4197,7 @@ function describeSettings(sources) {
       advanced: def.advanced === true,
       value,
       source,
-      fallback: def.fallback(profile)
+      fallback: def.fallback(profile2)
     };
   });
   return { groups: SETTING_GROUPS, settings, error: sources.settingsError };
@@ -3431,134 +4230,758 @@ async function saveSettings(path, settings) {
   await writeJsonAtomic(path, sorted);
 }
 
-// src/setup.ts
-import { execFile as execFile4 } from "node:child_process";
-import { access, constants, readdir as readdir2, readFile as readFile7, stat as stat3 } from "node:fs/promises";
-import { delimiter, isAbsolute, join as join3 } from "node:path";
-import { promisify as promisify4 } from "node:util";
-var run4 = promisify4(execFile4);
-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>"
+// src/onboarding.ts
+var TURN_TIMEOUT_MS2 = 4 * 6e4;
+var KILL_AFTER_MS = 5e3;
+var STEPS_KEPT = 40;
+var SESSION_MODEL = {
+  claude: { model: "opus", effort: "low" },
+  codex: { model: null, effort: "low" }
+};
+var ONBOARDING_TOOLS = [
+  "Bash(gh *)",
+  "Bash(acli *)",
+  "Bash(git config *)",
+  "mcp__claude_ai_Gmail__search_threads",
+  "mcp__claude_ai_Gmail__get_thread",
+  "mcp__claude_ai_Gmail__get_message",
+  "mcp__claude_ai_Gmail__list_labels",
+  "mcp__claude_ai_Google_Calendar__list_calendars",
+  "mcp__claude_ai_Google_Calendar__list_events",
+  "mcp__claude_ai_Google_Calendar__search_events",
+  "mcp__claude_ai_Google_Calendar__get_event",
+  "mcp__claude_ai_Google_Drive__search_files",
+  "mcp__claude_ai_Google_Drive__list_recent_files",
+  "mcp__claude_ai_Google_Drive__get_file_metadata",
+  "mcp__claude_ai_Google_Drive__read_file_content"
 ];
-function placeholdersIn(text) {
-  return PLACEHOLDERS.filter((placeholder) => text.includes(placeholder)).length;
+var RESTARTED = "the dashboard restarted while this was running";
+function blankFile() {
+  return { startedAt: (/* @__PURE__ */ new Date()).toISOString(), finishedAt: null, briefRequested: false, answers: {}, proposals: {} };
 }
-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 {
+function parseFile(text) {
+  const file = blankFile();
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return file;
+  }
+  if (typeof raw !== "object" || raw === null) return file;
+  const obj = raw;
+  if (typeof obj.startedAt === "string") file.startedAt = obj.startedAt;
+  if (typeof obj.finishedAt === "string") file.finishedAt = obj.finishedAt;
+  file.briefRequested = obj.briefRequested === true;
+  if (typeof obj.answers === "object" && obj.answers !== null) {
+    for (const [id, answer] of Object.entries(obj.answers)) {
+      const clean = cleanAnswer(answer);
+      if (clean) file.answers[id] = clean;
     }
   }
-  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;
+  if (typeof obj.proposals === "object" && obj.proposals !== null) {
+    for (const [id, value] of Object.entries(obj.proposals)) {
+      const record = value;
+      if (!record || !CLI_NAMES.includes(record.cli) || !PROFILES.includes(record.profile)) continue;
+      file.proposals[id] = {
+        cli: record.cli,
+        profile: record.profile,
+        sessionId: typeof record.sessionId === "string" ? record.sessionId : null,
+        status: record.status === "ready" || record.status === "failed" ? record.status : "working",
+        result: record.result ?? null,
+        error: typeof record.error === "string" ? record.error : null,
+        version: typeof record.version === "number" ? record.version : 0,
+        conversation: Array.isArray(record.conversation) ? record.conversation.filter(
+          (line) => typeof line === "object" && line !== null && (line.from === "you" || line.from === "it") && typeof line.text === "string"
+        ) : []
+      };
     }
   }
-  return found;
-}
-async function hasArchive(config) {
-  try {
-    return (await readdir2(config.archiveDir)).some((name) => name.endsWith(".json"));
-  } catch {
-    return false;
+  return file;
+}
+function cleanAnswer(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const obj = value;
+  if (obj.later === true) return { later: true };
+  const choices = {};
+  const fields = {};
+  if (typeof obj.choices === "object" && obj.choices !== null) {
+    for (const [id, values] of Object.entries(obj.choices)) {
+      if (Array.isArray(values)) choices[id] = [...new Set(values.filter((v) => typeof v === "string" && v.trim() !== ""))];
+    }
   }
-}
-async function exists(path) {
-  try {
-    await stat3(path);
-    return true;
-  } catch {
-    return false;
+  if (typeof obj.fields === "object" && obj.fields !== null) {
+    for (const [id, text] of Object.entries(obj.fields)) {
+      if (typeof text === "string") fields[id] = text;
+    }
   }
+  return { choices, fields };
 }
-async function firstBriefPending(config) {
-  return !await exists(config.itemsFile) && !await hasArchive(config);
+function given(answer) {
+  return answer && answer.later !== true ? answer : null;
 }
-async function setupState(config, opts) {
-  let sources = null;
-  try {
-    sources = await readFile7(config.sourcesFile, "utf8");
-  } catch {
-    sources = null;
-  }
-  const supported = process.platform === "darwin";
+function answerFromCard(card2) {
   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")
-    }
+    choices: Object.fromEntries(card2.choices.map((choice2) => [choice2.id, choice2.selected])),
+    fields: Object.fromEntries(card2.fields.map((field2) => [field2.id, field2.value]))
   };
 }
-var identity = null;
-function detectIdentity(config) {
-  identity ??= (async () => {
-    const [user, email] = await Promise.all([
-      run4(config.github.ghPath, ["api", "user", "--jq", '[.login, .name // ""] | join("\\n")'], { timeout: 5e3 }).then(
-        ({ stdout }) => stdout.split("\n"),
-        () => []
-      ),
-      run4("git", ["config", "--global", "user.email"], { timeout: 2e3 }).then(
-        ({ stdout }) => stdout.trim() || null,
-        () => null
-      )
-    ]);
+var Onboarding = class {
+  file = null;
+  loaded = false;
+  running = /* @__PURE__ */ new Map();
+  steps = /* @__PURE__ */ new Map();
+  /** Calendar.app's calendars being listed, which only starting the sessions waits for. */
+  calendars = null;
+  /** What listing them found, once it has: the calendars, or why they couldn't be listed. */
+  listed = null;
+  finishError = null;
+  config;
+  deps;
+  spawnFn;
+  gates = /* @__PURE__ */ new Map();
+  codexOff = null;
+  codexModel = null;
+  /** What looking for the CLIs found, once the screen has asked. Not kept: what is installed changes. */
+  detected = null;
+  detecting = null;
+  /** The pass starting sessions, which the next one waits for; see `startProposals`. */
+  starting = Promise.resolve();
+  /** The write in progress, which the next one waits for. */
+  writes = Promise.resolve();
+  constructor(config, deps) {
+    this.config = config;
+    this.deps = deps;
+    this.spawnFn = deps.spawnFn ?? spawn2;
+  }
+  /** Whether a session has a process going. A restart waits for none. */
+  get busy() {
+    return this.running.size > 0;
+  }
+  /**
+   * Read the file, and start again any session the last process left going.
+   * Only while setup is still to do: `needed` is the caller's `firstBriefPending`.
+   */
+  async start(needed) {
+    await this.load();
+    if (!needed || this.file?.finishedAt) return;
+    for (const record of Object.values(this.file?.proposals ?? {})) {
+      if (record.status === "working") {
+        record.status = "failed";
+        record.error = RESTARTED;
+      }
+    }
+    this.startProposals();
+  }
+  /** The screen, while setup is to do: the store has never had a brief, and setup hasn't finished. */
+  async view(setup) {
+    await this.load();
+    if (!setup.needed || this.file?.finishedAt) return null;
+    const file = this.file ?? blankFile();
+    const ctx = await this.context({ setup });
+    const sources = this.deps.readSources();
+    const answers = this.effective(ctx, file.answers);
+    const steps = [];
+    for (const question of this.questions(ctx)) {
+      const locked = this.locked(question, sources);
+      const drawn = question.card(ctx);
+      const record = file.proposals[question.id];
+      const answer = locked ? question.id === "cli" ? { choices: { cli: ctx.cli ? [ctx.cli] : [] }, fields: {} } : answerFromCard(drawn) : answers[question.id] ?? null;
+      const chosen = given(answer);
+      const looking = question.id === "cli" && !answer && !this.detected;
+      steps.push({
+        id: question.id,
+        title: question.title(ctx),
+        topic: question.topic,
+        status: answer ? chosen ? "answered" : "later" : "open",
+        summary: chosen ? question.summary(chosen, ctx) : answer ? question.later?.summary ?? null : null,
+        locked,
+        card: { ...drawn, version: record?.version ?? 0, revisable: Boolean(question.agent && record), later: question.later?.label ?? null },
+        proposal: looking ? {
+          status: "working",
+          conversation: [],
+          steps: [{ kind: "tool", text: "Look for Codex and Claude Code", detail: null, state: "running" }],
+          error: null
+        } : record ? {
+          status: record.status,
+          conversation: record.conversation,
+          steps: this.steps.get(question.id) ?? [],
+          error: record.status === "failed" ? record.error : null
+        } : null,
+        answer
+      });
+    }
     return {
-      login: config.github.accounts[0] ?? (user[0]?.trim() || null),
-      name: user[1]?.trim() || null,
-      email
+      detected: this.detected !== null,
+      steps,
+      current: steps.find((step) => step.status === "open")?.id ?? null,
+      error: this.finishError
     };
-  })();
-  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;
+  }
+  /**
+   * Look for the CLIs, which the screen asks for when it opens: with one ready,
+   * the first question answers itself. Asked again by Check again.
+   */
+  async detect() {
+    await this.load();
+    await this.lookForClis(true);
+    this.startProposals();
+    this.deps.onChange();
+  }
+  /**
+   * Record an answer, or that the user would rather decide later. One whose
+   * settings the dashboard would refuse is refused here, while the card that
+   * can fix it is still open.
+   */
+  async answer(id, raw) {
+    await this.load();
+    const file = this.file ??= blankFile();
+    if (file.finishedAt) return "setup has finished";
+    const question = questionById(id);
+    let answer = cleanAnswer(raw);
+    if (!question || !answer) return `there is no question ${JSON.stringify(id)}, or that is not an answer to it`;
+    if (!given(answer) && !question.later) return `"${question.topic}" needs an answer`;
+    if (id === "cli" && given(answer)) {
+      const chosen = await this.chooseCli(given(answer));
+      if (typeof chosen === "string") return chosen;
+      answer = chosen;
+    }
+    const ctx = await this.context();
+    const before = { cli: ctx.cli, profile: ctx.profile };
+    if (given(answer) && question.settings) {
+      const refused = this.deps.checkSettings(this.settingsOf({ ...file.answers, [id]: answer }, await this.context({ answers: { ...file.answers, [id]: answer } })));
+      if (refused) return refused;
+    }
+    file.answers[id] = answer;
+    this.finishError = null;
+    await this.stop(id, "you continued before it finished");
+    const after = await this.context();
+    if (after.profile !== before.profile) {
+      for (const other of QUESTIONS) {
+        if (!other.agent) continue;
+        delete file.answers[other.id];
+        await this.drop(other.id);
+      }
+    } else if (after.cli !== before.cli) {
+      for (const other of QUESTIONS) if (other.agent && !file.answers[other.id]) await this.drop(other.id);
+    }
+    await this.save();
+    this.startProposals();
+    this.deps.onChange();
+    return null;
+  }
+  /** Tell a question's session what to change. `draft` is what the card holds now, which it should start from. */
+  async revise(id, text, draft) {
+    await this.load();
+    const question = questionById(id);
+    const record = this.file?.proposals[id];
+    if (!question?.agent || !record) return "nothing is looking into that question";
+    if (this.running.has(id)) return "it is still working on that question";
+    const ctx = await this.context();
+    const current = cleanAnswer(draft);
+    const request = [
+      `The user says: ${text.trim()}`,
+      ...given(current) ? ["", "What the card holds now, which they may have changed:", "", "```json", JSON.stringify(current), "```"] : [],
+      "",
+      "Revise your proposal, and answer with the whole of it again."
+    ].join("\n");
+    const resume = record.sessionId && record.cli === ctx.cli ? record.sessionId : null;
+    const said = [...record.conversation, { from: "you", text: text.trim() }];
+    await this.ask(question, ctx, resume ? request : `${await this.firstMessage(question, ctx)}
+
+${request}`, resume, said);
+    return null;
+  }
+  /**
+   * Look again: ask a question's session again from the start, after it failed,
+   * and list Calendar.app's calendars again for the question that shows them,
+   * since what failed may have been the access the user has since granted.
+   */
+  async retry(id) {
+    await this.load();
+    const question = questionById(id);
+    if (!question) return `there is no question ${JSON.stringify(id)}`;
+    if (this.running.has(id)) return "it is still working on that question";
+    if (id === "calendars") {
+      this.calendars = null;
+      this.listed = null;
+    }
+    if (id === "cli") await this.lookForClis(true);
+    if (question.agent) await this.drop(id);
+    this.startProposals();
+    this.deps.onChange();
+    return null;
+  }
+  /**
+   * Save everything, and ask for the first brief. Files first, then the
+   * settings, whose save restarts the dashboard: the start after it begins the
+   * run. Resolves with why not, or null.
+   */
+  async finish() {
+    await this.load();
+    const file = this.file ??= blankFile();
+    if (file.finishedAt) return { error: "setup has already finished" };
+    if (!file.answers.cli) await this.lookForClis(false);
+    const ctx = await this.context();
+    const sources = this.deps.readSources();
+    const answers = this.effective(ctx, file.answers);
+    const sections = [];
+    let objective2 = null;
+    for (const question of this.questions(ctx)) {
+      const answer = answers[question.id];
+      if (!answer && !this.locked(question, sources)) return this.refuse(`answer "${question.title(ctx)}", or decide it later`);
+      const chosen = this.locked(question, sources) ? null : given(answer);
+      if (!chosen) continue;
+      sections.push(...question.sources?.(chosen, ctx) ?? []);
+      objective2 = question.objective?.(chosen) ?? objective2;
+    }
+    const values = this.settingsOf(file.answers, ctx);
+    const refused = this.deps.checkSettings(values);
+    if (refused) return this.refuse(refused);
+    await this.starting;
+    for (const id of [...this.running.keys()]) await this.stop(id, "setup finished");
+    const existing = await readEditable(this.config.sourcesFile);
+    if (existing.text === null && sections.length > 0) {
+      await mkdir2(this.config.dataDir, { recursive: true });
+      await saveEditable(this.config.sourcesFile, composeSources(ctx.profile, sections, (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)), ABSENT);
+    }
+    if (objective2) {
+      const focus = await readEditable(this.config.focusFile);
+      const saved = await saveEditable(this.config.focusFile, setFocusFields(focus.text, objective2, FOCUS_TEMPLATE), focus.version);
+      if (!saved.saved) return this.refuse("focus.md changed on disk while saving; finish again");
+    }
+    file.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    file.briefRequested = ctx.cli !== null;
+    await this.save();
+    const before = JSON.stringify(Object.entries(sources.settings).sort());
+    const saveRefused = await this.deps.saveSettings(values);
+    if (saveRefused) {
+      file.finishedAt = null;
+      file.briefRequested = false;
+      await this.save();
+      return this.refuse(saveRefused);
+    }
+    this.finishError = null;
+    this.deps.onChange();
+    return { restart: JSON.stringify(Object.entries(this.deps.readSources().settings).sort()) !== before };
+  }
+  /**
+   * Whether the finish asked for a first brief that hasn't been started, and
+   * forget it: asked once, so a run that fails is retried by the user, not by
+   * every start.
+   */
+  async takeBriefRequest() {
+    await this.load();
+    if (!this.file?.briefRequested) return false;
+    this.file.briefRequested = false;
+    await this.save();
+    return true;
+  }
+  /** What the finish would write as the source list, or null when the store already has one it would keep. */
+  async previewSources() {
+    await this.load();
+    const existing = await readEditable(this.config.sourcesFile);
+    if (existing.text !== null) return { text: null, kept: true };
+    const ctx = await this.context();
+    const sections = [];
+    for (const question of this.questions(ctx)) {
+      const chosen = given(this.file?.answers[question.id]);
+      if (chosen) sections.push(...question.sources?.(chosen, ctx) ?? []);
+    }
+    return { text: sections.length ? composeSources(ctx.profile, sections, (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)) : null, kept: false };
+  }
+  /** Stop every session, for shutdown, and wait until each has exited and been written down. */
+  async close() {
+    await this.starting;
+    const over = [...this.running.values()].map((run5) => run5.over);
+    for (const id of [...this.running.keys()]) await this.stop(id, RESTARTED);
+    await Promise.all(over);
+  }
+  /* ---------- the sessions ---------- */
+  /**
+   * Start whatever sessions the answers so far call for, without holding up the
+   * reply that asked: starting one under Codex runs a few checks first, and a
+   * screen waiting on them has every button greyed out with nothing to say why.
+   * One pass at a time, so two quick answers can't both start the same question.
+   */
+  startProposals() {
+    this.starting = this.starting.then(() => this.ensureProposals()).catch((err) => console.error(`[daily-focus] setup could not start looking: ${err.message}`));
+  }
+  /** Resolves once the sessions asked for so far have started: for tests, and for anything that must not race them. */
+  started() {
+    return this.starting;
+  }
+  /** Start a session for each question that has one and needs it: the CLI and the profile are known, and nobody has asked yet. */
+  async ensureProposals() {
+    const file = this.file;
+    if (!file || file.finishedAt) return;
+    if (Object.keys(file.answers).length === 0) return;
+    const set = (this.deps.readSources().process.DAILY_FOCUS_AGENT ?? "").trim();
+    if (file.answers.cli && !given(file.answers.cli) || set && !CLI_NAMES.includes(set)) return;
+    await this.lookForClis(false);
+    const ctx = await this.context({ listCalendars: true });
+    const sources = this.deps.readSources();
+    const profileKnown = given(file.answers.profile) !== null || (sources.process.DAILY_FOCUS_PROFILE ?? "").trim() !== "";
+    if (!ctx.cli || !profileKnown) return;
+    for (const question of this.questions(ctx)) {
+      if (!question.agent || file.answers[question.id] || this.running.has(question.id)) continue;
+      const record = file.proposals[question.id];
+      if (record && record.cli === ctx.cli && record.profile === ctx.profile && record.status !== "failed") continue;
+      if (record?.status === "failed" && record.error !== RESTARTED && record.cli === ctx.cli && record.profile === ctx.profile) continue;
+      await this.ask(question, ctx, await this.firstMessage(question, ctx), null);
+    }
+  }
+  /** The first message of a question's session: the instructions, what is known, and the question. */
+  async firstMessage(question, ctx) {
+    const instructions = await readFile8(this.config.onboardingPromptSource, "utf8").catch(
+      () => "You are helping someone set up Daily Focus. Only read; never send, post or edit anything. Answer with the JSON the schema asks for."
+    );
+    const agent = question.agent;
+    const facts = agent.facts?.(ctx) ?? null;
+    return [
+      instructions.trim(),
+      "",
+      "## This setup",
+      "",
+      `- Profile: ${ctx.profile}`,
+      `- Today: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`,
+      "",
+      `## The question: ${question.title(ctx)}`,
+      "",
+      agent.brief(ctx),
+      ...facts ? ["", "### What the dashboard already knows", "", facts] : []
+    ].join("\n");
+  }
+  async ask(question, ctx, prompt, resume, conversation = []) {
+    const file = this.file ??= blankFile();
+    const cli2 = ctx.cli;
+    const previous = file.proposals[question.id];
+    const record = {
+      cli: cli2,
+      profile: ctx.profile,
+      sessionId: resume,
+      status: "working",
+      result: previous?.cli === cli2 && previous.profile === ctx.profile ? previous.result : null,
+      error: null,
+      version: previous?.version ?? 0,
+      conversation
+    };
+    file.proposals[question.id] = record;
+    this.steps.set(question.id, []);
+    await this.save();
+    this.deps.onChange();
+    const bin = ctx.clis?.[cli2]?.path ?? null;
+    if (!bin) return this.settle(question.id, record, { ok: false, error: `could not find ${cli2} on this machine` });
+    if (cli2 === "codex") {
+      const gate = this.gates.get(bin) ?? new CodexGate(bin, this.deps.execFn);
+      this.gates.set(bin, gate);
+      const refusal2 = await gate.refusal();
+      if (refusal2) return this.settle(question.id, record, { ok: false, error: refusal2 });
+    }
+    let codexConfig = [];
+    if (cli2 === "codex") {
+      try {
+        this.codexOff ??= computerUseOff(bin, this.deps.execFn);
+        codexConfig = await this.codexOff;
+      } catch (err) {
+        this.codexOff = null;
+        return this.settle(question.id, record, { ok: false, error: `Codex could not say which plugins to switch off: ${err.message}` });
+      }
+    }
+    const schemaDir = await mkdtemp(join5(tmpdir2(), "daily-focus-setup-"));
+    const schemaFile = join5(schemaDir, "schema.json");
+    const json = JSON.stringify(question.agent.schema);
+    await writeFile2(schemaFile, json, "utf8");
+    await mkdir2(this.config.onboardingDir, { recursive: true });
+    const adapter = ADAPTERS[cli2];
+    const session = SESSION_MODEL[cli2];
+    const model = cli2 === "codex" ? await (this.codexModel ??= codexLatestModel(bin, this.deps.execFn)) : session.model;
+    const args = adapter.args({
+      prompt,
+      sessionId: resume,
+      model,
+      effort: session.effort,
+      tools: ONBOARDING_TOOLS,
+      denyEdits: true,
+      drafts: false,
+      codexConfig,
+      schema: { json, file: schemaFile }
+    });
+    let child;
+    try {
+      child = this.spawnFn(bin, args, { cwd: this.config.onboardingDir, stdio: ["ignore", "pipe", "pipe"], env: process.env });
+    } catch (err) {
+      await rm2(schemaDir, { recursive: true, force: true });
+      return this.settle(question.id, record, { ok: false, error: `could not run ${bin}: ${err.message}` });
+    }
+    const timer = setTimeout(() => void this.stop(question.id, "gave up after four minutes"), TURN_TIMEOUT_MS2);
+    timer.unref();
+    let ended;
+    const run5 = { child, timer, abortReason: null, over: new Promise((resolve2) => ended = resolve2) };
+    this.running.set(question.id, run5);
+    let done;
+    let said = "";
+    const stderr = [];
+    child.stderr?.on("data", (chunk) => {
+      stderr.push(chunk.toString("utf8"));
+      if (stderr.length > 50) stderr.shift();
+    });
+    const calls = /* @__PURE__ */ new Map();
+    const steps = this.steps.get(question.id);
+    const add = (step) => {
+      steps.push(step);
+      if (steps.length > STEPS_KEPT) steps.shift();
+    };
+    if (child.stdout) {
+      createInterface2({ input: child.stdout }).on("line", (line) => {
+        const event = adapter.parse(line);
+        if (!event) return;
+        if (event.sessionId) record.sessionId = event.sessionId;
+        if (event.text) said = event.text;
+        for (const parsed of event.steps ?? []) {
+          const known = calls.get(parsed.id);
+          if (known) {
+            if (parsed.text) known.text = parsed.text;
+            if (parsed.detail) known.detail = parsed.detail;
+            known.state = parsed.state;
+          } else if (parsed.text) {
+            const step = { kind: "tool", text: parsed.text, detail: parsed.detail ?? null, state: parsed.state };
+            calls.set(parsed.id, step);
+            add(step);
+          }
+        }
+        if (event.steps) this.deps.onChange();
+        if (event.done) done = event.done;
+      });
+    }
+    child.on("error", (err) => {
+      done = { ok: false, error: `could not run ${bin}: ${err.message}` };
+    });
+    child.on("exit", () => {
+      if (run5.abortReason === null) return;
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      this.running.delete(question.id);
+      void rm2(schemaDir, { recursive: true, force: true });
+      const outcome = run5.abortReason ? { ok: false, error: run5.abortReason } : done ?? {
+        ok: false,
+        error: `${cli2} exited with code ${code}${stderr.length ? `: ${stderr.join("").trim().split("\n").slice(-3).join(" ")}` : ""}`
+      };
+      void this.settle(question.id, record, outcome.ok ? { ok: true, reply: outcome.reply ?? said } : outcome).catch((err) => console.error(`[daily-focus] setup could not keep what it found: ${err.message}`)).finally(ended);
+    });
+  }
+  /** A session is over: keep its answer when it is JSON, or why it isn't. */
+  async settle(id, record, outcome) {
+    if (this.file?.proposals[id] !== record) return;
+    for (const step of this.steps.get(id) ?? []) if (step.state === "running") step.state = outcome.ok ? "done" : "failed";
+    if (outcome.ok) {
+      try {
+        record.result = JSON.parse(stripFence(outcome.reply ?? ""));
+        record.status = "ready";
+        record.error = null;
+        record.version += 1;
+        const why = record.result?.why;
+        if (typeof why === "string" && why.trim()) record.conversation.push({ from: "it", text: why.trim() });
+      } catch {
+        record.status = "failed";
+        record.error = "it answered, but not in the shape asked for";
+      }
+    } else {
+      record.status = "failed";
+      record.error = outcome.error ?? "failed";
+    }
+    await this.save();
+    this.deps.onChange();
+  }
+  /** Stop a session: asked to, then made to if it hasn't gone within a few seconds. */
+  async stop(id, reason) {
+    const run5 = this.running.get(id);
+    if (!run5 || run5.abortReason !== null) return;
+    run5.abortReason = reason;
+    run5.child.kill("SIGTERM");
+    const kill = setTimeout(() => {
+      if (run5.child.exitCode === null && run5.child.signalCode === null) run5.child.kill("SIGKILL");
+    }, KILL_AFTER_MS);
+    kill.unref();
+    void run5.over.then(() => clearTimeout(kill));
+  }
+  /** Forget a question's proposal, stopping its session first. */
+  async drop(id) {
+    await this.stop(id, "no longer needed");
+    if (this.file) delete this.file.proposals[id];
+    this.steps.delete(id);
+  }
+  /* ---------- what a question may read ---------- */
+  /**
+   * Look for the CLIs, once per process unless `again`. Only from a click or
+   * from setup already under way: `--version` and a login check are programs
+   * run on the user's behalf, and a new store's state is read before anyone is
+   * at the screen.
+   */
+  async lookForClis(again) {
+    if (this.detected && !again) return;
+    this.detecting ??= this.deps.detectClis().finally(() => {
+      this.detecting = null;
+    });
+    this.detected = await this.detecting;
+  }
+  /**
+   * The CLI answer to keep: one of the ready ones, or a path the user typed,
+   * which is used only once it has said what it is and that it is ready.
+   * Otherwise why not, in a sentence the card shows.
+   */
+  async chooseCli(answer) {
+    const typed = answer.fields.path?.trim();
+    if (!typed) {
+      const picked = answer.choices.cli?.[0];
+      await this.lookForClis(false);
+      if (picked && this.detected?.[picked]?.ready) return { choices: { cli: [picked] }, fields: {} };
+      return "Enter the path to codex or claude, or decide this later";
+    }
+    const { cli: cli2, found } = await this.deps.probeCli(expandHome(typed));
+    if (!cli2 || !found.ready) {
+      return `${found.problem ?? "That can't be used"}${found.fix ? `: run ${found.fix} in a terminal, then try again.` : "."}`;
+    }
+    await this.lookForClis(false);
+    this.detected = { ...this.detected, [cli2]: found };
+    return { choices: { cli: [cli2] }, fields: { path: found.path } };
+  }
+  /**
+   * The answers as they stand, with the CLI setup picked without asking when
+   * the user hasn't picked one: the first ready, or the one already set.
+   */
+  effective(ctx, answers) {
+    if (answers.cli || !ctx.cli) return { ...answers };
+    return { ...answers, cli: { choices: { cli: [ctx.cli] }, fields: {} } };
+  }
+  /** Set in the environment, which wins over setup: shown as it stands, never asked. */
+  locked(question, sources) {
+    return question.keys.length > 0 && question.keys.every((key) => (sources.process[key] ?? "").trim() !== "");
+  }
+  /**
+   * The settings these answers add up to, in question order, less what the
+   * environment sets: that can't be saved over, and wins anyway.
+   */
+  settingsOf(answers, ctx) {
+    const sources = this.deps.readSources();
+    const values = {};
+    const effective = this.effective(ctx, answers);
+    for (const question of this.questions(ctx)) {
+      const chosen = this.locked(question, sources) ? null : given(effective[question.id]);
+      if (chosen) Object.assign(values, question.settings?.(chosen, ctx) ?? {});
+    }
+    for (const key of Object.keys(values)) if ((sources.process[key] ?? "").trim() !== "") delete values[key];
+    return values;
+  }
+  questions(ctx) {
+    return QUESTIONS.filter((question) => !question.applies || question.applies(ctx));
+  }
+  /**
+   * Everything a question may read. The CLI and the profile are the answers
+   * when given, else what is in effect, else the card's own pick, so the
+   * questions that follow from them are counted from the start.
+   *
+   * Calendar.app's calendars only as already listed, unless `listCalendars`:
+   * the helper may ask for calendar access, so it is launched only from a
+   * click, never from a state read, which any GET makes.
+   */
+  async context(opts = {}) {
+    const sources = this.deps.readSources();
+    const env = layerEnv(sources);
+    const current = {};
+    for (const def of SETTINGS) {
+      const value = (env[def.key] ?? "").trim();
+      if (value) current[def.key] = value;
+    }
+    const setup = opts.setup ?? await this.deps.setup();
+    const answers = opts.answers ?? this.file?.answers ?? {};
+    const profileAnswer = given(answers.profile)?.choices.profile?.[0];
+    const profile2 = PROFILES.includes(profileAnswer) ? profileAnswer : current.DAILY_FOCUS_PROFILE === "personal" ? "personal" : "work";
+    const cliAnswer = given(answers.cli);
+    const typed = cliAnswer?.fields.path?.trim();
+    const answered = cliAnswer?.choices.cli?.[0];
+    let clis = this.detected;
+    if (clis && typed && answered && CLI_NAMES.includes(answered) && clis[answered].path !== typed) {
+      clis = { ...clis, [answered]: { ...clis[answered], path: typed, onPath: false, ready: true, problem: null, fix: null } };
+    }
+    const set = current.DAILY_FOCUS_AGENT;
+    const cliLocked = (sources.process.DAILY_FOCUS_AGENT ?? "").trim() !== "";
+    const cli2 = answers.cli ? answered ?? null : cliLocked ? set && CLI_NAMES.includes(set) ? set : null : set && clis?.[set]?.ready ? set : clis ? preferredCli(clis) : null;
+    const started = Object.keys(answers).length > 0;
+    const profileKnown = started && (given(answers.profile) !== null || (sources.process.DAILY_FOCUS_PROFILE ?? "").trim() !== "");
+    let calendars2 = null;
+    const liveAgenda = !["off", "false", "0", "no"].includes((current.DAILY_FOCUS_CALENDAR ?? "").toLowerCase());
+    if (setup.calendar.supported && setup.calendar.built && liveAgenda) {
+      if (opts.listCalendars === true && profileKnown) {
+        this.calendars ??= this.deps.listCalendars().catch((err) => err instanceof Error ? err.message : String(err)).then((listed2) => {
+          this.listed = listed2;
+        });
+        await this.calendars;
+      }
+      calendars2 = this.listed;
+    }
+    const proposals = {};
+    for (const [id, record] of Object.entries(this.file?.proposals ?? {})) {
+      if (record.cli === cli2 && record.profile === profile2 && record.result !== null) proposals[id] = record.result;
+    }
+    return {
+      machine: machineName(),
+      profile: profile2,
+      cli: cli2 && CLI_NAMES.includes(cli2) ? cli2 : null,
+      clis,
+      identity: started ? await this.deps.identity() : { name: null, login: null, logins: [], email: null },
+      calendars: calendars2,
+      calendar: setup.calendar,
+      boards: await this.deps.boards(),
+      current,
+      proposals
+    };
+  }
+  /* ---------- the file ---------- */
+  async load() {
+    if (this.loaded) return;
+    this.loaded = true;
+    try {
+      this.file = parseFile(await readFile8(this.config.onboardingFile, "utf8"));
+    } catch {
+      this.file = null;
+    }
+  }
+  /**
+   * Write the file as it is now. One write at a time: sessions settle side by
+   * side, and two renames of the same temporary file would trip over each other.
+   */
+  save() {
+    const write = this.writes.then(async () => {
+      if (!this.file) return;
+      await mkdir2(this.config.dataDir, { recursive: true });
+      await writeJsonAtomic(this.config.onboardingFile, this.file);
+    });
+    this.writes = write.catch(() => {
+    });
+    return write;
+  }
+  refuse(error) {
+    this.finishError = error;
+    this.deps.onChange();
+    return { error };
+  }
+};
+function stripFence(text) {
+  const fenced = /^```(?:json)?\s*\n([\s\S]*?)\n```\s*$/.exec(text.trim());
+  return fenced ? fenced[1] : text.trim();
 }
 
 // src/shellpath.ts
-import { spawn as spawn2 } from "node:child_process";
+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 = spawn2(file, args, { detached: true, stdio: ["ignore", "pipe", "ignore"] });
+  const child = spawn3(file, args, { detached: true, stdio: ["ignore", "pipe", "ignore"] });
   let output = "";
   let settled = false;
   const finish = (error) => {
@@ -3650,7 +5073,7 @@ async function hydratePath(env = process.env, platform = process.platform, exec
 
 // src/server.ts
 var PUBLIC_DIR = resolve(fileURLToPath(new URL("../public", import.meta.url)));
-var VERSION = packageVersion();
+var VERSION2 = packageVersion();
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -3693,7 +5116,7 @@ async function readBody(req) {
 }
 async function serveStatic(res, urlPath) {
   const relative = normalize(decodeURIComponent(urlPath === "/" ? "/index.html" : urlPath));
-  const filePath = join4(PUBLIC_DIR, relative);
+  const filePath = join6(PUBLIC_DIR, relative);
   if (filePath !== PUBLIC_DIR && !filePath.startsWith(PUBLIC_DIR + sep)) {
     res.writeHead(403).end("Forbidden");
     return;
@@ -3743,7 +5166,7 @@ function configure(sources) {
 function statusOf(state, config, busy) {
   const last = state.agentRun.last;
   return {
-    version: VERSION,
+    version: VERSION2,
     dataDir: config.dataDir,
     profile: config.profile,
     setupNeeded: state.setup.needed,
@@ -3782,7 +5205,7 @@ async function startServer(env, options = {}) {
   let restart = null;
   let restarting = false;
   let settingsWrites = Promise.resolve();
-  await stat4(join4(PUBLIC_DIR, "app.js")).catch(() => {
+  await stat4(join6(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)"
     );
@@ -3822,6 +5245,46 @@ async function startServer(env, options = {}) {
       restartWhenIdle();
     }
   });
+  const onboarding = new Onboarding(config, {
+    onChange: () => {
+      void broadcast();
+      restartWhenIdle();
+    },
+    // A path already set for either CLI is looked at before PATH.
+    detectClis: () => {
+      const configured = {};
+      if (config.agent.cli && config.agent.binPath !== config.agent.cli) configured[config.agent.cli] = config.agent.binPath;
+      if (config.assistant.agent && config.assistant.binPath !== config.assistant.agent) configured[config.assistant.agent] = config.assistant.binPath;
+      return detectClis(configured);
+    },
+    probeCli: (path) => probeCli(path, null, false),
+    readSources,
+    setup: () => setupState(config),
+    identity: () => detectIdentity(config),
+    boards: async () => {
+      const actions = await store.readActions();
+      const now = /* @__PURE__ */ new Date();
+      const health = (view) => ({
+        enabled: view.enabled,
+        fetchedAt: view.fetchedAt,
+        reason: view.reason?.message ?? null
+      });
+      return { github: health(board.view(actions, now)), jira: health(tickets.view(actions, now)) };
+    },
+    listCalendars: async () => {
+      const facts = await runHelper(config.calendar.appPath, []);
+      const today = /* @__PURE__ */ new Map();
+      for (const event of facts.events) {
+        if (typeof event.calendarId === "string") today.set(event.calendarId, (today.get(event.calendarId) ?? 0) + 1);
+      }
+      return facts.calendars.map(({ id, title, source }) => ({ title, source, eventsToday: today.get(id) ?? 0 }));
+    },
+    checkSettings: (values) => {
+      const applied = applySettingsChange(readSources(), values);
+      return "error" in applied ? applied.error : null;
+    },
+    saveSettings: (values) => saveSettingsValues(values)
+  });
   let codexWarnings = [];
   const codexBins = /* @__PURE__ */ new Set();
   if (config.agent.cli === "codex") codexBins.add(config.agent.binPath);
@@ -3831,12 +5294,34 @@ async function startServer(env, options = {}) {
     for (const warning of codexWarnings) console.warn(`[daily-focus] ${warning}`);
     if (codexWarnings.length > 0) void broadcast();
   });
+  async function startRequestedBrief() {
+    if (!agent.enabled || !await firstBriefPending(config) || !await onboarding.takeBriefRequest()) return;
+    await agent.run("hand").catch((err) => {
+      console.error(`[daily-focus] could not start the first brief: ${err.message}`);
+    });
+  }
+  function saveSettingsValues(values) {
+    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(() => {
+    });
+    return saved;
+  }
   function requestRestart() {
     restart = options.onRestart ? "waiting" : "manual";
     restartWhenIdle();
   }
   function restartWhenIdle() {
-    if (restart !== "waiting" || restarting || agent.busy || assistant.busy) return;
+    if (restart !== "waiting" || restarting || agent.busy || assistant.busy || onboarding.busy) return;
     restarting = true;
     setImmediate(() => options.onRestart?.());
   }
@@ -3848,11 +5333,9 @@ async function startServer(env, options = {}) {
       // 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())
-    });
+    const setup = await setupState(config);
     const pulls = board.view(actions, now);
+    const onboardingState = await onboarding.view(setup);
     return {
       ...state,
       board: pulls,
@@ -3862,6 +5345,7 @@ async function startServer(env, options = {}) {
       setupWarnings: [...configWarnings, ...codexWarnings, ...linkWarning ? [linkWarning] : []],
       restart,
       setup,
+      onboarding: onboardingState,
       assetVersion,
       storeId
     };
@@ -3907,7 +5391,13 @@ data: ${payload}
         basename(tempPathFor(config.timeZoneFile)),
         // Appended by this process, which broadcasts on its own.
         basename(config.assistantLogFile),
-        basename(config.agentLogFile)
+        basename(config.agentLogFile),
+        // Rewritten by the runner before every run; nothing on the page shows it.
+        basename(config.agentSettingsFile),
+        basename(tempPathFor(config.agentSettingsFile)),
+        // Rewritten by the setup screen, which broadcasts on its own.
+        basename(config.onboardingFile),
+        basename(tempPathFor(config.onboardingFile))
       ]
     }
   );
@@ -3920,6 +5410,8 @@ data: ${payload}
   });
   await assistant.start();
   await agent.start();
+  await onboarding.start(await firstBriefPending(config));
+  await startRequestedBrief();
   let ticks = Promise.resolve();
   function clockTick() {
     ticks = ticks.then(tickOnce).catch((err) => {
@@ -4218,6 +5710,40 @@ data: ${JSON.stringify(await buildState())}
       void broadcast(state);
       return;
     }
+    if (path.startsWith("/api/onboarding/") && req.method === "POST") {
+      const body = await readJsonObject(req, res);
+      if (!body) return;
+      const step = typeof body.step === "string" ? body.step : "";
+      let refused2 = null;
+      if (path === "/api/onboarding/answer") {
+        refused2 = await onboarding.answer(step, body.answer);
+      } else if (path === "/api/onboarding/revise") {
+        refused2 = typeof body.text === "string" && body.text.trim() !== "" ? await onboarding.revise(step, body.text, body.draft) : '"text" is required: what to change';
+      } else if (path === "/api/onboarding/retry") {
+        refused2 = await onboarding.retry(step);
+      } else if (path === "/api/onboarding/detect") {
+        await onboarding.detect();
+      } else if (path === "/api/onboarding/finish") {
+        const finished = await onboarding.finish();
+        if ("error" in finished) refused2 = finished.error;
+        else if (!finished.restart) await startRequestedBrief();
+      } else {
+        sendJSON(res, 404, { error: `no such setup action: ${path}` });
+        return;
+      }
+      if (refused2) {
+        sendJSON(res, 409, { error: refused2 });
+        return;
+      }
+      const state = await buildState();
+      sendState(res, state);
+      void broadcast(state);
+      return;
+    }
+    if (path === "/api/onboarding/sources" && req.method === "GET") {
+      sendJSON(res, 200, await onboarding.previewSources());
+      return;
+    }
     if (path === "/api/settings" && req.method === "GET") {
       sendJSON(res, 200, { ...describeSettings(readSources()), restart });
       return;
@@ -4230,20 +5756,7 @@ data: ${JSON.stringify(await buildState())}
         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;
+      const refused2 = await saveSettingsValues(values);
       if (refused2) {
         sendJSON(res, 400, { error: refused2 });
         return;
@@ -4283,8 +5796,8 @@ data: ${JSON.stringify(await buildState())}
     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]]) {
+      const { objective: objective2, blocker } = body;
+      for (const [name, value] of [["objective", objective2], ["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;
@@ -4293,7 +5806,7 @@ data: ${JSON.stringify(await buildState())}
       const current = await readEditable(config.focusFile);
       const next = setFocusFields(
         current.text,
-        { objective: objective ?? null, blocker: blocker ?? null },
+        { objective: objective2 ?? null, blocker: blocker ?? null },
         FOCUS_TEMPLATE
       );
       const result = await saveEditable(config.focusFile, next, current.version);
@@ -4310,10 +5823,10 @@ data: ${JSON.stringify(await buildState())}
       try {
         const facts = await runHelper(config.calendar.appPath, []);
         const seen = /* @__PURE__ */ new Set();
-        const calendars = facts.calendars.filter((entry) => !seen.has(`${entry.title}
+        const calendars2 = 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 });
+        sendJSON(res, 200, { calendars: calendars2 });
       } catch (err) {
         sendJSON(res, 409, { error: err.message });
       }
@@ -4352,6 +5865,7 @@ ${entry.source}`)).map(({ title, source }) => ({ title, source })).sort((a, b) =
     tickets.stop();
     await assistant.close();
     await agent.close();
+    await onboarding.close();
     stopWatching();
     stopWatchingAssets();
     for (const res of subscribers) res.end();