rovecode 0.3.2 → 0.4.0-beta.2

package/src/sextant/message-hits.ts

@@ -1,26 +0,0 @@
-/** Click zones on the transcript: a tool row that names a file (`~ edit src/a.ts`, `◆ read …`) opens
- *  that file in the code panel — what `/open <path>` does. The rows come from the same cached build the
- *  painter used (draw-messages.ts cachedBuildRows), at the same scroll offset, so a zone is exactly the
- *  painted row. Rows under a card, or off the visible window, get no zone. */
-import { areas, cachedBuildRows, messagesScroll } from "./draw-messages.ts";
-import { inner } from "./draw-util.ts";
-import type { Rect, SextantState, Theme } from "./types.ts";
-
-export interface MessageHit { rect: Rect; path: string }
-
-export function messageRowHits(rect: Rect, s: SextantState, theme: Theme, now: number): MessageHit[] {
-  const B = inner(rect);
-  if (B.w < 3 || B.h < 1) return [];
-  const { msgH } = areas(B, s);
-  if (msgH <= 0) return [];
-  const rows = cachedBuildRows(s, B.w, theme, now);
-  const { offset } = messagesScroll(rect, s, theme, now);
-  const out: MessageHit[] = [];
-  for (let i = 0; i < msgH; i++) {
-    const r = rows[offset + i];
-    if (!r?.path) continue;
-    const x = B.x + (r.indent ?? 0);
-    out.push({ rect: { x, y: B.y + i, w: Math.max(1, B.w - (r.indent ?? 0) - 1), h: 1 }, path: r.path }); // -1: the scrollbar column
-  }
-  return out;
-}

package/src/sextant/model.ts

@@ -1,387 +0,0 @@
-/** Sextant model (port #41): the surface state and the pure RunEvent reducer. Ported from the
- *  user's sextant v0.4.0 app.js:100-161 (state S, fileStatus/changedFiles/expandTo, setState/
- *  elapsed/stateLabel, toast) and :272-301 (buildTree/treeRows); the mock session/scenario fields
- *  are replaced by state fed from rovecode's RunEvent stream (core/types.ts:135-149). Pure: `now` is a
- *  parameter, no Date.now()/timers/process access; `applyEvent` mutates the state in place. */
-
-import { contextHealth } from "../core/usage.ts";
-import { outstandingClause, outstandingTone } from "../core/loop.ts";
-import { estimateTokens } from "../core/context.ts";
-import { todoCounts, type TodoItem, type TodoCounts } from "../tools/todo.ts";
-import type { TaskInfo } from "../core/tasks.ts";
-import type { ActivityState, ApplyEvent, DiffHunk, FileStatus, MessageRow, Notice, SextantState, ThemeName, Toast, ToolRow, TreeRow } from "./types.ts";
-import { MAX_NOTICES } from "./types.ts";
-import { describeCall, summarizeEnd } from "./tool-rows.ts";
-
-export const TOUCH_MS = 1500;
-export const TOAST_MS = 2600;
-const MAX_TOASTS = 6;
-const NOTE_MAX = 120;
-
-export interface InitOptions {
-  cwd: string;
-  repo: { name: string; branch: string | null; modified?: number };
-  version: string;
-  theme: ThemeName;
-  mode: "plan" | "act";
-  yolo: boolean;
-  commands: { name: string; description: string }[];
-  now: number;
-  /** provider/model shown in the footer and the usage panel */
-  model?: { provider: string; model: string };
-}
-
-export function initialState(o: InitOptions): SextantState {
-  return {
-    cwd: o.cwd,
-    repo: { name: o.repo.name, branch: o.repo.branch, modified: o.repo.modified ?? 0 },
-    files: { paths: [], statuses: new Map(), expanded: new Set(), touched: new Map(), cursor: 0, scroll: 0, version: 0 },
-    activity: { state: "IDLE", label: "idle", runId: null, startedAt: null, endedAt: null },
-    code: { mode: "code", file: null, content: null, hl: null, scroll: 0, search: null, run: null, diff: null, lane: 0, laneOpen: false },
-    messages: [], msgScroll: 0, stick: true, card: null,
-    plan: { todos: [] }, crew: [],
-    usage: { provider: o.model?.provider ?? "", model: o.model?.model ?? "", turns: 0, tokensIn: 0, tokensOut: 0, contextPct: null, costUsd: null },
-    input: { text: "", cur: 0, history: [], histIdx: -1, sgSel: 0 },
-    focus: "messages", page: "code", palette: null, market: null, context: null, wizard: null, help: false, toasts: [], notices: [], staged: [], escUntil: 0,
-    running: false, mode: o.mode, yolo: o.yolo, theme: o.theme, bootAt: o.now, commands: o.commands, version: o.version,
-  };
-}
-
-// ------------------------------------------------------------------ reducer
-
-export interface ApplyHooks {
-  /** HEAD-vs-disk hunks for an edit/write that landed (the caller owns disk + git I/O); null = none */
-  diffFor?: (file: string, tool: string, s: SextantState) => { hunks: DiffHunk[]; add: number; del: number } | null;
-}
-interface CallInfo { tool: string; verb: string; path: string | null; add: number; del: number; cmd: string | null }
-
-/** `now` is passed on ERROR transitions only — it stamps activity.errorAt (the pet's storm trigger) */
-const setActivity = (s: SextantState, state: ActivityState, label: string, now?: number): void => {
-  s.activity.state = state; s.activity.label = label;
-  if (state === "ERROR" && now !== undefined) s.activity.errorAt = now;
-};
-const pushRow = (s: SextantState, row: MessageRow): void => { s.messages.push(row); s.stick = true; };
-function finalizeAssistant(s: SextantState): void { for (const r of s.messages) if (r.kind === "assistant") r.streaming = false; }
-function findRow(s: SextantState, callId: string): ToolRow | undefined {
-  for (let i = s.messages.length - 1; i >= 0; i--) { const r = s.messages[i]!; if (r.kind === "tool" && r.callId === callId) return r; }
-  return undefined;
-}
-const anyRunning = (s: SextantState): boolean => s.messages.some((r) => r.kind === "tool" && r.running);
-function appendNote(detail: string | undefined, note: string): string {
-  const n = note.split(/\r?\n/).find((l) => l.trim())?.trim() ?? "";
-  const joined = detail ? `${detail} · ${n}` : n;
-  const cps = [...joined];
-  return cps.length > NOTE_MAX ? "…" + cps.slice(cps.length - NOTE_MAX + 1).join("") : joined;
-}
-function showFile(s: SextantState, path: string, hl: [number, number] | null): void {
-  if (s.code.file !== path) { s.code.content = null; s.code.scroll = 0; }
-  s.code.mode = "code"; s.code.file = path; s.code.hl = hl;
-}
-
-/** Build the reducer; `hooks` supply what the pure model cannot compute (real diff hunks). */
-export function makeApplyEvent(hooks: ApplyHooks = {}): ApplyEvent {
-  const calls = new Map<string, CallInfo>();
-  let sawText = false;
-  /** cumulative reasoning tokens of the turn in flight (reasoning_update); the answer side is the streaming row's text */
-  let reasoning = 0;
-  const liveTokens = (s: SextantState): void => {
-    if (s.activity.turnAt === undefined) return;
-    const last = s.messages[s.messages.length - 1];
-    s.activity.tokens = reasoning + (last && last.kind === "assistant" && last.streaming ? estimateTokens(last.text) : 0);
-  };
-  /** the provider turn is over (a tool runs, the turn or the run ended): the live line goes with it */
-  const settleTurn = (s: SextantState): void => { delete s.activity.turnAt; delete s.activity.tokens; };
-  return (s, ev, now) => {
-    switch (ev.type) {
-      case "run_start":
-        s.activity = { state: "THINKING", label: "thinking", runId: ev.runId, startedAt: now, endedAt: null };
-        s.running = true; s.stick = true; sawText = false; reasoning = 0; calls.clear();
-        break;
-      case "turn_start":
-        finalizeAssistant(s); setActivity(s, "THINKING", "thinking"); s.usage.turns += 1;
-        s.activity.turnAt = now; s.activity.tokens = 0; reasoning = 0; // the live line's clock starts at the provider call, not the keystroke
-        break;
-      case "message_update": {
-        const last = s.messages[s.messages.length - 1];
-        if (last && last.kind === "assistant" && last.streaming) last.text += ev.delta;
-        else { finalizeAssistant(s); pushRow(s, { kind: "assistant", text: ev.delta, streaming: true, id: ev.messageId }); }
-        sawText = true; setActivity(s, "WRITING", "writing");
-        liveTokens(s);
-        break;
-      }
-      case "reasoning_update":
-        reasoning = ev.tokens; liveTokens(s);
-        break;
-      case "tool_execution_start": {
-        finalizeAssistant(s); settleTurn(s);
-        const d = describeCall(ev.tool, ev.args, s.cwd);
-        calls.set(ev.callId, { tool: ev.tool, verb: d.verb, path: d.path, add: d.add, del: d.del, cmd: d.cmd });
-        const row: ToolRow = { kind: "tool", callId: ev.callId, tool: ev.tool, verb: d.verb, label: d.label, running: true };
-        if (d.path) row.path = d.path;
-        if (d.verb === "edit" || d.verb === "write") { row.add = d.add; row.del = d.del; }
-        pushRow(s, row);
-        setActivity(s, d.state, d.activity);
-        if (d.path && d.touch) { s.files.touched.set(d.path, now + TOUCH_MS); expandTo(s, d.path); s.files.version++; }
-        if (d.path && (d.verb === "read" || d.verb === "edit" || d.verb === "write")) showFile(s, d.path, d.hl);
-        if (d.verb === "run") { s.code.mode = "run"; s.code.run = { cmd: d.cmd ?? d.label, lines: [], status: "running" }; }
-        if (d.verb === "search") { s.code.mode = "search"; s.code.search = { query: d.label, lines: [] }; }
-        break;
-      }
-      case "tool_execution_update": {
-        const row = findRow(s, ev.callId);
-        if (row) row.detail = appendNote(row.detail, ev.note);
-        break;
-      }
-      case "tool_execution_end": {
-        const info = calls.get(ev.callId); calls.delete(ev.callId);
-        let row = findRow(s, ev.callId);
-        if (!row) { row = { kind: "tool", callId: ev.callId, tool: info?.tool ?? "tool", verb: info?.verb ?? "other", label: info?.tool ?? ev.callId, running: true }; pushRow(s, row); }
-        row.running = false; row.ok = ev.ok; row.ms = ev.durationMs;
-        const end = summarizeEnd({ verb: row.verb }, row.tool, ev.ok, ev.output);
-        if (end.detail) row.detail = end.detail;
-        if (end.runLines && s.code.run && (!info?.cmd || s.code.run.cmd === info.cmd)) {
-          s.code.run.lines = end.runLines; s.code.run.status = ev.ok ? "ok" : "fail";
-          if (end.exitCode !== undefined) s.code.run.exitCode = end.exitCode;
-        }
-        if (end.searchLines && s.code.search) s.code.search.lines = end.searchLines;
-        if (ev.ok && info?.path && (row.verb === "edit" || row.verb === "write")) {
-          if (row.verb === "write") addPath(s, info.path);
-          const diff = hooks.diffFor?.(info.path, row.tool, s) ?? null;
-          if (diff) { row.add = diff.add; row.del = diff.del; s.code.diff = { file: info.path, ...diff }; s.code.mode = "diff"; }
-        }
-        if (!ev.ok) setActivity(s, "ERROR", `${row.verb} failed`, now);
-        else if (!anyRunning(s)) setActivity(s, "THINKING", "thinking");
-        break;
-      }
-      case "tool_call_failed": {
-        calls.delete(ev.callId); settleTurn(s);
-        const row = findRow(s, ev.callId);
-        const reason = ev.reason.replace(/_/g, " ");
-        if (row) { row.running = false; row.ok = false; row.detail = reason; }
-        pushRow(s, { kind: "system", tone: "error", text: `${reason}: ${ev.detail}` });
-        const what = ev.reason === "permission_denied" ? "denied" : reason;
-        setActivity(s, "ERROR", row ? `${row.label} ${what}` : what, now);
-        notify(s, row ? `${row.label} ${what}` : `tool ${what}`, now, "error", "error");
-        break;
-      }
-      case "compaction":
-        pushRow(s, { kind: "compaction", text: `compacted (${ev.strategy}${ev.trigger ? `, ${ev.trigger}` : ""}): ${fmtK(ev.tokensBefore)} → ${fmtK(ev.tokensAfter)} tokens` });
-        break;
-      case "steer":
-        pushRow(s, { kind: "steer", text: ev.text });
-        break;
-      case "verify": // the verify gate (core/verify-gate.ts): the check is running / how it ended, one row each
-        pushRow(s, { kind: "system", tone: ev.state === "running" || ev.state === "passed" ? "info" : "warn", text: ev.state === "running" ? `⧗ verify: ${ev.command}` : `verify ${ev.state}: ${ev.detail ?? ""}` });
-        break;
-      case "turn_end":
-        finalizeAssistant(s); settleTurn(s);
-        break;
-      case "run_end": {
-        finalizeAssistant(s); settleTurn(s);
-        if (ev.status === "done") {
-          setActivity(s, "SUCCESS", "done");
-          if (!sawText && ev.summary) pushRow(s, { kind: "assistant", text: ev.summary, streaming: false });
-          // "done" is the model's silence, not a verdict — one clause says what the transcript left (core/loop.ts)
-          const left = ev.outstanding ? outstandingClause(ev.outstanding) : null;
-          const tone = ev.outstanding ? outstandingTone(ev.outstanding) : "info";
-          if (left !== null) pushRow(s, { kind: "system", tone, text: `done · ${left}` });
-          notify(s, left !== null ? `run done · ${left}` : "run done", now, tone, "done");
-        } else if (ev.status === "error") {
-          setActivity(s, "ERROR", "error", now);
-          if (ev.summary) pushRow(s, { kind: "system", tone: "error", text: ev.summary });
-          notify(s, `run failed${ev.summary ? `: ${ev.summary.split("\n")[0]!.slice(0, 80)}` : ""}`, now, "error", "error");
-        } else {
-          setActivity(s, "IDLE", ev.status);
-          pushRow(s, { kind: "system", tone: "warn", text: `run ${ev.status}: ${ev.summary}` });
-          notify(s, `run ${ev.status}`, now, "warn", "done");
-        }
-        s.activity.endedAt = now; s.running = false;
-        for (const r of s.messages) if (r.kind === "tool" && r.running) { r.running = false; r.ok = false; r.detail ??= "interrupted"; }
-        { const pre = s.files.touched.size; for (const [p, until] of s.files.touched) if (until <= now) s.files.touched.delete(p); if (s.files.touched.size !== pre) s.files.version++; }
-        calls.clear();
-        break;
-      }
-    }
-  };
-}
-/** the default reducer instance (no diff hook) */
-export const applyEvent: ApplyEvent = makeApplyEvent();
-
-// ------------------------------------------------------------------ files tree
-
-/** deterministic, locale-independent order: case-insensitive, then raw */
-export const pathCompare = (a: string, b: string): number => {
-  const x = a.toLowerCase(), y = b.toLowerCase();
-  return x < y ? -1 : x > y ? 1 : a < b ? -1 : a > b ? 1 : 0;
-};
-const normPath = (p: string): string => p.replace(/\\/g, "/").replace(/^\.\/+/, "");
-
-/** Replace the file list + git statuses (null statuses = no git); the header count follows. */
-export function setFiles(s: SextantState, paths: readonly string[], statuses: ReadonlyMap<string, FileStatus> | null): void {
-  s.files.paths = [...new Set(paths.map(normPath).filter(Boolean))].sort(pathCompare);
-  s.files.statuses = new Map(statuses ? [...statuses].map(([p, st]) => [normPath(p), st] as const) : []);
-  s.repo.modified = s.files.statuses.size;
-  s.files.version++;
-}
-function addPath(s: SextantState, path: string): void {
-  if (s.files.paths.includes(path)) return;
-  s.files.paths.push(path); s.files.paths.sort(pathCompare); s.files.version++;
-}
-/** open every ancestor directory of `path` */
-export function expandTo(s: SextantState, path: string): void {
-  const parts = path.split("/");
-  let added = false;
-  for (let i = 1; i < parts.length; i++) { const seg = parts.slice(0, i).join("/"); if (!s.files.expanded.has(seg)) { s.files.expanded.add(seg); added = true; } }
-  if (added) s.files.version++;
-}
-export const repoModified = (s: SextantState): number => s.files.statuses.size;
-/** files shown in the tree (tracked ∪ status-only paths, minus deleted) */
-export function fileCount(s: SextantState): number {
-  const all = new Set(s.files.paths);
-  for (const [p, st] of s.files.statuses) if (st === "D") all.delete(p); else all.add(p);
-  return all.size;
-}
-
-interface Node { name: string; path: string; kids: Map<string, Node> | null }
-
-// keyed on the FilesState object too: two states with the same version (tests, a second surface) must not share rows
-let _treeCache: { files: SextantState["files"]; version: number; expSz: number; now: number; rows: TreeRow[] } | null = null;
-/** Flatten the tree (dirs first, expanded set honored); GUIDE glyphs are the drawer's job. */
-export function treeRows(s: SextantState, now = -1): TreeRow[] {
-  const expSz = s.files.expanded.size;
-  if (_treeCache && _treeCache.files === s.files && _treeCache.version === s.files.version && _treeCache.expSz === expSz && _treeCache.now === now) return _treeCache.rows;
-  const all = new Set(s.files.paths);
-  for (const p of s.files.statuses.keys()) all.add(p);
-  const root: Node = { name: "", path: "", kids: new Map() };
-  for (const p of [...all].sort(pathCompare)) {
-    const parts = p.split("/").filter(Boolean);
-    let node = root;
-    parts.forEach((part, i) => {
-      const leaf = i === parts.length - 1;
-      let kid = node.kids!.get(part);
-      if (!kid) { kid = { name: part, path: parts.slice(0, i + 1).join("/"), kids: leaf ? null : new Map() }; node.kids!.set(part, kid); }
-      else if (!leaf && !kid.kids) kid.kids = new Map();
-      node = kid;
-    });
-  }
-  const changed = (n: Node): boolean => (n.kids ? [...n.kids.values()].some(changed) : s.files.statuses.has(n.path));
-  const rows: TreeRow[] = [];
-  const walk = (n: Node, depth: number): void => {
-    const kids = [...n.kids!.values()].sort((x, y) => Number(!!y.kids) - Number(!!x.kids) || pathCompare(x.name, y.name));
-    for (const k of kids) {
-      if (k.kids) {
-        const open = s.files.expanded.has(k.path);
-        const row: TreeRow = { path: k.path, name: k.name, depth, dir: true, expanded: open };
-        if (!open && changed(k)) row.hasChanges = true;
-        rows.push(row);
-        if (open) walk(k, depth + 1);
-      } else {
-        const row: TreeRow = { path: k.path, name: k.name, depth, dir: false };
-        const st = s.files.statuses.get(k.path); if (st) row.status = st;
-        const t = s.files.touched.get(k.path); if (t !== undefined) row.touchedUntil = t;
-        rows.push(row);
-      }
-    }
-  };
-  walk(root, 0);
-  _treeCache = { files: s.files, version: s.files.version, expSz, now, rows };
-  return rows;
-}
-
-export type Guide = "bar" | "tee" | "end" | "blank";
-/** Per-row connector kinds (app.js treeRows `guides`): one entry per depth level ≥ 1. */
-export function treeGuides(rows: readonly TreeRow[]): Guide[][] {
-  const n = rows.length;
-  const last = new Array<boolean>(n).fill(true);
-  const open: boolean[] = [];
-  for (let i = n - 1; i >= 0; i--) {
-    const d = rows[i]!.depth;
-    last[i] = !open[d];
-    open[d] = true; open.length = d + 1;
-  }
-  const out: Guide[][] = [];
-  const ancLast: boolean[] = [];
-  for (let i = 0; i < n; i++) {
-    const d = rows[i]!.depth; ancLast[d] = last[i]!;
-    const g: Guide[] = [];
-    for (let k = 1; k <= d; k++) g.push(k === d ? (last[i] ? "end" : "tee") : ancLast[k] ? "blank" : "bar");
-    out.push(g);
-  }
-  return out;
-}
-
-// ------------------------------------------------------------------ toasts · clock · usage · plan
-
-export function pushToast(s: SextantState, text: string, now: number, tone: Toast["tone"] = "info"): void {
-  s.toasts.push({ text, until: now + TOAST_MS, tone });
-  if (s.toasts.length > MAX_TOASTS) s.toasts.splice(0, s.toasts.length - MAX_TOASTS);
-}
-
-/** A notification: a toast now AND a Notice in the history, so it can be read after the toast fades.
- *  Berkay's four triggers — a run finishing, a failed tool, a card waiting, plus a history — all come
- *  through here; a bare pushToast stays for the renderer-local "unknown theme" class of message that
- *  nobody needs to read back. */
-export function notify(s: SextantState, text: string, now: number, tone: Toast["tone"] = "info", kind: Notice["kind"] = "info"): void {
-  pushToast(s, text, now, tone);
-  const id = (s.notices[s.notices.length - 1]?.id ?? 0) + 1;
-  s.notices.push({ id, at: now, tone, kind, text, read: false });
-  if (s.notices.length > MAX_NOTICES) s.notices.splice(0, s.notices.length - MAX_NOTICES);
-}
-export function unreadNotices(s: SextantState): number { return s.notices.reduce((n, x) => n + (x.read ? 0 : 1), 0); }
-export function markNoticesRead(s: SextantState): void { for (const n of s.notices) n.read = true; }
-export function pruneToasts(s: SextantState, now: number): void {
-  if (s.toasts.some((t) => t.until <= now)) s.toasts = s.toasts.filter((t) => t.until > now);
-}
-/** run timer: frozen at endedAt once the run ends; 0 before any run */
-export function elapsed(s: SextantState, now: number): number {
-  const a = s.activity;
-  return a.startedAt === null ? 0 : Math.max(0, (a.endedAt ?? now) - a.startedAt);
-}
-/** mm:ss.t (engine.js fmtClock) */
-export function fmtClock(ms: number): string {
-  const sec = Math.max(0, ms) / 1000, m = Math.floor(sec / 60), r = sec - m * 60;
-  return `${String(m).padStart(2, "0")}:${r.toFixed(1).padStart(4, "0")}`;
-}
-/** 4200 → "4.2k" (engine.js fmtK) */
-export const fmtK = (n: number): string => (n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(Math.max(0, Math.round(n))));
-/** whole seconds for the live line: "0s" · "59s" · "1m 0s" · "6m 46s" · "1h 0m" — the run clock keeps
- *  fmtClock's mm:ss.t; this one is read in prose next to a word and a count, so it drops the tenths */
-export function fmtElapsed(ms: number): string {
-  const sec = Math.floor(Math.max(0, ms) / 1000);
-  if (sec < 60) return `${sec}s`;
-  const m = Math.floor(sec / 60);
-  if (m < 60) return `${m}m ${sec - m * 60}s`;
-  return `${Math.floor(m / 60)}h ${m % 60}m`;
-}
-
-export interface UsagePatch {
-  provider?: string; model?: string; effort?: string; turns?: number; tokensIn?: number; tokensOut?: number;
-  /** estimated tokens in the context + the model's window (undefined window → pct unknown) */
-  contextTokens?: number; contextWindow?: number | undefined;
-  costUsd?: number | null;
-}
-/** 0..100 estimated fill via core/usage.ts contextHealth; null when the window is unknown */
-export function contextPercent(used: number, window: number | undefined): number | null {
-  if (window === undefined) return null;
-  return Math.min(100, Math.round(contextHealth(used, window).fraction * 100));
-}
-export function setUsage(s: SextantState, u: UsagePatch): void {
-  if (u.provider !== undefined) s.usage.provider = u.provider;
-  if (u.model !== undefined) s.usage.model = u.model;
-  if (u.effort !== undefined) s.usage.effort = u.effort;
-  if (u.turns !== undefined) s.usage.turns = u.turns;
-  if (u.tokensIn !== undefined) s.usage.tokensIn = u.tokensIn;
-  if (u.tokensOut !== undefined) s.usage.tokensOut = u.tokensOut;
-  if ("contextTokens" in u || "contextWindow" in u) {
-    s.usage.contextPct = contextPercent(u.contextTokens ?? 0, u.contextWindow);
-    if (u.contextTokens !== undefined) s.usage.contextTokens = u.contextTokens;
-    if (u.contextWindow !== undefined) s.usage.contextWindow = u.contextWindow; else delete s.usage.contextWindow;
-  }
-  if (u.costUsd !== undefined) s.usage.costUsd = u.costUsd;
-}
-/** loadTodos() result → plan panel (a corrupt file arrives as empty + note, never throws) */
-export function setPlan(s: SextantState, loaded: { items: TodoItem[]; note?: string }): void {
-  s.plan = loaded.note ? { todos: loaded.items, note: loaded.note } : { todos: loaded.items };
-}
-export const planCounts = (s: SextantState): TodoCounts => todoCounts(s.plan.todos);
-export function setCrew(s: SextantState, tasks: readonly TaskInfo[]): void { s.crew = [...tasks]; }