daily-focus 1.2.0-dev.8 → 2.0.0-dev.14

package/dist/{chunk-SX5FPS3A.js → chunk-JTMBBUMD.js}

@@ -1,3 +1,13 @@
+import {
+  canonicalId,
+  foldActionLog
+} from "./chunk-ITUK7XKS.js";
+import {
+  laterISO,
+  localDateKey,
+  parseISO
+} from "./chunk-72NUDSOV.js";
+
 // src/codex.ts
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -99,6 +109,18 @@ async function codexVersionWarning(bin, run = defaultExec) {
   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.`;
 }
+async function codexLatestModel(bin, run = defaultExec) {
+  try {
+    const catalog = JSON.parse(await run(bin, ["debug", "models"], { timeout: LIST_TIMEOUT_MS }));
+    const listed = (Array.isArray(catalog.models) ? catalog.models : []).filter(
+      (model) => typeof model === "object" && model !== null && typeof model.slug === "string" && typeof model.priority === "number" && model.visibility === "list"
+    );
+    listed.sort((a, b) => a.priority - b.priority);
+    return listed[0]?.slug ?? null;
+  } catch {
+    return null;
+  }
+}
 
 // src/assistant.ts
 import { spawn } from "node:child_process";
@@ -106,7 +128,11 @@ 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",
@@ -189,10 +215,12 @@ function foldAssistantLog(text) {
         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;
@@ -201,6 +229,7 @@ function foldAssistantLog(text) {
     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";
@@ -214,6 +243,27 @@ function foldAssistantLog(text) {
   }
   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;
@@ -225,7 +275,7 @@ function parseLine(line) {
   }
 }
 var claudeAdapter = {
-  args({ prompt, sessionId, model, effort, tools, denyEdits }) {
+  args({ prompt, sessionId, model, effort, tools, denyEdits, schema }) {
     const args = [
       "-p",
       "--output-format",
@@ -240,6 +290,7 @@ var claudeAdapter = {
     if (tools.length > 0) args.push("--allowedTools", ...tools);
     if (model) args.push("--model", model);
     if (effort) args.push("--effort", effort);
+    if (schema) args.push("--json-schema", schema.json);
     if (sessionId) args.push("--resume", sessionId);
     args.push("--", prompt);
     return args;
@@ -248,14 +299,24 @@ var claudeAdapter = {
     const event = parseLine(line);
     if (!event) return null;
     const type = event.type;
+    if (type === "system" && event.subtype === "task_notification" && typeof event.tool_use_id === "string") {
+      const step = { id: event.tool_use_id, state: event.status === "completed" ? "done" : "failed", final: true };
+      return { steps: [step] };
+    }
     if (type === "system" && typeof event.session_id === "string") {
       return { sessionId: event.session_id };
     }
-    if (type === "assistant") {
+    if (type === "assistant" || type === "user") {
       const message = event.message;
       const content = Array.isArray(message?.content) ? message.content : [];
-      const text = content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n\n");
-      return text ? { text } : null;
+      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;
+      if (!text && !steps.length) return null;
+      if (typeof event.parent_tool_use_id === "string") parsed.by = event.parent_tool_use_id;
+      return parsed;
     }
     if (type === "result") {
       const ok = event.is_error !== true && event.subtype === "success";
@@ -268,10 +329,11 @@ var claudeAdapter = {
   }
 };
 var codexAdapter = {
-  args({ prompt, sessionId, model, effort, drafts, codexConfig }) {
+  args({ prompt, sessionId, model, effort, drafts, codexConfig, schema }) {
     const args = ["exec"];
     if (sessionId) args.push("resume");
     args.push("--json", "--skip-git-repo-check");
+    if (schema) args.push("--output-schema", schema.file);
     const config = [
       'sandbox_mode="workspace-write"',
       "sandbox_workspace_write.network_access=true",
@@ -293,10 +355,11 @@ var codexAdapter = {
     if (type === "thread.started" && typeof event.thread_id === "string") {
       return { sessionId: event.thread_id };
     }
-    if (type === "item.completed") {
+    if (type === "item.started" || type === "item.completed") {
       const item = event.item;
-      if (item?.type === "agent_message" && typeof item.text === "string") return { text: item.text };
-      return null;
+      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") {
@@ -311,6 +374,90 @@ var ADAPTERS = {
   claude: claudeAdapter,
   codex: codexAdapter
 };
+var CLAUDE_QUIET_TOOLS = /* @__PURE__ */ new Set(["ToolSearch", "TodoWrite", "StructuredOutput"]);
+var HANDOFF = "Hand part of it to a subagent";
+var WAIT = "Wait for its subagents";
+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(HANDOFF, said("description")), handoff: true };
+  }
+  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 === "collab_tool_call" && item.tool === "wait") return { id: item.id, text: WAIT, detail: null, 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)}`];
@@ -364,7 +511,7 @@ var Assistant = class _Assistant {
     for (const turn of this.turns.values()) {
       if (turn.status !== "running") continue;
       turn.status = "aborted";
-      turn.error = "the dashboard restarted while this was running";
+      turn.error = RESTARTED;
       turn.endedAt = (/* @__PURE__ */ new Date()).toISOString();
       await this.append({
         event: "aborted",
@@ -372,10 +519,20 @@ var Assistant = class _Assistant {
         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()) {
@@ -408,9 +565,10 @@ ${typed}` : action.request : typed;
   }
   /**
    * Start a turn. Returns once the process is running, not once it has answered;
-   * the answer arrives through `onChange` and the next state.
+   * 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) {
+  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");
@@ -427,10 +585,12 @@ ${typed}` : action.request : typed;
       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);
@@ -441,6 +601,7 @@ ${typed}` : action.request : typed;
       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);
@@ -492,18 +653,27 @@ ${typed}` : action.request : typed;
       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) {
-          turn.reply = turn.reply ? `${turn.reply}
-
-${event.text}` : event.text;
-          this.hooks.onChange();
+        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;
       });
     }
@@ -531,24 +701,28 @@ ${event.text}` : event.text;
   }
   /** Kill everything, for shutdown. The exit handlers write the aborted lines. */
   async close() {
-    for (const itemId of [...this.running.keys()]) await this.stop(itemId, "the dashboard shut down");
+    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 reply = outcome.reply ?? turn.reply;
+    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, at });
+      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, at });
+      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, at });
+      await this.append({ event: "failed", turn: turn.id, sessionId: turn.sessionId, error: turn.error, reply, steps, at });
     }
     this.hooks.onChange();
   }
@@ -594,10 +768,268 @@ ${event.text}` : event.text;
   }
 };
 
+// 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 {
+  computerUseOff,
+  refusalFor,
   CodexGate,
   codexVersionWarning,
+  codexLatestModel,
   QUICK_ACTIONS,
   ADAPTERS,
-  Assistant
+  HANDOFF,
+  WAIT,
+  unwrapShell,
+  connectorLabel,
+  compactArgs,
+  shorten,
+  Assistant,
+  autoKeys,
+  actionOf,
+  AutoAsk,
+  judge,
+  resolveBoard,
+  countBoard
 };

package/dist/chunk-QG4XXKBP.js

@@ -0,0 +1,18 @@
+// src/fs.ts
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+async function writeJsonAtomic(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  const temp = tempPathFor(path);
+  await writeFile(temp, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  await rename(temp, path);
+}
+function tempPathFor(path) {
+  return `${path}.tmp`;
+}
+
+export {
+  writeJsonAtomic,
+  tempPathFor
+};