daily-focus 1.1.1-dev.3 → 1.2.0-dev.10

package/dist/chunk-ODJGQCM3.js

@@ -0,0 +1,1003 @@
+import {
+  canonicalId,
+  foldActionLog
+} from "./chunk-RZNQJ6UG.js";
+import {
+  laterISO,
+  localDateKey,
+  parseISO
+} from "./chunk-J7ZYVUG6.js";
+
+// src/codex.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var GMAIL_CONNECTOR = "connector_2128aebfecb84f64a069897515042a44";
+var CONNECTOR_POLICY = [
+  'apps._default.default_tools_approval_mode="writes"',
+  'apps._default.approvals_reviewer="user"'
+];
+var GMAIL_DRAFTS = ["create_draft", "update_draft"].map(
+  (tool) => `apps.${GMAIL_CONNECTOR}.tools.${tool}.approval_mode="approve"`
+);
+var COMPUTER_USE_PLUGINS = [
+  "unified-computer-use@openai-bundled",
+  "computer-use@openai-bundled",
+  "browser@openai-bundled",
+  "chrome@openai-bundled"
+];
+var COMPUTER_USE_SERVERS = ["node_repl", "cua_repl", "computer-use"];
+var LIST_TIMEOUT_MS = 3e4;
+var exec = promisify(execFile);
+var defaultExec = async (file, args, { timeout }) => {
+  try {
+    const { stdout } = await exec(file, args, { timeout, maxBuffer: 16 * 1024 * 1024 });
+    return stdout;
+  } catch (err) {
+    const stderr = String(err.stderr ?? "").trim();
+    if (!stderr) throw err;
+    throw new Error(stderr.split("\n").slice(0, 2).join(" "));
+  }
+};
+function configArgs(overrides) {
+  return overrides.flatMap((override) => ["-c", override]);
+}
+async function enabledServers(bin, overrides, run) {
+  const output = await run(bin, ["mcp", "list", "--json", ...configArgs(overrides)], { timeout: LIST_TIMEOUT_MS });
+  let servers;
+  try {
+    servers = JSON.parse(output);
+  } catch {
+    throw new Error("codex mcp list --json printed something other than JSON");
+  }
+  if (!Array.isArray(servers)) throw new Error("codex mcp list --json printed something other than a list");
+  return servers.filter((server) => typeof server?.name === "string").filter((server) => server.enabled !== false).map((server) => server.name);
+}
+async function computerUseOff(bin, run = defaultExec) {
+  const overrides = COMPUTER_USE_PLUGINS.map((plugin) => `plugins.${plugin}.enabled=false`);
+  const left = (await enabledServers(bin, overrides, run)).filter((name) => COMPUTER_USE_SERVERS.includes(name));
+  if (left.length === 0) return overrides;
+  overrides.push(...left.map((name) => `mcp_servers.${name}.enabled=false`));
+  const still = (await enabledServers(bin, overrides, run)).filter((name) => COMPUTER_USE_SERVERS.includes(name));
+  if (still.length > 0) throw new Error(`Codex still starts ${still.join(", ")}`);
+  return overrides;
+}
+var CODEX_CONNECTOR_POLICY = "0.144.0";
+var CODEX_MINIMUM = "0.149.0";
+function versionParts(text) {
+  const match = /(\d+)\.(\d+)\.(\d+)/.exec(text);
+  return match ? match.slice(1, 4).map(Number) : null;
+}
+function olderThan(version, than) {
+  const a = versionParts(version);
+  const b = versionParts(than);
+  if (!a || !b) return false;
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i] < b[i];
+  }
+  return false;
+}
+async function codexVersion(bin, run = defaultExec) {
+  try {
+    return versionParts(await run(bin, ["--version"], { timeout: LIST_TIMEOUT_MS }))?.join(".") ?? null;
+  } catch {
+    return null;
+  }
+}
+function refusalFor(version) {
+  if (!version || !olderThan(version, CODEX_CONNECTOR_POLICY)) return null;
+  return `Codex ${version} is older than ${CODEX_CONNECTOR_POLICY}, which ignores the dashboard's refusal of connector writes without saying so, so the dashboard won't run it. Update Codex`;
+}
+var CodexGate = class {
+  #bin;
+  #run;
+  #cleared = false;
+  constructor(bin, run = defaultExec) {
+    this.#bin = bin;
+    this.#run = run;
+  }
+  async refusal() {
+    if (this.#cleared) return null;
+    const version = await codexVersion(this.#bin, this.#run);
+    const refusal = refusalFor(version);
+    if (version && !refusal) this.#cleared = true;
+    return refusal;
+  }
+};
+async function codexVersionWarning(bin, run = defaultExec) {
+  const version = await codexVersion(bin, run);
+  if (!version || !olderThan(version, CODEX_MINIMUM)) return null;
+  const consequence = olderThan(version, CODEX_CONNECTOR_POLICY) ? `Before ${CODEX_CONNECTOR_POLICY} Codex ignores the dashboard's refusal of connector writes without saying so, so the dashboard won't start the agent or the assistant on it.` : `Before ${CODEX_MINIMUM} Codex can't switch computer use off, so the assistant won't answer while computer use is off in its settings.`;
+  return `Codex ${version} is older than ${CODEX_MINIMUM}, the oldest the dashboard's limits on Codex work with. ${consequence} Update Codex.`;
+}
+
+// src/assistant.ts
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { createInterface } from "node:readline";
+var TURN_TIMEOUT_MS = 10 * 6e4;
+var RESTARTED = "the dashboard restarted while this was running";
+var SHUT_DOWN = "the dashboard shut down";
+var TURNS_SHOWN = 20;
+var STEPS_KEPT = 100;
+var DETAIL_LENGTH = 200;
+var QUICK_ACTIONS = [
+  {
+    id: "assess-review",
+    label: "Assess the review",
+    sources: ["github"],
+    request: "Read every review comment and requested change on this pull request against the diff. For each one say whether it is right, partly right or mistaken, with the evidence, and what I should do about it."
+  },
+  {
+    id: "explain-ci",
+    label: "Explain the CI failure",
+    sources: ["github"],
+    request: "Find the failing checks on this pull request and read their logs. Explain what is failing, why, and the smallest change that would fix it. Do not attempt the fix."
+  },
+  {
+    id: "summarise-pr",
+    label: "Summarise the change",
+    sources: ["github"],
+    request: "Summarise what this pull request changes and why, in a form I could paste as its description, and flag anything a reviewer is likely to push back on."
+  },
+  {
+    id: "reply-reviewer",
+    label: "Draft replies to reviewers",
+    sources: ["github"],
+    request: "Draft a reply to each open review comment on this pull request, in my voice, agreeing where the reviewer is right and explaining where they are not. Give me the text to post. Do not post it."
+  },
+  {
+    id: "draft-reply",
+    label: "Draft a reply",
+    sources: ["email"],
+    request: "Read the whole thread and draft a reply from me, in my voice, that answers what was asked. Create it as a Gmail draft on this thread so I can open it there. Never send it. If you cannot create drafts, give me the text instead and say so."
+  },
+  {
+    id: "summarise-thread",
+    label: "Summarise the thread",
+    sources: ["email"],
+    request: "Read the whole thread and summarise it: who wants what, what has been decided, and what is still open."
+  },
+  {
+    id: "what-they-need",
+    label: "What do they need from me?",
+    sources: ["email", "slack", "messages"],
+    request: "Read this and tell me exactly what is being asked of me, by whom, by when, and what the smallest adequate response would be."
+  },
+  {
+    id: "summarise-ticket",
+    label: "Summarise the ticket",
+    sources: ["jira"],
+    request: "Read this ticket, its comments and anything it links to, and summarise where it stands: what is done, what is left, and what is blocking it."
+  },
+  {
+    id: "status-comment",
+    label: "Draft a status comment",
+    sources: ["jira"],
+    request: "Read this ticket and its linked pull requests, and draft a short status comment from me for the ticket. Give me the text to post. Do not post it."
+  },
+  {
+    id: "next-steps",
+    label: "Break it into next steps",
+    sources: null,
+    request: "Read whatever this item points at and turn it into three to five concrete next steps I could start on today, smallest first."
+  }
+];
+function foldAssistantLog(text) {
+  const turns = /* @__PURE__ */ new Map();
+  for (const line of text.split("\n")) {
+    if (line.trim() === "") continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof record !== "object" || record === null || typeof record.turn !== "string") continue;
+    if (record.event === "started") {
+      if (typeof record.item !== "string" || typeof record.request !== "string") continue;
+      turns.set(record.turn, {
+        id: record.turn,
+        itemId: record.item,
+        agent: record.agent,
+        sessionId: null,
+        request: record.request,
+        action: typeof record.action === "string" ? record.action : null,
+        auto: typeof record.auto === "string" ? record.auto : null,
+        startedAt: record.at,
+        endedAt: null,
+        status: "running",
+        reply: "",
+        steps: [],
+        error: null
+      });
+      continue;
+    }
+    const turn = turns.get(record.turn);
+    if (!turn) continue;
+    turn.sessionId = typeof record.sessionId === "string" ? record.sessionId : turn.sessionId;
+    turn.reply = typeof record.reply === "string" ? record.reply : turn.reply;
+    turn.steps = readSteps(record.steps);
+    turn.endedAt = record.at;
+    if (record.event === "finished") {
+      turn.status = "done";
+    } else if (record.event === "failed") {
+      turn.status = "failed";
+      turn.error = record.error;
+    } else if (record.event === "aborted") {
+      turn.status = "aborted";
+      turn.error = record.reason;
+    }
+  }
+  return turns;
+}
+function addStep(turn, step) {
+  turn.steps.push(step);
+  if (turn.steps.length > STEPS_KEPT) turn.steps.shift();
+}
+function sameWords(a, b) {
+  return a.replace(/\s+/g, " ").trim() === b.replace(/\s+/g, " ").trim();
+}
+function readSteps(value) {
+  if (!Array.isArray(value)) return [];
+  const steps = [];
+  for (const candidate of value) {
+    if (typeof candidate !== "object" || candidate === null || typeof candidate.text !== "string") continue;
+    steps.push({
+      kind: candidate.kind === "message" ? "message" : "tool",
+      text: candidate.text,
+      detail: typeof candidate.detail === "string" ? candidate.detail : null,
+      state: candidate.state === "failed" ? "failed" : "done"
+    });
+  }
+  return steps;
+}
+function parseLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("{")) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+var claudeAdapter = {
+  args({ prompt, sessionId, model, effort, tools, denyEdits }) {
+    const args = [
+      "-p",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--permission-mode",
+      "dontAsk",
+      "--permission-prompts",
+      "none"
+    ];
+    if (denyEdits) args.push("--disallowedTools", "Edit", "Write", "NotebookEdit");
+    if (tools.length > 0) args.push("--allowedTools", ...tools);
+    if (model) args.push("--model", model);
+    if (effort) args.push("--effort", effort);
+    if (sessionId) args.push("--resume", sessionId);
+    args.push("--", prompt);
+    return args;
+  },
+  parse(line) {
+    const event = parseLine(line);
+    if (!event) return null;
+    const type = event.type;
+    if (type === "system" && typeof event.session_id === "string") {
+      return { sessionId: event.session_id };
+    }
+    if (type === "assistant" || type === "user") {
+      const message = event.message;
+      const content = Array.isArray(message?.content) ? message.content : [];
+      const parsed = {};
+      const text = type === "assistant" ? content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n\n") : "";
+      if (text) parsed.text = text;
+      const steps = content.flatMap((block) => claudeStep(block) ?? []);
+      if (steps.length) parsed.steps = steps;
+      return text || steps.length ? parsed : null;
+    }
+    if (type === "result") {
+      const ok = event.is_error !== true && event.subtype === "success";
+      const reply = typeof event.result === "string" ? event.result : void 0;
+      const parsed = { done: ok ? { ok, reply } : { ok, error: reply ?? String(event.subtype ?? "failed") } };
+      if (typeof event.session_id === "string") parsed.sessionId = event.session_id;
+      return parsed;
+    }
+    return null;
+  }
+};
+var codexAdapter = {
+  args({ prompt, sessionId, model, effort, drafts, codexConfig }) {
+    const args = ["exec"];
+    if (sessionId) args.push("resume");
+    args.push("--json", "--skip-git-repo-check");
+    const config = [
+      'sandbox_mode="workspace-write"',
+      "sandbox_workspace_write.network_access=true",
+      ...CONNECTOR_POLICY,
+      ...drafts ? GMAIL_DRAFTS : [],
+      ...codexConfig
+    ];
+    if (model) config.push(`model=${JSON.stringify(model)}`);
+    if (effort) config.push(`model_reasoning_effort=${JSON.stringify(effort)}`);
+    args.push(...configArgs(config));
+    if (sessionId) args.push(sessionId);
+    args.push(prompt);
+    return args;
+  },
+  parse(line) {
+    const event = parseLine(line);
+    if (!event) return null;
+    const type = event.type;
+    if (type === "thread.started" && typeof event.thread_id === "string") {
+      return { sessionId: event.thread_id };
+    }
+    if (type === "item.started" || type === "item.completed") {
+      const item = event.item;
+      if (type === "item.completed" && item?.type === "agent_message" && typeof item.text === "string") return { text: item.text };
+      const step = item ? codexStep(item, type === "item.completed") : null;
+      return step ? { steps: [step] } : null;
+    }
+    if (type === "turn.completed") return { done: { ok: true } };
+    if (type === "turn.failed" || type === "error") {
+      const error = event.error;
+      const message = typeof event.message === "string" ? event.message : error?.message;
+      return { done: { ok: false, error: message ?? String(type) } };
+    }
+    return null;
+  }
+};
+var ADAPTERS = {
+  claude: claudeAdapter,
+  codex: codexAdapter
+};
+var CLAUDE_QUIET_TOOLS = /* @__PURE__ */ new Set(["ToolSearch", "TodoWrite"]);
+function claudeStep(block) {
+  if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+    return { id: block.tool_use_id, state: block.is_error === true ? "failed" : "done" };
+  }
+  if (block.type !== "tool_use" || typeof block.id !== "string" || typeof block.name !== "string") return null;
+  if (CLAUDE_QUIET_TOOLS.has(block.name)) return null;
+  const input = block.input ?? {};
+  const said = (key) => typeof input[key] === "string" && input[key] !== "" ? input[key] : null;
+  const step = (text, detail) => ({ id: block.id, text, detail: shorten(detail), state: "running" });
+  switch (block.name) {
+    case "Bash":
+      return step(said("description") ?? "Run a command", said("command"));
+    case "WebFetch":
+      return step("Fetch a page", said("url"));
+    case "WebSearch":
+      return step("Search the web", said("query"));
+    case "Read":
+      return step("Read a file", said("file_path"));
+    case "Grep":
+      return step("Search files", said("pattern"));
+    case "Glob":
+      return step("List files", said("pattern"));
+    case "Task":
+    case "Agent":
+      return step("Hand part of it to a subagent", said("description"));
+  }
+  const mcp = /^mcp__(.+?)__(.+)$/.exec(block.name);
+  if (mcp) return step(connectorLabel(mcp[1], mcp[2]), compactArgs(input));
+  return step(block.name, compactArgs(input));
+}
+function codexStep(item, completed) {
+  if (typeof item.id !== "string") return null;
+  const failed = item.status === "failed" || item.error !== void 0 && item.error !== null;
+  const state = completed ? failed ? "failed" : "done" : "running";
+  if (item.type === "command_execution") {
+    const exited = typeof item.exit_code === "number" && item.exit_code !== 0;
+    return {
+      id: item.id,
+      text: "Run a command",
+      detail: shorten(unwrapShell(item.command ?? "")),
+      state: completed && exited ? "failed" : state
+    };
+  }
+  if (item.type === "mcp_tool_call" && typeof item.server === "string" && typeof item.tool === "string") {
+    return { id: item.id, text: connectorLabel(item.server, item.tool), detail: compactArgs(item.arguments), state };
+  }
+  if (item.type === "web_search") {
+    const action = item.action ?? {};
+    if (action.type === "open_page") return { id: item.id, text: "Open a page", detail: shorten(action.url ?? null), state };
+    if (action.type === "find_in_page") return { id: item.id, text: "Find in a page", detail: shorten(action.pattern ?? action.url ?? null), state };
+    return { id: item.id, text: "Search the web", detail: shorten(action.query || item.query || null), state };
+  }
+  return null;
+}
+function unwrapShell(command) {
+  const wrapped = /^(?:\S*\/)?(?:ba|z)?sh\s+-l?c\s+(['"])([\s\S]*)\1$/.exec(command.trim());
+  if (!wrapped) return command.trim();
+  return wrapped[1] === "'" ? wrapped[2].replaceAll(`'\\''`, `'`) : wrapped[2];
+}
+function connectorLabel(server, tool) {
+  const words = (name) => name.replace(/[_-]+/g, " ").trim();
+  if (server === "codex_apps") {
+    const said = words(tool);
+    return said.charAt(0).toUpperCase() + said.slice(1);
+  }
+  return `${words(server.replace(/^claude_ai_/, ""))}: ${words(tool)}`;
+}
+function compactArgs(input) {
+  if (input === null || input === void 0) return null;
+  if (typeof input === "object" && Object.keys(input).length === 0) return null;
+  return shorten(typeof input === "string" ? input : JSON.stringify(input));
+}
+function shorten(value) {
+  if (!value) return null;
+  const lines = value.trim().split("\n");
+  const first = lines[0].trim();
+  const more = lines.length > 1;
+  if (first.length > DETAIL_LENGTH) return `${first.slice(0, DETAIL_LENGTH - 1)}\u2026`;
+  return more ? `${first} \u2026` : first;
+}
+function composePrompt(instructions, context, request, profile) {
+  const now = /* @__PURE__ */ new Date();
+  const facts = [`- Profile: ${profile}`, `- Today: ${now.toISOString().slice(0, 10)}`];
+  const parts = [instructions.trim(), "", "## Context", "", ...facts, ""];
+  if (context.item) parts.push("### The item", "", "```json", JSON.stringify(context.item, null, 2), "```", "");
+  if (context.pull) parts.push("### The pull request, as the board last saw it", "", "```json", JSON.stringify(context.pull, null, 2), "```", "");
+  if (context.ticket) parts.push("### The ticket, as the board last saw it", "", "```json", JSON.stringify(context.ticket, null, 2), "```", "");
+  parts.push("## Request", "", request.trim());
+  return parts.join("\n");
+}
+var Assistant = class _Assistant {
+  turns = /* @__PURE__ */ new Map();
+  running = /* @__PURE__ */ new Map();
+  loaded = false;
+  config;
+  hooks;
+  spawnFn;
+  execFn;
+  /** Refuses a Codex too old to hold to the connector rules; see `codex.ts`. */
+  codexGate;
+  /** What switches computer use off, once Codex has said; see `computerUseConfig`. */
+  codexOff = null;
+  constructor(config, hooks, spawnFn = spawn, execFn) {
+    this.config = config;
+    this.hooks = hooks;
+    this.spawnFn = spawnFn;
+    this.execFn = execFn;
+    this.codexGate = new CodexGate(config.assistant.binPath, execFn);
+  }
+  get enabled() {
+    return this.config.assistant.agent !== null;
+  }
+  /** Whether any turn has a process going right now. */
+  get busy() {
+    return this.running.size > 0;
+  }
+  /**
+   * Read the log, and close whatever was left running when the last process
+   * died. Cheap when the assistant is off: the log is read only if it exists.
+   */
+  async start() {
+    if (this.loaded) return;
+    this.loaded = true;
+    let text = "";
+    try {
+      text = await readFile(this.config.assistantLogFile, "utf8");
+    } catch {
+      return;
+    }
+    for (const [id, turn] of foldAssistantLog(text)) this.turns.set(id, turn);
+    for (const turn of this.turns.values()) {
+      if (turn.status !== "running") continue;
+      turn.status = "aborted";
+      turn.error = RESTARTED;
+      turn.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.append({
+        event: "aborted",
+        turn: turn.id,
+        sessionId: turn.sessionId,
+        reason: turn.error,
+        reply: turn.reply,
+        steps: turn.steps,
+        at: turn.endedAt
+      });
+    }
+  }
+  /**
+   * Every turn the dashboard started on its own, however old: what has been
+   * asked ahead is never asked again, and the panel's window of recent turns
+   * is no record of that.
+   */
+  autoTurns() {
+    return [...this.turns.values()].filter((turn) => turn.auto !== null);
+  }
+  /** The assistant's half of the state. Asking ahead is `autoask.ts`'s to add, since it needs the board. */
+  view() {
+    const items = {};
+    for (const turn of this.turns.values()) {
+      const entry = items[turn.itemId] ??= { running: false, sessionId: null, turns: [] };
+      entry.turns.push(turn);
+      if (turn.status === "running") entry.running = true;
+      if (turn.sessionId && turn.agent === this.config.assistant.agent) entry.sessionId = turn.sessionId;
+    }
+    for (const entry of Object.values(items)) {
+      entry.turns.sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+      entry.turns = entry.turns.slice(-TURNS_SHOWN);
+    }
+    return {
+      enabled: this.enabled,
+      agent: this.config.assistant.agent,
+      quickActions: [...QUICK_ACTIONS],
+      items
+    };
+  }
+  /** The request text an ask resolves to, or null when there is nothing to send. */
+  static requestFor(ask) {
+    const action = ask.action ? QUICK_ACTIONS.find((candidate) => candidate.id === ask.action) : void 0;
+    if (ask.action && !action) return null;
+    const typed = (ask.text ?? "").trim();
+    if (!action && typed === "") return null;
+    const request = action ? typed ? `${action.request}
+
+${typed}` : action.request : typed;
+    return { request, action: action?.id ?? null };
+  }
+  /**
+   * Start a turn. Returns once the process is running, not once it has answered;
+   * the answer arrives through `onChange` and the next state. `auto` marks a
+   * turn the dashboard started on its own, with the key of what it answers.
+   */
+  async ask(ask, context, options = {}) {
+    const agent = this.config.assistant.agent;
+    if (!agent) throw new Error("the assistant is off; set DAILY_FOCUS_ASSISTANT to claude or codex");
+    if (this.running.has(ask.itemId)) throw new Error("the assistant is already working on this item");
+    const resolved = _Assistant.requestFor(ask);
+    if (!resolved) throw new Error("nothing to ask: give a quick action or some text");
+    await this.start();
+    const previous = this.view().items[ask.itemId]?.sessionId ?? null;
+    const turn = {
+      id: randomUUID(),
+      itemId: ask.itemId,
+      agent,
+      // Null until the CLI says: a resumed session that fails must not be
+      // recorded as if this CLI had owned it.
+      sessionId: null,
+      request: resolved.request,
+      action: resolved.action,
+      auto: options.auto ?? null,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      endedAt: null,
+      status: "running",
+      reply: "",
+      steps: [],
+      error: null
+    };
+    this.turns.set(turn.id, turn);
+    await this.append({
+      event: "started",
+      turn: turn.id,
+      item: turn.itemId,
+      agent,
+      request: turn.request,
+      action: turn.action,
+      ...turn.auto ? { auto: turn.auto } : {},
+      at: turn.startedAt
+    });
+    const prompt = previous ? resolved.request : composePrompt(await this.instructions(), context, resolved.request, this.config.profile);
+    await mkdir(this.config.assistantDir, { recursive: true });
+    const refusal = agent === "codex" ? await this.codexGate.refusal() : null;
+    if (refusal) {
+      await this.finish(turn, { ok: false, error: refusal });
+      return turn;
+    }
+    let codexConfig;
+    try {
+      codexConfig = await this.computerUseConfig();
+    } catch (err) {
+      const error = err.code === "ENOENT" ? this.spawnError(err) : `computer use is off in the settings, and Codex could not confirm it: ${err.message}. Update Codex, or turn computer use on for the assistant`;
+      await this.finish(turn, { ok: false, error });
+      return turn;
+    }
+    const adapter = ADAPTERS[agent];
+    const args = adapter.args({
+      prompt,
+      sessionId: previous,
+      model: this.config.assistant.model,
+      effort: this.config.assistant.effort,
+      tools: this.config.assistant.tools,
+      denyEdits: true,
+      drafts: true,
+      codexConfig
+    });
+    let child;
+    try {
+      child = this.spawnFn(this.config.assistant.binPath, args, {
+        cwd: this.config.assistantDir,
+        // Stdin closed: both CLIs wait on it otherwise, one of them for three seconds.
+        stdio: ["ignore", "pipe", "pipe"],
+        env: process.env
+      });
+    } catch (err) {
+      await this.finish(turn, { ok: false, error: this.spawnError(err) });
+      return turn;
+    }
+    const timer = setTimeout(() => this.stop(turn.itemId, "gave up after ten minutes"), TURN_TIMEOUT_MS);
+    timer.unref();
+    const run = { turn, child, timer, abortReason: null };
+    this.running.set(turn.itemId, run);
+    this.hooks.onChange();
+    let done;
+    const stderr = [];
+    child.stderr?.on("data", (chunk) => {
+      stderr.push(chunk.toString("utf8"));
+      if (stderr.length > 50) stderr.shift();
+    });
+    const calls = /* @__PURE__ */ new Map();
+    if (child.stdout) {
+      const lines = createInterface({ input: child.stdout });
+      lines.on("line", (line) => {
+        const event = adapter.parse(line);
+        if (!event) return;
+        if (event.sessionId) turn.sessionId = event.sessionId;
+        if (event.text) addStep(turn, { kind: "message", text: event.text, detail: null, state: "done" });
+        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);
+            addStep(turn, step);
+          }
+        }
+        if (event.text || event.steps) this.hooks.onChange();
+        if (event.done) done = event.done;
+      });
+    }
+    child.on("error", (err) => {
+      done = { ok: false, error: this.spawnError(err) };
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      this.running.delete(turn.itemId);
+      const outcome = run.abortReason ? { ok: false, error: run.abortReason } : done ?? {
+        ok: false,
+        error: `${agent} exited with code ${code}${stderr.length ? `: ${stderr.join("").trim().split("\n").slice(-3).join(" ")}` : ""}`
+      };
+      void this.finish(turn, outcome, run.abortReason !== null);
+    });
+    return turn;
+  }
+  /** Kill the turn running on an item, if any. */
+  async stop(itemId, reason = "stopped") {
+    const run = this.running.get(itemId);
+    if (!run) return false;
+    run.abortReason = reason;
+    run.child.kill("SIGTERM");
+    return true;
+  }
+  /** Kill everything, for shutdown. The exit handlers write the aborted lines. */
+  async close() {
+    for (const itemId of [...this.running.keys()]) await this.stop(itemId, SHUT_DOWN);
+  }
+  async finish(turn, outcome, aborted = false) {
+    const at = (/* @__PURE__ */ new Date()).toISOString();
+    const last = turn.steps.findLast((step) => step.kind === "message");
+    const reply = outcome.ok ? outcome.reply ?? last?.text ?? "" : "";
+    if (outcome.ok && last && sameWords(last.text, reply)) turn.steps.splice(turn.steps.lastIndexOf(last), 1);
+    for (const step of turn.steps) if (step.state === "running") step.state = outcome.ok ? "done" : "failed";
+    turn.reply = reply;
+    turn.endedAt = at;
+    const steps = turn.steps;
+    if (outcome.ok) {
+      turn.status = "done";
+      await this.append({ event: "finished", turn: turn.id, sessionId: turn.sessionId, reply, steps, at });
+    } else if (aborted) {
+      turn.status = "aborted";
+      turn.error = outcome.error ?? "stopped";
+      await this.append({ event: "aborted", turn: turn.id, sessionId: turn.sessionId, reason: turn.error, reply, steps, at });
+    } else {
+      turn.status = "failed";
+      turn.error = outcome.error ?? "failed";
+      await this.append({ event: "failed", turn: turn.id, sessionId: turn.sessionId, error: turn.error, reply, steps, at });
+    }
+    this.hooks.onChange();
+  }
+  /**
+   * What switches computer use off, when the assistant runs Codex and the user
+   * hasn't turned it on. Asked of Codex once and kept for the life of the
+   * process; settings that change it restart the dashboard anyway. A failure
+   * isn't kept, so the next turn asks again.
+   */
+  computerUseConfig() {
+    if (this.config.assistant.agent !== "codex" || this.config.assistant.computerUse) return Promise.resolve([]);
+    this.codexOff ??= computerUseOff(this.config.assistant.binPath, this.execFn).catch((err) => {
+      this.codexOff = null;
+      throw err;
+    });
+    return this.codexOff;
+  }
+  spawnError(err) {
+    const code = err.code;
+    const bin = this.config.assistant.binPath;
+    if (code === "ENOENT") return `could not find ${bin}; install it or set DAILY_FOCUS_ASSISTANT_BIN to its path`;
+    return `could not run ${bin}: ${err instanceof Error ? err.message : String(err)}`;
+  }
+  /** The store's copy, or the repo's before `npm run init` has linked it. */
+  async instructions() {
+    for (const path of [this.config.assistantPromptFile, this.config.assistantPromptSource]) {
+      try {
+        return await readFile(path, "utf8");
+      } catch {
+      }
+    }
+    return "You are helping with one item from a personal dashboard. Read only; never send, post or edit anything.";
+  }
+  /**
+   * The log records what happened; the turn in memory is updated by the caller
+   * first. Only this process writes the file, so the memory never has to be
+   * re-read from it.
+   */
+  async append(record) {
+    await mkdir(this.config.dataDir, { recursive: true });
+    await appendFile(this.config.assistantLogFile, `${JSON.stringify(record)}
+`, "utf8");
+  }
+};
+
+// src/autoask.ts
+var AUTO_ACTIONS = ["assess-review", "explain-ci"];
+function autoKeys(row) {
+  if (row.court !== "you" || row.status !== "open") return [];
+  const keys = [];
+  const heard = row.reasons.filter((reason) => reason.kind === "changes-requested" || reason.kind === "activity").map((reason) => reason.at ?? "");
+  if (heard.length > 0) keys.push(`assess-review@${heard.sort().at(-1) || row.updatedAt}`);
+  if (row.reasons.some((reason) => reason.kind === "ci-failing")) {
+    const commit = row.headSha ?? row.lastActivityByYou ?? row.updatedAt;
+    keys.push(`explain-ci@${commit}:${[...row.failingChecks].sort().join(",")}`);
+  }
+  return keys;
+}
+function actionOf(key) {
+  const action = key.slice(0, key.indexOf("@"));
+  return AUTO_ACTIONS.includes(action) ? action : null;
+}
+var SETTLE_MS = 1e3;
+var AutoAsk = class {
+  deps;
+  timer = null;
+  /** A look is under way: one at a time, so two can't both start a turn. */
+  looking = false;
+  /** Something changed while a look was under way, so look again after it. */
+  again = false;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  get enabled() {
+    return this.deps.config.assistant.auto && this.deps.assistant.enabled;
+  }
+  /** Something changed — the board, or a turn — so look again shortly. Coalesced. */
+  poke() {
+    if (!this.enabled || this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.consider().catch((err) => {
+        console.error(`[daily-focus] could not ask ahead: ${err.message}`);
+      });
+    }, SETTLE_MS);
+    this.timer.unref();
+  }
+  /**
+   * Start the next question the board calls for, if one may start now. Returns
+   * its key, or null when nothing was started. Each finished turn pokes, which
+   * is what takes the queue on to the next.
+   */
+  async consider() {
+    if (!this.enabled || !this.deps.canStart()) return null;
+    if (this.looking) {
+      this.again = true;
+      return null;
+    }
+    this.looking = true;
+    try {
+      return await this.look();
+    } finally {
+      this.looking = false;
+      if (this.again) {
+        this.again = false;
+        this.poke();
+      }
+    }
+  }
+  async look() {
+    const { assistant } = this.deps;
+    await assistant.start();
+    const asked = assistant.autoTurns();
+    if (asked.some((turn) => turn.status === "running")) return null;
+    if (this.usedToday(asked) >= this.deps.config.assistant.autoLimit) return null;
+    const items = assistant.view().items;
+    const cutShort = (turn) => turn.status === "aborted" && (turn.error === RESTARTED || turn.error === SHUT_DOWN);
+    const done = new Set(asked.filter((turn) => !cutShort(turn)).map((turn) => `${turn.itemId} ${turn.auto}`));
+    for (const row of await this.deps.rows()) {
+      if (items[row.id]?.running) continue;
+      for (const key of autoKeys(row)) {
+        const action = actionOf(key);
+        if (!action || done.has(`${row.id} ${key}`)) continue;
+        try {
+          await assistant.ask({ itemId: row.id, action }, await this.deps.context(row.id), { auto: key });
+          return key;
+        } catch {
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+  /** Asking ahead as the page shows it, for the board's rows as they are now. */
+  view(rows) {
+    const keyed = {};
+    for (const row of rows) {
+      const keys = autoKeys(row);
+      if (keys.length > 0) keyed[row.id] = keys;
+    }
+    return {
+      enabled: this.enabled,
+      limit: this.deps.config.assistant.autoLimit,
+      usedToday: this.usedToday(this.deps.assistant.autoTurns()),
+      rows: keyed
+    };
+  }
+  close() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+  /** Turns started on its own today, on the server's calendar, however they went. */
+  usedToday(asked) {
+    const today = localDateKey(this.deps.now?.() ?? /* @__PURE__ */ new Date());
+    return asked.filter((turn) => localDateKey(new Date(turn.startedAt)) === today).length;
+  }
+};
+
+// src/prs.ts
+var NUDGE_AFTER_MS = 24 * 36e5;
+var STALE_DRAFT_AFTER_MS = 14 * 864e5;
+var COURT_ORDER = ["you", "ready", "reviewers", "gate", "blocked", "checks", "draft"];
+function courtOrder(court) {
+  return COURT_ORDER.indexOf(court);
+}
+function ms(iso) {
+  const parsed = parseISO(iso);
+  return parsed ? parsed.getTime() : null;
+}
+function deriveDecision(pr) {
+  if (pr.reviewDecision) return pr.reviewDecision;
+  if (pr.reviews.some((review) => review.state === "CHANGES_REQUESTED")) return "CHANGES_REQUESTED";
+  if (pr.reviews.some((review) => review.state === "APPROVED")) return "APPROVED";
+  return null;
+}
+function matchMergeGates(pr, gates) {
+  if (gates.length === 0) return [];
+  return (pr.pendingChecks ?? []).filter((check) => gates.includes(check.name));
+}
+function newest(pr, state) {
+  return pr.reviews.filter((review) => review.state === state).sort((a, b) => a.at < b.at ? 1 : -1)[0];
+}
+function judge(pr, now, nudgedAt, gates = []) {
+  const decision = deriveDecision(pr);
+  const you = pr.lastActivityByYou ?? null;
+  const others = pr.lastActivityByOthers ?? null;
+  const mergeState = pr.mergeStateStatus ?? null;
+  if (pr.isDraft) {
+    const touched = you ?? pr.createdAt;
+    const idle = now.getTime() - (ms(touched) ?? now.getTime());
+    return { court: "draft", decision, reasons: [], stale: idle >= STALE_DRAFT_AFTER_MS, nudge: false, since: touched };
+  }
+  const reasons = [];
+  if (decision === "CHANGES_REQUESTED") {
+    const request = newest(pr, "CHANGES_REQUESTED");
+    reasons.push({ kind: "changes-requested", login: request?.login, at: request?.at });
+  }
+  if (pr.checks === "failure") reasons.push({ kind: "ci-failing" });
+  if (pr.mergeable === "CONFLICTING" || mergeState === "DIRTY") reasons.push({ kind: "conflicts" });
+  if (mergeState === "BEHIND") reasons.push({ kind: "behind" });
+  const theirMove = others !== null && (you === null || others.at > you);
+  const approval = newest(pr, "APPROVED");
+  const afterApproval = others !== null && approval !== void 0 && others.at > approval.at;
+  const approved = decision === "APPROVED" && !afterApproval;
+  if (theirMove && others && !approved) {
+    reasons.push({ kind: "activity", login: others.login, at: others.at, activity: others.kind });
+  }
+  if (reasons.length > 0) {
+    const since = theirMove && others ? others.at : pr.updatedAt;
+    return { court: "you", decision, reasons, stale: false, nudge: false, since };
+  }
+  const waitingSince = laterISO(pr.readyAt, you) ?? pr.createdAt;
+  const settled = (court, reason) => ({
+    court,
+    decision,
+    reasons: [reason],
+    stale: false,
+    nudge: false,
+    since: waitingSince
+  });
+  if (decision !== "REVIEW_REQUIRED") {
+    const gate = matchMergeGates(pr, gates);
+    if (gate.length > 0) return settled("gate", { kind: "merge-gate", checks: gate });
+    const pending = pr.pendingChecks ?? [];
+    const running = { kind: "checks-pending" };
+    if (pending.length > 0) running.checks = pending;
+    if (mergeState === "BLOCKED" && pending.length === 0) {
+      return settled("blocked", { kind: "merge-blocked" });
+    }
+    if (mergeState === "BLOCKED" || mergeState === "UNSTABLE") return settled("checks", running);
+    if (mergeState === "UNKNOWN") return settled("checks", { kind: "mergeability-unknown" });
+    if (approved) {
+      if (mergeState === "CLEAN" || mergeState === "HAS_HOOKS") {
+        return { court: "ready", decision, reasons: [], stale: false, nudge: false, since: approval?.at ?? pr.updatedAt };
+      }
+      if (mergeState === null) {
+        const unfinished = pr.checks === "pending" || pending.length > 0;
+        if (!unfinished) {
+          return { court: "ready", decision, reasons: [], stale: false, nudge: false, since: approval?.at ?? pr.updatedAt };
+        }
+        return settled("checks", running);
+      }
+    }
+  }
+  const quietSince = laterISO(waitingSince, nudgedAt) ?? waitingSince;
+  const waited = now.getTime() - (ms(quietSince) ?? now.getTime());
+  const verdict = { court: "reviewers", decision, reasons, stale: false, nudge: waited >= NUDGE_AFTER_MS, since: waitingSince };
+  const nudged = ms(nudgedAt);
+  if (nudgedAt && nudged !== null && quietSince === nudgedAt && !verdict.nudge) {
+    verdict.nudgedAt = nudgedAt;
+    verdict.nudgedUntil = new Date(nudged + NUDGE_AFTER_MS).toISOString();
+  }
+  return verdict;
+}
+function resolveBoard(pulls, actions, now, gates = []) {
+  const folded = foldActionLog(actions, now);
+  const rows = pulls.map((pr) => {
+    const log = folded.get(canonicalId(pr.id));
+    const verdict = judge(pr, now, log?.nudgedAt ?? null, gates);
+    const row = { ...pr, ...verdict, status: log?.status === "snoozed" ? "snoozed" : "open", notes: log?.notes ?? [] };
+    if (row.status === "snoozed" && log?.snoozedUntil) row.snoozedUntil = log.snoozedUntil;
+    return row;
+  });
+  return rows.sort((a, b) => {
+    const court = courtOrder(a.court) - courtOrder(b.court);
+    if (court !== 0) return court;
+    if (a.since !== b.since) return a.since < b.since ? -1 : 1;
+    return a.id < b.id ? -1 : 1;
+  });
+}
+function countBoard(rows) {
+  const counts = {
+    you: 0,
+    ready: 0,
+    reviewers: 0,
+    gate: 0,
+    blocked: 0,
+    checks: 0,
+    draft: 0,
+    parked: 0
+  };
+  for (const row of rows) {
+    if (row.status === "snoozed") counts.parked++;
+    else counts[row.court]++;
+  }
+  return counts;
+}
+
+export {
+  CodexGate,
+  codexVersionWarning,
+  QUICK_ACTIONS,
+  ADAPTERS,
+  Assistant,
+  autoKeys,
+  actionOf,
+  AutoAsk,
+  judge,
+  resolveBoard,
+  countBoard
+};