rovecode 0.4.0-beta.2 → 0.4.0

package/src/sextant/draw-plan.ts

@@ -0,0 +1,159 @@
+/** Sextant plan + usage painters (port #41). Ported from the user's sextant v0.4.0 app.js:675-744
+ *  (drawPlan steps/crew/next, drawUsage tokens/context bar/cost); the scenario phases are gone — the
+ *  steps ARE the session's todos (tools/todo.ts loadTodos), the crew rows are TaskManager TaskInfo,
+ *  usage comes from the run's real token/cost accounting. Pure: `now` only drives the crew spinner. */
+
+import { ATTR } from "./types.ts";
+import type { Rect, ScreenLike, Seg, SextantState, Theme } from "./types.ts";
+import type { TaskInfo } from "../core/tasks.ts";
+import { EMPTY } from "../core/voice.ts";
+import type { TodoItem } from "../tools/todo.ts";
+import { fmtK, planCounts } from "./model.ts";
+import { crewSummary, laneGlyph, laneStatus, laneTone } from "./draw-agents.ts";
+import { panel } from "./layout.ts";
+import { st } from "./theme.ts";
+import { driftRow } from "./draw-context.ts";
+
+const CREW_MAX = 5;
+export const STEP_GLYPH: Record<TodoItem["status"], string> = { completed: "◆", in_progress: "◈", pending: "◇" };
+
+const oneLine = (text: string): string => text.replace(/\s+/g, " ").trim();
+/** greedy word wrap (app.js wrap) — long words are split at the width */
+export function wrapText(text: string, width: number): string[] {
+  const out: string[] = [];
+  if (width <= 0) return out;
+  for (const para of oneLine(text).split("\n")) {
+    let line = "";
+    for (const w of para.split(" ")) {
+      if (!line) { line = w; continue; }
+      if ([...line].length + 1 + [...w].length <= width) line += " " + w; else { out.push(line); line = w; }
+    }
+    while ([...line].length > width) { const cps = [...line]; out.push(cps.slice(0, width).join("")); line = cps.slice(width).join(""); }
+    out.push(line);
+  }
+  return out;
+}
+
+/** `next` = the in_progress item, then the first pending one */
+export function nextSteps(todos: readonly TodoItem[]): TodoItem[] {
+  const out: TodoItem[] = [];
+  const cur = todos.find((t) => t.status === "in_progress"); if (cur) out.push(cur);
+  const pend = todos.find((t) => t.status === "pending"); if (pend) out.push(pend);
+  return out;
+}
+/** non-terminal tasks = "working" (queued + running) — crewSummary(crew).working agrees */
+export const crewWorking = (crew: readonly TaskInfo[]): number => crewSummary(crew).working;
+/** the crew board's glyph + tone (#46 draw-agents): ◇ queued · spinner running · ◆ done · × failed · ▪ cancelled */
+export function crewGlyph(t: TaskInfo, theme: Theme, now: number): [string, number] {
+  return [laneGlyph(t.status, now), laneTone(t.status, theme)];
+}
+/** the crew board's status word (#46 laneStatus): `working mm:ss` while running, else the status */
+export const crewStatus = (t: TaskInfo, now = 0): string => laneStatus(t, now);
+
+/** Plan panel: `plan  done/total` title, todo steps (◆ done · ◈ in_progress · ◇ pending, priority hint
+ *  at the right), then — anchored to the bottom — `crew  k working` (when any) and `next`. */
+export function drawPlan(scr: ScreenLike, R: Rect, s: SextantState, theme: Theme, now = 0): void {
+  const todos = s.plan.todos, c = planCounts(s);
+  const B = panel(scr, R, "plan", false, todos.length ? [[`${c.completed}/${c.total}`, st(theme.muted)]] : [], theme);
+  const yEnd = B.y + B.h;
+  let y = B.y;
+  if (s.plan.note) for (const line of wrapText(s.plan.note, B.w).slice(0, 2)) if (y < yEnd) scr.put(B.x, y++, line, st(theme.warn), B.w);
+  const next = nextSteps(todos), crew = s.crew.slice(-CREW_MAX);
+  let nextRows = next.length ? next.length + 1 : 0, crewRows = crew.length ? crew.length + 1 : 0;
+  let nextY = yEnd - nextRows;
+  let crewY = (nextRows ? nextY - 1 : yEnd) - crewRows;
+  const minY = y + 2; // keep the steps header + one row above the anchored blocks
+  if (crewRows && crewY < minY) { crewRows = 0; crewY = yEnd; }
+  if (nextRows && nextY < minY) { nextRows = 0; nextY = yEnd; }
+  const stepsEnd = crewRows ? crewY - 1 : nextRows ? nextY - 1 : yEnd;
+  scr.text(B.x, y++, [["steps", st(theme.muted)], [todos.length ? `  ${c.completed}/${c.total}` : "", st(theme.dim)]], B.w);
+  if (!todos.length && y < stepsEnd) { // empty plan: the hint's second line only when there is room
+    scr.put(B.x, y++, EMPTY.plan[0], st(theme.dim), B.w);
+    if (y < stepsEnd) scr.put(B.x, y++, EMPTY.plan[1], st(theme.dim), B.w);
+  }
+  // a long plan windows around the step in progress instead of always showing its head: the person
+  // wants to see what is being done now, not steps 1-8 of 30. One row above says how many are earlier.
+  const room = Math.max(0, stepsEnd - y), curIdx = todos.findIndex((t) => t.status === "in_progress");
+  let start = 0;
+  if (todos.length > room && curIdx >= room - 1) { // the current step would be hidden (or be the marker row)
+    const visible = Math.max(1, room - 2); // minus the "earlier" row and the "+N more" row
+    start = Math.max(0, Math.min(curIdx - Math.floor(visible / 2), todos.length - visible));
+  }
+  if (start > 0 && y < stepsEnd) scr.put(B.x, y++, `  …${start} earlier`, st(theme.dim), B.w);
+  let shown = start;
+  for (const t of todos.slice(start)) {
+    if (y >= stepsEnd) break;
+    const cur = t.status === "in_progress", done = t.status === "completed";
+    const pr = t.priority === "high" ? "high" : t.priority === "low" ? "low" : "";
+    scr.put(B.x, y, STEP_GLYPH[t.status], st(done ? theme.okDim : cur ? theme.accent : theme.dim));
+    scr.clip(B.x + 3, y, oneLine(t.content), st(done ? theme.fg2 : cur ? theme.fg : theme.muted, -1, cur ? ATTR.BOLD : 0), B.w - 3 - (pr ? pr.length + 1 : 0));
+    if (pr) scr.put(B.x + B.w - pr.length, y, pr, st(t.priority === "high" ? theme.warn : theme.dim));
+    y++; shown++;
+  }
+  if (shown < todos.length && shown > 0) { y--; scr.fill(B.x, y, B.w, 1, " "); scr.put(B.x, y, `  +${todos.length - shown + 1} more`, st(theme.dim), B.w); }
+  if (crewRows) {
+    let cy = crewY;
+    scr.text(B.x, cy++, [["crew", st(theme.muted)], [`  ${crewSummary(s.crew).text}`, st(theme.dim)]], B.w);
+    for (const t of crew) {
+      const [g, gc] = crewGlyph(t, theme, now), status = crewStatus(t, now);
+      scr.text(B.x, cy, [[g + " ", st(gc)], [t.label, st(t.status === "done" ? theme.fg2 : t.status === "failed" ? theme.err : theme.fg)]], B.w - status.length - 1);
+      scr.put(B.x + B.w - status.length, cy, status, st(t.status === "failed" ? theme.err : theme.dim));
+      cy++;
+    }
+  }
+  if (nextRows) {
+    let ny = nextY;
+    scr.put(B.x, ny++, "next", st(theme.muted));
+    for (const t of next) {
+      const cur = t.status === "in_progress";
+      scr.text(B.x, ny++, [[STEP_GLYPH[t.status] + " ", st(cur ? theme.accent : theme.dim)], [oneLine(t.content), st(cur ? theme.fg : theme.muted)]], B.w);
+    }
+  }
+}
+
+/** filled cells of a `width`-wide context bar at `pct` (0..100) */
+export const barFilled = (pct: number, width: number): number => Math.round((Math.max(0, Math.min(100, pct)) / 100) * width);
+/** the first candidate that fits `width` cells, else the last one clipped with an ellipsis */
+export function fitText(candidates: readonly string[], width: number): string {
+  for (const c of candidates) if ([...c].length <= width) return c;
+  const last = candidates[candidates.length - 1];
+  if (last === undefined || width <= 0) return "";
+  return width === 1 ? "…" : [...last].slice(0, width - 1).join("") + "…";
+}
+
+/** Usage panel (3 inner rows): `tokens 4.2k` (+ in/out split when it fits), `context ━━──── 12%`
+ *  (or `context ?` when the window is unknown), `cost $0.030` (or `cost —` when unpriced) +
+ *  provider/model (model alone, then clipped, when narrow). */
+export function drawUsage(scr: ScreenLike, R: Rect, s: SextantState, theme: Theme): void {
+  const B = panel(scr, R, "usage", false, [], theme);
+  const u = s.usage;
+  const label = (t: string): Seg => [t.padEnd(10), st(theme.muted)];
+  const total = fmtK(u.tokensIn + u.tokensOut);
+  const split = fitText([`  ${fmtK(u.tokensIn)} in · ${fmtK(u.tokensOut)} out`, `  ${fmtK(u.tokensIn)}/${fmtK(u.tokensOut)}`, ""], B.w - 10 - total.length);
+  if (u.tokensIn + u.tokensOut === 0) scr.text(B.x, B.y, [label("tokens"), [EMPTY.usage, st(theme.dim)]], B.w); // nothing spent yet
+  else scr.text(B.x, B.y, [label("tokens"), [total, st(theme.fg)], [split, st(theme.dim)]], B.w);
+  scr.text(B.x, B.y + 1, [label("context")]);
+  if (u.contextPct === null) scr.put(B.x + 10, B.y + 1, "?", st(theme.dim));
+  else {
+    const barW = Math.max(6, B.w - 10 - 7), filled = barFilled(u.contextPct, barW);
+    for (let i = 0; i < barW; i++) scr.put(B.x + 10 + i, B.y + 1, i < filled ? "━" : "─", st(i < filled ? theme.accent : theme.rule2));
+    scr.put(B.x + 10 + barW + 2, B.y + 1, `${Math.round(u.contextPct)}%`.padStart(4), st(u.contextPct > 80 ? theme.warn : theme.fg));
+  }
+  const cost = u.costUsd === null ? "—" : `$${u.costUsd.toFixed(3)}`;
+  const model = u.model ? fitText([u.provider ? `  ${u.provider}/${u.model}` : `  ${u.model}`, `  ${u.model}`], B.w - 10 - cost.length) : "";
+  scr.text(B.x, B.y + 2, [label("cost"), [cost, st(theme.fg)], [model, st(theme.dim)]], B.w);
+
+  // How far the bar above is from what the provider actually counted. It matters here rather than only
+  // inside /context because compaction fires on OUR estimate: a model whose real prompt is a fifth bigger
+  // than the bar says gets compacted late, and the bar is the thing the human is looking at when they
+  // decide whether one more turn fits.
+  //
+  // Drawn only once /context has been opened, and silent otherwise. The number comes from comparing our
+  // count with a turn that reported usage, which the cockpit does not do on its own — and inventing a
+  // placeholder ("drift —") would take a row to say nothing. `driftRow` returns undefined when there is
+  // nothing honest to say, so this is one condition rather than a special case.
+  const d = s.context ? driftRow(s.context.drift, s.context.tolerance) : undefined;
+  if (d && B.h > 3) {
+    scr.text(B.x, B.y + 3, [label("drift"), [fitText([d.text, ""], B.w - 10), st(d.warn ? theme.warn : theme.dim)]], B.w);
+  }
+}

package/src/sextant/draw-tabs.ts

@@ -0,0 +1,85 @@
+/** The tab strip: paging between panels the terminal is too narrow to show at once.
+ *
+ *  layout.ts hides the files panel under 140 columns and the plan/usage column under 110, and until
+ *  now a hidden panel was simply gone — ⌃e answered "the files panel needs ≥ 140 columns" and that was
+ *  that. Berkay asked for the panels to behave like tabs instead: on a narrow terminal the MAIN slot
+ *  (the code panel's rect) shows whichever panel `s.page` names, and a strip on that slot's top border
+ *  says which panels exist and which one is showing. Clicking a tab pages to it; ⌃e pages to files,
+ *  ⌃o cycles.
+ *
+ *  Deliberately absent on a wide terminal: when every panel is on screen there is nothing to page,
+ *  and a strip would be one more thing to read. tabsFor() returns [] and nothing is drawn.
+ *
+ *  Geometry and painting live together here so the hit zones the frame loop registers are the cells
+ *  that were actually painted — the same rule card-hits.ts and panel-hits.ts follow. The strip
+ *  overpaints the panel title on the top border (panel() draws the title at x+2); the active tab IS
+ *  the title. */
+
+import { st } from "./draw-util.ts";
+import { strWidth } from "./screen.ts";
+import { ATTR, PAGES, type Layout, type Page, type Rect, type ScreenLike, type SextantState, type Theme } from "./types.ts";
+
+export interface Tab {
+  page: Page;
+  /** the cells the label occupies on the border row */
+  rect: Rect;
+  active: boolean;
+}
+
+const LABEL: Record<Page, string> = { code: "code", files: "files", plan: "plan" };
+const SEP = " · ";
+
+/** is this page's own panel hidden by the layout, so it needs a tab to be reachable? */
+export function hiddenByLayout(L: Layout, page: Page): boolean {
+  return page === "files" ? L.files === null : page === "plan" ? L.plan === null : false;
+}
+
+/** the page actually showing in the main slot: `s.page` if that panel is hidden by the layout (so
+ *  paging is what makes it visible), else code — a page pointing at a panel that is already on
+ *  screen is inert, never a duplicate */
+export function mainPage(L: Layout, s: SextantState): Page {
+  return hiddenByLayout(L, s.page) ? s.page : "code";
+}
+
+/** The tabs to show, positioned on the main slot's top border; [] on a wide terminal. */
+export function tabsFor(L: Layout, s: SextantState): Tab[] {
+  const hidden = PAGES.filter((p) => hiddenByLayout(L, p));
+  if (hidden.length === 0) return [];
+  const pages: Page[] = ["code", ...hidden];
+  const active = mainPage(L, s);
+  const y = L.code.y;
+  const right = L.code.x + L.code.w - 2; // the border's last usable cell before the corner
+  let x = L.code.x + 2;
+  const out: Tab[] = [];
+  for (const [i, page] of pages.entries()) {
+    const w = strWidth(LABEL[page]) + 2; // ` label `
+    if (x + w > right) break;           // a strip the border cannot hold stops, never wraps
+    out.push({ page, rect: { x, y, w, h: 1 }, active: page === active });
+    x += w + (i < pages.length - 1 ? strWidth(SEP) : 0);
+  }
+  return out;
+}
+
+/** Paint the strip over the main slot's top border. Pure; returns what it painted. */
+export function drawTabs(scr: ScreenLike, L: Layout, s: SextantState, theme: Theme): Tab[] {
+  const tabs = tabsFor(L, s);
+  if (tabs.length === 0) return tabs;
+  const focused = s.focus === "code" || s.focus === "files";
+  for (const [i, t] of tabs.entries()) {
+    const style = t.active
+      ? st(theme.bg, focused ? theme.accent : theme.fg2, ATTR.BOLD)
+      : st(theme.muted);
+    scr.text(t.rect.x, t.rect.y, [[` ${LABEL[t.page]} `, style]], t.rect.w);
+    const next = tabs[i + 1];
+    if (next) scr.text(t.rect.x + t.rect.w, t.rect.y, [[SEP, st(theme.frame)]], next.rect.x - (t.rect.x + t.rect.w));
+  }
+  return tabs;
+}
+
+/** the page after `page` among the tabs on screen (⌃o); `page` itself when there is nothing to cycle */
+export function nextPage(L: Layout, s: SextantState): Page {
+  const tabs = tabsFor(L, s);
+  if (tabs.length < 2) return s.page;
+  const i = tabs.findIndex((t) => t.active);
+  return tabs[(i + 1) % tabs.length]!.page;
+}

package/src/sextant/draw-util.ts

@@ -0,0 +1,65 @@
+/** Sextant surface (port #42) — small pure drawing helpers shared by the code and messages panels.
+ *  Ported from the user's own sextant v0.4.0 prototype: src/app.js:37 (st), :66-78 (wrap), :210-220
+ *  (panel). Pure: no clock, no timers, no process access — `now` arrives as a parameter.
+ *  #44 dedupe: `st` and `panel` are the shared theme.ts / layout.ts ones, re-exported here so the
+ *  panels' imports stay put (layout.ts panel() = this file's former one: interior cleared to the
+ *  theme background, extras clipped with an ellipsis before they are dropped). */
+
+import { SPIN, type Rect } from "./types.ts";
+
+export { st } from "./theme.ts";
+export { panel } from "./layout.ts";
+
+/** the four-glyph diamond spinner, phase from the frame clock (140 ms per step) */
+export const spinner = (now: number): string => SPIN[Math.floor(now / 140) % SPIN.length] ?? "◇";
+
+/** split file content into lines; a trailing newline does not produce a phantom empty line */
+export function splitLines(s: string): string[] {
+  const l = s.split("\n");
+  if (l.length && l[l.length - 1] === "") l.pop();
+  return l;
+}
+
+/** 1-slot cache: splitLines is called twice per frame (drawFileView + codeScrollTop/rowCount).
+ *  File content is a stable string reference within a frame; reference equality is the cheapest guard. */
+let _splitCache: { src: string; lines: string[] } | null = null;
+export function splitLinesCached(s: string): string[] {
+  if (_splitCache && _splitCache.src === s) return _splitCache.lines;
+  const lines = splitLines(s);
+  _splitCache = { src: s, lines };
+  return lines;
+}
+
+/** Word-wrap to `width` cells — one cell per code point (types.ts), so an emoji counts once and a
+ *  surrogate pair never straddles two rows — keeping explicit newlines (a blank paragraph stays a
+ *  blank row); a word longer than the width is hard-split wherever it starts. Never returns []. */
+export function wrap(text: string, width: number): string[] {
+  const w = Math.max(1, width);
+  const out: string[] = [];
+  for (const para of String(text).split("\n")) {
+    let line = "", len = 0;
+    for (const word of para.split(" ")) {
+      const cps = [...word];
+      if (line && len + 1 + cps.length <= w) { line += " " + word; len += 1 + cps.length; continue; }
+      if (line) out.push(line);
+      while (cps.length > w) out.push(cps.splice(0, w).join(""));
+      line = cps.join(""); len = cps.length;
+    }
+    out.push(line);
+  }
+  return out;
+}
+
+/** hard-split a line into `width`-cell chunks (terminal-style, no word boundaries; one cell per
+ *  code point — an astral glyph moves to the next row whole); "" → [""] */
+export function hardWrap(line: string, width: number): string[] {
+  const w = Math.max(1, width);
+  const cps = [...line];
+  if (cps.length <= w) return [line];
+  const out: string[] = [];
+  for (let i = 0; i < cps.length; i += w) out.push(cps.slice(i, i + w).join(""));
+  return out;
+}
+
+/** inner rect of a panel drawn at `r` (2 cells of horizontal padding, 1 row for each border) */
+export const inner = (r: Rect): Rect => ({ x: r.x + 2, y: r.y + 1, w: r.w - 4, h: r.h - 2 });

package/src/sextant/engine.ts

@@ -0,0 +1,230 @@
+/** ported from the user's sextant v0.4.0 prototype, src/engine.js (+ wrap() from app.js lines 66-78) */
+/* Pure helpers for the panels: syntax tokenizer, diff hunks/line marks over jsdiff output, fuzzy
+   match, word wrap, small formatters. The prototype's O(n·m) LCS diffLines() is NOT ported —
+   jsdiff (Myers, already a dependency) produces the ops, which then feed the same hunk/mark code. */
+
+import { diffLines, type ChangeObject, type StructuredPatch } from "diff";
+import type { DiffHunk } from "./types.ts";
+
+export type Lang = "ts" | "json" | "md" | "text";
+export const LANG_NAME: Readonly<Record<Lang, string>> = { ts: "TypeScript", json: "JSON", md: "Markdown", text: "Plain Text" };
+
+/** split on \n, dropping the empty tail a trailing newline leaves */
+export const splitLines = (s: string): string[] => { const l = s.split("\n"); if (l.length && l[l.length - 1] === "") l.pop(); return l; };
+export const basename = (p: string): string => p.slice(p.lastIndexOf("/") + 1);
+export const dirname = (p: string): string => (p.includes("/") ? p.slice(0, p.lastIndexOf("/")) : "");
+
+/** language by extension; the TS tokenizer serves the whole JS/TS family (the prototype knew .ts/.tsx only) */
+export function langOf(p: string): Lang {
+  if (/\.[cm]?[jt]sx?$/.test(p)) return "ts";
+  if (/\.jsonc?$/.test(p)) return "json";
+  if (/\.(md|markdown)$/.test(p)) return "md";
+  return "text";
+}
+
+/* ------------------------------------------------------------ tokenizer */
+
+export type TokenClass = "kw" | "str" | "num" | "cm" | "fn" | "ty" | "pu" | "op" | "prop" | "id" | "key" | "dec" | "plain";
+export type Token = [string, TokenClass];
+
+const KW = new Set("import export from const let var function return if else async await new type interface extends implements class throw try catch finally for while of in as default void typeof instanceof null undefined true false this readonly declare satisfies keyof enum switch case break continue do yield static private public protected".split(" "));
+const TS_RE = /(\/\/.*)|("(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'|`(?:[^`\\]|\\.)*`)|(\b\d[\d_]*(?:\.\d+)?\b)|(@?[A-Za-z_$][\w$]*)|([{}()[\]])|([;,.:])|(=>|\?\?|\?\.|[<>=!+\-*/%&|^~?]+)/g;
+
+/** one source line → [text, class] runs; "text" is one plain run, "md" goes through tokenizeMd */
+export function tokenize(line: string, lang: string): Token[] {
+  if (lang === "md") return tokenizeMd(line);
+  if (lang === "text") return [[line, "plain"]];
+  const out: Token[] = [];
+  let last = 0;
+  let m: RegExpExecArray | null;
+  TS_RE.lastIndex = 0;
+  while ((m = TS_RE.exec(line))) {
+    if (m.index > last) out.push([line.slice(last, m.index), "plain"]);
+    const tok = m[0];
+    let cls: TokenClass;
+    if (m[1]) cls = "cm";
+    else if (m[2]) cls = lang === "json" && /^\s*:/.test(line.slice(m.index + tok.length)) ? "key" : "str";
+    else if (m[3]) cls = "num";
+    else if (m[4]) {
+      const before = line[m.index - 1];
+      const after = line.slice(m.index + tok.length);
+      if (tok[0] === "@") cls = "dec";
+      else if (KW.has(tok)) cls = "kw";
+      else if (before === ".") cls = "prop";
+      else if (/^\s*\(/.test(after) || (/^</.test(after) && /^[a-z]/.test(tok))) cls = "fn";
+      else if (/^[A-Z]/.test(tok)) cls = "ty";
+      else if (/^\??:/.test(after)) cls = "prop";
+      else cls = "id";
+    } else if (m[5] || m[6]) cls = "pu";
+    else cls = "op";
+    out.push([tok, cls]);
+    last = m.index + tok.length;
+  }
+  if (last < line.length) out.push([line.slice(last), "plain"]);
+  return out;
+}
+
+export function tokenizeMd(line: string): Token[] {
+  if (/^#{1,6}\s/.test(line)) return [[line, "kw"]];
+  if (/^\s{4}/.test(line)) return [[line, "str"]];
+  const out: Token[] = [];
+  let last = 0;
+  let m: RegExpExecArray | null;
+  const re = /`[^`]+`/g;
+  while ((m = re.exec(line))) {
+    if (m.index > last) out.push([line.slice(last, m.index), "plain"]);
+    out.push([m[0], "str"]);
+    last = m.index + m[0].length;
+  }
+  if (last < line.length) out.push([line.slice(last), "plain"]);
+  return out;
+}
+
+/* ------------------------------------------------------------ diff */
+
+export type OpKind = "eq" | "del" | "ins";
+/** one diff line; an/bn are the 1-based old/new line numbers (absent on the side the line is not on) */
+export interface DiffOp { t: OpKind; text: string; an?: number; bn?: number }
+/** a run of ops with its @@ header numbers: old start/count, new start/count */
+export interface Hunk { ops: DiffOp[]; as: number; bs: number; ac: number; bc: number }
+export type LineMark = "added" | "changed";
+
+/** jsdiff diffLines() change objects → the prototype's op list with line numbers */
+export function opsFromChanges(changes: readonly ChangeObject<string>[]): DiffOp[] {
+  const ops: DiffOp[] = [];
+  let an = 0, bn = 0;
+  for (const c of changes) {
+    const lines = c.value.split("\n");
+    if (lines.length > c.count) lines.pop(); // the value ends with its last line's newline
+    for (const text of lines) {
+      if (c.added) ops.push({ t: "ins", text, bn: ++bn });
+      else if (c.removed) ops.push({ t: "del", text, an: ++an });
+      else ops.push({ t: "eq", text, an: ++an, bn: ++bn });
+    }
+  }
+  return ops;
+}
+
+/** line-diff two texts (jsdiff Myers) → ops; replaces the prototype's O(n·m) LCS table */
+export function diffOps(a: string, b: string): DiffOp[] {
+  return opsFromChanges(diffLines(a, b));
+}
+
+/** added/deleted line counts */
+export const opStats = (ops: readonly DiffOp[]): { a: number; d: number } => {
+  let a = 0, d = 0;
+  for (const o of ops) { if (o.t === "ins") a++; else if (o.t === "del") d++; }
+  return { a, d };
+};
+
+function hunkOf(ops: readonly DiffOp[], s: number, e: number): Hunk {
+  const slice = ops.slice(s, e);
+  let as: number | null = null, bs: number | null = null, ac = 0, bc = 0;
+  for (const o of slice) {
+    if (o.an) { if (as == null) as = o.an; ac++; }
+    if (o.bn) { if (bs == null) bs = o.bn; bc++; }
+  }
+  return { ops: slice, as: as ?? 0, bs: bs ?? 0, ac, bc };
+}
+
+/** group changes into hunks with `ctx` context lines; changes closer than 2·ctx share a hunk; Infinity = one hunk */
+export function buildHunks(ops: readonly DiffOp[], ctx: number): Hunk[] {
+  if (!isFinite(ctx)) return ops.length ? [hunkOf(ops, 0, ops.length)] : [];
+  const hunks: Hunk[] = [];
+  let i = 0;
+  while (i < ops.length) {
+    if (ops[i]!.t === "eq") { i++; continue; }
+    const start = Math.max(0, i - ctx);
+    let end = i + 1, j = i + 1;
+    while (j < ops.length) {
+      if (ops[j]!.t !== "eq") { end = j + 1; j++; continue; }
+      let k = j;
+      while (k < ops.length && ops[k]!.t === "eq") k++;
+      if (k < ops.length && k - j <= ctx * 2) { j = k; continue; }
+      break;
+    }
+    end = Math.min(ops.length, end + ctx);
+    hunks.push(hunkOf(ops, start, end));
+    i = end;
+  }
+  return hunks;
+}
+
+/** new-line-number → "added" (pure insertion) | "changed" (insertion next to a deletion) */
+export function lineMarks(ops: readonly DiffOp[]): Map<number, LineMark> {
+  const marks = new Map<number, LineMark>();
+  let i = 0;
+  while (i < ops.length) {
+    if (ops[i]!.t === "eq") { i++; continue; }
+    let j = i, hasDel = false;
+    while (j < ops.length && ops[j]!.t !== "eq") { if (ops[j]!.t === "del") hasDel = true; j++; }
+    for (let k = i; k < j; k++) { const o = ops[k]!; if (o.t === "ins" && o.bn) marks.set(o.bn, hasDel ? "changed" : "added"); }
+    i = j;
+  }
+  return marks;
+}
+
+/** a prototype hunk → the contract's DiffHunk rows */
+export function toDiffHunk(h: Hunk): DiffHunk {
+  return { rows: h.ops.map((o) => ({ op: o.t === "ins" ? "+" : o.t === "del" ? "-" : " ", text: o.text })), oldStart: h.as, newStart: h.bs };
+}
+
+/** jsdiff structuredPatch() hunks → the contract's DiffHunk rows ("" stays a context row) */
+export function hunksFromPatch(patch: StructuredPatch): DiffHunk[] {
+  return patch.hunks.map((h) => ({
+    oldStart: h.oldStart,
+    newStart: h.newStart,
+    rows: h.lines.map((l) => {
+      const c = l[0];
+      const op = c === "+" ? "+" : c === "-" ? "-" : " ";
+      return { op, text: c === "+" || c === "-" || c === " " ? l.slice(1) : l };
+    }),
+  }));
+}
+
+/* ------------------------------------------------------------ fuzzy */
+
+export interface FuzzyMatch { score: number; idx: number[] }
+
+/** subsequence match, case-insensitive: +3 for a run, +1 otherwise, +2 at a word/path start; null when q is not in s */
+export function fuzzy(q: string, s: string): FuzzyMatch | null {
+  q = q.toLowerCase(); s = s.toLowerCase();
+  let qi = 0, score = 0, last = -2;
+  const idx: number[] = [];
+  for (let i = 0; i < s.length && qi < q.length; i++) {
+    if (s[i] === q[qi]) {
+      idx.push(i);
+      score += (last === i - 1 ? 3 : 1) + (i === 0 || s[i - 1] === " " || s[i - 1] === "/" ? 2 : 0);
+      last = i; qi++;
+    }
+  }
+  return qi === q.length ? { score, idx } : null;
+}
+
+/* ------------------------------------------------------------ text */
+
+/** greedy word wrap per paragraph (\n); a word longer than width is hard-split (app.js wrap) */
+export function wrap(text: string, width: number): string[] {
+  width = Math.max(1, width); // width ≤ 0 never advanced the hard-split loop below (prototype quirk)
+  const out: string[] = [];
+  for (const para of String(text).split("\n")) {
+    let line = "";
+    for (const w of para.split(" ")) {
+      if (!line) { line = w; continue; }
+      if (line.length + 1 + w.length <= width) line += " " + w; else { out.push(line); line = w; }
+    }
+    while (line.length > width) { out.push(line.slice(0, width)); line = line.slice(width); }
+    out.push(line);
+  }
+  return out;
+}
+
+/** mm:ss.t run clock */
+export const fmtClock = (ms: number): string => {
+  const s = Math.max(0, ms) / 1000;
+  const m = Math.floor(s / 60);
+  const r = s - m * 60;
+  return `${String(m).padStart(2, "0")}:${r.toFixed(1).padStart(4, "0")}`;
+};
+export const fmtDur = (ms: number): string => (ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`);
+export const fmtK = (n: number): string => (n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n));

package/src/sextant/frame-hits.ts

@@ -0,0 +1,25 @@
+/** Click zones on the outer frame's two border rows (draw-frame.ts headerRight / footerRight): the
+ *  unread badge `◆ N` opens the notices (⌃b), the theme name in the footer tag cycles the theme (⌃t),
+ *  and `effort X` prefills `/effort ` so the levels appear as suggestions. The words are located by
+ *  the same segment math the painter uses, so a zone is exactly the word it reads. */
+import { footerRight, headerRight } from "./draw-frame.ts";
+import { segWidth } from "./layout.ts";
+import type { HitZone, Rect, SextantState, Theme } from "./types.ts";
+
+export function frameHits(F: Rect, s: SextantState, theme: Theme, now: number): HitZone[] {
+  const out: HitZone[] = [];
+  const head = headerRight(s, theme, now);
+  const hx = F.x + F.w - 2 - segWidth(head.segs);
+  if (head.badge) out.push({ rect: { x: hx + head.badge[0], y: F.y, w: head.badge[1], h: 1 }, onClick: () => {}, key: { type: "key", name: "b", ctrl: true } });
+  const foot = footerRight(s, theme);
+  const fx = F.x + F.w - 2 - segWidth(foot.segs), fy = F.y + F.h - 1;
+  if (foot.effort) {
+    out.push({
+      rect: { x: fx + foot.effort[0], y: fy, w: foot.effort[1], h: 1 },
+      // the prompt gets `/effort ` with the cursor at the end; the suggestion strip then lists the levels
+      onClick: () => { s.input.text = "/effort "; s.input.cur = s.input.text.length; s.input.sgSel = 0; s.focus = "messages"; },
+    });
+  }
+  out.push({ rect: { x: fx + foot.theme[0], y: fy, w: foot.theme[1], h: 1 }, onClick: () => {}, key: { type: "key", name: "t", ctrl: true } });
+  return out;
+}