kaizen-agent 1.43.1 → 1.43.2

package/cli/pty.test.ts

@@ -186,6 +186,16 @@ test.skipIf(process.platform === "win32")("the done sweep keeps a session the us
   await Bun.sleep(200);
   expect(alive(used)).toBe(true);
   process.kill(used, "SIGTERM");
+
+  // Only looked at: the page's focus and query answers reach the tty but are not typing.
+  done(Date.now() - 60_000);
+  const looked = launch("looked");
+  await Bun.sleep(200);
+  writePty("looked", "\x1b[I\x1b[O\x1b[?0u\x1b[<64;10;5M\x1bP>|xterm.js(6.0)\x1b\\");
+  await Bun.sleep(200);
+  expect(ptyState("looked")!.typed).toBe(0);
+  sweepSessions(st, Date.now() + CLOSE_GRACE_MS);
+  expect(await gone(looked)).toBe(true);
 });
 
 test("asking: Claude Code and Codex prompts count as a question, ordinary output does not", async () => {

package/cli/pty.ts

@@ -11,7 +11,7 @@ const WIN = process.platform === "win32";
 // Windows PowerShell, which every Windows has, both hosts the console and runs the agent in it.
 const winPs = () => join(process.env.SystemRoot ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
 
-type Pty = { proc: Bun.Subprocess; out: string[]; size: number; listeners: Set<(d: string | null) => void>; exit: number | null; asking: boolean; quiet?: Timer; total: number; since: number; onChange?: () => void };
+type Pty = { proc: Bun.Subprocess; out: string[]; size: number; listeners: Set<(d: string | null) => void>; exit: number | null; asking: boolean; quiet?: Timer; total: number; since: number; typed: number; onChange?: () => void };
 
 // What a page attaching late gets replayed. A full-screen tool redraws often, so the
 // tail of its output is enough to rebuild the screen.
@@ -38,7 +38,7 @@ export const ptySupported = WIN || typeof (Bun as any).Terminal === "function";
 // onChange: called when the agent ends or starts or stops asking, so the board can redraw.
 export function startPty(key: string, cmd: string[], cwd: string, pidFile?: string, onChange?: () => void): number {
   const dec = new TextDecoder();
-  const p: Pty = { proc: null as unknown as Bun.Subprocess, out: [], size: 0, listeners: new Set(), exit: null, asking: false, total: 0, since: 0, onChange };
+  const p: Pty = { proc: null as unknown as Bun.Subprocess, out: [], size: 0, listeners: new Set(), exit: null, asking: false, total: 0, since: 0, typed: 0, onChange };
   const flag = (v: boolean) => { if (p.asking !== v) { p.asking = v; onChange?.(); } };
   const push = (d: string) => {
     p.out.push(d);
@@ -99,11 +99,19 @@ export function attachPty(key: string, fn: (d: string | null) => void): (() => v
   return () => p.listeners.delete(fn);
 }
 
+// What the page's terminal sends by itself: focus in/out (Claude Code turns focus
+// reporting on), mouse and wheel reports, and answers to the agent's queries (cursor,
+// device, mode, colour, version). None of it is the user typing.
+const REPORT = /\x1b\[[IO]|\x1b\[<[\d;]*[Mm]|\x1b\[\?[\d;]*(?:[cnu]|\$y)|\x1b\[>[\d;]*c|\x1b\[\d+;\d+R|\x1b\[\d*n|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1bP[^\x1b]*\x1b\\/g;
+
 export function writePty(key: string, d: string) {
   const p = ptys.get(key);
   if (!p || p.exit !== null) return;
-  p.since = p.total;
-  if (p.asking) { p.asking = false; p.onChange?.(); }
+  if (d.replace(REPORT, "")) {
+    p.typed = Date.now();
+    p.since = p.total;
+    if (p.asking) { p.asking = false; p.onChange?.(); }
+  }
   send(p, d);
 }
 
@@ -122,7 +130,7 @@ export const ptyKeys = () => [...ptys.keys()];
 
 export const ptyState = (key: string) => {
   const p = ptys.get(key);
-  return p ? { alive: p.exit === null, exit: p.exit, asking: p.asking } : null;
+  return p ? { alive: p.exit === null, exit: p.exit, asking: p.asking, typed: p.typed } : null;
 };
 
 // The environment the user's login shell builds: PATH and anything exported in their

package/cli/state.ts

@@ -5,7 +5,7 @@ import { existsSync, readFileSync, readdirSync, appendFileSync, writeFileSync, m
 import { Database } from "bun:sqlite";
 import { join, dirname, win32, posix } from "node:path";
 import { homedir, arch, cpus, release, totalmem, version as osVersion } from "node:os";
-import { startPty, ptySupported } from "./pty.ts";
+import { startPty, ptySupported, ptyState } from "./pty.ts";
 import { codeDir, projectFromWorktree } from "./worktree.ts";
 
 // The real path: process.cwd() is always physical, so a raw $HOME that crosses a
@@ -1343,7 +1343,7 @@ function opencodeRows(sql: string, ...args: (string | number)[]): string[] {
   } catch { return []; }
 }
 
-export const CLOSE_GRACE_MS = 2 * 60_000;
+export const CLOSE_GRACE_MS = 60_000;
 const sessionsDir = (st: string) => join(st, "sessions");
 
 export function readSessions(st: string): Session[] {
@@ -1509,7 +1509,11 @@ export function sweepSessions(st: string, now: number) {
 // Whether the user typed into the session's terminal after `t`: its tty's access time
 // moves when input is read. Such a session is the user's now, not the run's to close.
 // No tty (Windows, a stranger's PID): false, so the sweep closes as before.
+// A board card's session is judged by its keystrokes: the page's terminal answers the
+// agent's focus and query reports on that tty too, which moved its time on every look.
 function typedSince(st: string, s: Session, t: number): boolean {
+  const card = ptyState(s.key);
+  if (card) return card.typed > t;
   try {
     if (process.platform === "win32") return false;
     const pid = parseInt(readText(join(sessionsDir(st), s.key + ".pid")));

package/cli/web.ts

@@ -209,6 +209,8 @@ export async function web(repoDir: string, opts: Opts = {}) {
       const key = c.kind === "run" ? runs.get(`${c.state}\0${c.id}`) : ideaPty.get(`${c.state}\0${c.text}`);
       if (!key || !live.has(key)) return undefined;
       const st = ptyState(key)!;
+      // A finished run's agent that has ended has nothing left to show or resume.
+      if (!st.alive && (c.status === "done" || c.status === "abandoned")) return undefined;
       return { key, alive: st.alive, asking: st.asking };
     };
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaizen-agent",
-  "version": "1.43.1",
+  "version": "1.43.2",
   "description": "Staged workflow for AI agents — code, writing, research, operations: plan, human approval, build, independent review, bounded fix loop.",
   "type": "module",
   "bin": {

package/skills/kaizen/config.default.yml

@@ -114,7 +114,7 @@ agent:
   # auto picks Claude Code if installed, otherwise the first agent found on PATH.
   default: auto
   # on: a board decision ends the run's waiting session before continuing its
-  # conversation, and abandoned or done runs (after 2 minutes) have theirs ended.
+  # conversation, and abandoned or done runs (after 1 minute) have theirs ended.
   # Only sessions the board or dashboard launched are touched. off: nothing is
   # ended, and a resumed conversation opens beside the window still waiting.
   close: on

package/skills/kaizen/docs.md

@@ -108,7 +108,9 @@ updated: YYYY-MM-DD
 2. Split it into 5–12 areas a newcomer would name — by what the parts do, not by
    folder alone. Fewer for a small project.
 3. Write one note per area in the shape above, then `Index.md`, then `Log.md` with the
-   first line.
+   first line. Every source file lands in some note's `sources` — the area's helpers,
+   small screens and scripts too, not only its main files — named directly or through a
+   folder that holds it (see *Coverage* below).
 4. Write the pointer (below).
 5. Lint, and report.
 
@@ -124,8 +126,9 @@ updated: YYYY-MM-DD
    rewrite the sections they affect — never `## Notes` — and set `updated`.
 3. Every `sources` path is gone: move the note to `Project/Archive/` and drop it from
    the Index. Never delete a note.
-4. A part of the repository no note covers (a new top-level folder, a new entry point):
-   write a note for it.
+4. A source file no note covers (see *Coverage*): add it to the `sources` of the note
+   whose area it belongs to, and mention it there; where it fits no area (a new top-level
+   folder, a new entry point), write a note for it.
 5. Refresh the Index lines whose description changed, append one Log line naming every
    note touched, refresh the pointer, lint, and report.
 
@@ -138,10 +141,20 @@ Checks, reported and not silently fixed:
 - every note has `description`, `tags`, `sources` and `updated` (the Index and Log need
   no `sources`), and is listed in the Index;
 - every `sources` path exists;
+- **uncovered**: source files no note's `sources` names or holds, listed one per line;
 - **stale**: notes whose `sources` changed after their `updated` day, found as in
   *Update* step 1;
 - `Index.md` is under 60 lines.
 
+## Coverage
+
+A **source file** is one the repository tracks (`git ls-files`; outside git, every file
+not ignored), leaving out lockfiles, generated or built output, vendored code, binaries,
+and bulk data folders. A note covers a file when its `sources` names the file or a folder
+that holds it, so a data folder such as `public/quran` is covered by naming the folder.
+Lint's *uncovered* list is what makes this checkable: a file no note covers is also a file
+whose changes *stale* never sees, so the vault falls behind without saying so.
+
 ## The pointer
 
 What makes an agent open the Index first. One block, identical everywhere:

package/skills/kaizen/spec-main.md

@@ -191,3 +191,31 @@ When a child run reaches `done`, the board appends `Child <child id> done: <titl
 the parent's `notes.md` by itself. The parent documents it from there: if it is still in
 flight its next stage reads `notes.md`; if it is already `done`, the entry is the record.
 Never reopen a finished parent.
+
+**A roadmap's increments are filed at its approval.** When the approved plan has a
+`## Roadmap` (see *A whole application is a roadmap* in `spec-plan.md`), the same write
+that records the approval files increments 2 to N, in order, from the project folder:
+`kaizen card add "<title> (roadmap #N · after #a, #b)" --parent <run id>`, with
+`any time` in place of `after …` where it has no prerequisite and its `blocked: <reason>`
+kept in the text where it has one. Increment 1 is this run's own build. Nothing starts
+by itself: the user starts an increment from its card when they choose, and the parent's
+card lists its children with their status. An increment cut at the approval is not
+filed; it goes to the backlog like anything else cut there.
+
+## Discovery rounds
+
+A roadmap plan's Discovery and any run's REA offer reach the user through the main
+thread, under every runner: each round's questions are asked with the tool's structured
+question mechanism (AskUserQuestion in Claude Code), all of a round's questions in one
+call, each with the planner's recommended option first. Under `runner: full`, the
+planner stops after writing a round; dispatch it again with the answers, recorded in
+`02-approval.md` as that round's decisions, until it writes a plan with no round left
+to ask, then present that plan at the plan approval as usual. Answers are not an
+approval: the run stays at `stage: "plan"` with `awaiting: null` throughout, and
+`awaiting: "approvals.plan"` is set only once `01-plan.md` has a `## Roadmap` — a round
+written to that file is not a plan to approve, and a tool resuming the run re-asks its
+questions. Where the user says yes to REA before the plan exists, run the study here,
+write what it found to the run's `notes.md`, and dispatch the planner with it. Where
+REA has to be installed first, the install in *Offer REA* (`spec-plan.md`) is the main
+thread's too: doctor, the dry-run shown to the user, setup only on their approval,
+then the restart, after which the run resumes at `stage: "plan"` from `state.json`.

package/skills/kaizen/spec-plan.md

@@ -27,6 +27,39 @@ different work behind each, nothing available to break the tie — and even then
 its recommendation with the question. Questions the existing material can answer are
 never asked; that is the planner's own work.
 
+**Offer REA for what exists but is not here.** In every run and every track: when the
+request or what came with it names something that already exists but whose source is
+not at hand — an app or site to copy, replace or integrate with, an APK or IPA, a
+binary, a package, a file format, a device or its firmware, a protocol or a capture —
+and REA's tools are connected in the session, the plan asks once:
+`Q: Study <the thing> with REA first?`, with `yes` (recommended where how it works
+inside decides the design) and `no`. Under `runner: lite` or an inline planner, a yes
+given before the plan is written lets the planner run REA itself and plan from what it
+found. Under `full`, where the planner has no REA tools, the main thread runs the study
+on a yes, writes what it found to the run's `notes.md`, and dispatches the planner
+again; a yes given at the plan approval instead makes the study the build's first
+step. What REA
+returns is cited with its limitations, as *the track* in `spec.md` already requires.
+REA not connected: ask instead
+`Q: REA isn't installed — set it up first?`, with `help me install it` (recommended
+where how it works inside decides the design), `I'll install it myself` and `skip
+REA`. On *help me install it* the main thread follows REA's own setup: it runs
+`npx -y rea-agents@<version> doctor --client <client> --json` — the version pinned,
+as REA's own guide pins it, taken from `npm view rea-agents version` and shown to the
+user; the client from the run's `agent` (`claude` → `claude_code`, `codex` → `codex`,
+`agy` → `antigravity`, `opencode` → `opencode`, `gemini` → `gemini_cli`, `cursor` →
+`cursor`) — then `setup --client <client> --dry-run --json` with the same version, shows the user the exact files it
+would change, and runs `setup --client <client> --yes` only after they approve it —
+setup writes the agent's own configuration, so it is never run unseen, in any mode.
+On *I'll install it myself* it gives that same command and waits. Either way the new
+tools appear only after the agent restarts: say so, and the run resumes from its
+`state.json`, the yes to REA recorded beforehand in `02-approval.md` so the resumed
+session studies the thing rather than asking again. REA's prerequisites (Node, and
+Java, Ghidra or JADX for some targets) are named where doctor reports them missing,
+never installed by the run. On *skip REA*, or when setup fails, the plan says so
+once and claims about that thing's internals are marked unverified. Nothing of the
+kind named: REA is not mentioned.
+
 **Building from nothing is the exception: settle the foundation first.** When the
 track is a new product or app, there is no material to answer the questions that
 decide everything after them, and "wrong" for this track is a wrong foundation — the
@@ -39,6 +72,67 @@ materially different builds — put to the user as an *Open question* with optio
 all in one round, before anything is built. Three quick questions and a default for
 the rest is how a run ends up writing the second app instead of the first.
 
+**A whole application is a roadmap, not a run.** When the track is a new product or
+app — web, mobile, PWA, desktop, anything — and it covers more than one independent
+module, one run cannot hold it: the plan, the diff and the review all outgrow what a
+reader can check. A single screen or a single feature stays one run. The Framing says
+in one line that the plan is a roadmap, so the user can refuse it. A roadmap plan adds
+three sections right after the Goal, each written for a person, and the
+foundation round above becomes up to three rounds:
+
+- **`## Discovery`** — the planner goes deep before it designs. It reads everything the
+  user brought first (decks, forms, sheets, screenshots, an existing repo, REA's
+  findings), then asks only what is still open, in up to three rounds of `Q:` pick
+  lists, each question with a recommended option: (1) purpose, who uses it and in what
+  roles, what it replaces; (2) the flows of each module and their domain rules;
+  (3) the foundation choices, among them how it ships, as a multi-select — full CI/CD
+  (tests and deploy on every merge), Docker (an image and a compose file that run
+  anywhere), a managed platform (Vercel, Fly, Railway or similar), mobile app ready
+  (store builds with signing, for example Capacitor or Expo/EAS), or a simple manual
+  deploy — and, where the app has a screen and no design system exists, its look and
+  feel, asked as item 7 *Design direction* below says: the feel (for example rich and
+  animated, calm and simple, enterprise and dense, gen-z and playful) and how much
+  motion. A round with nothing left to ask is skipped. Under `runner: full` the
+  planner writes `01-plan.md` with the Framing, `## Discovery` so far and the round's
+  questions as *Open questions*, and no `## Roadmap`, then stops; that file is a
+  round, not a plan. The main thread asks them and dispatches it again with the
+  answers. Under
+  `lite` or inline, the session asks them directly. The section records the roles, the
+  main flows, the things the app keeps track of and how they relate, a glossary of
+  the domain's words, and every answer given.
+- **`## Foundation`** — a decision with its reason, derived from Discovery, for each
+  of: platform; frontend (framework, UI kit, state, the design direction chosen);
+  backend (runtime, framework, API style); the contract between them (REST, RPC or
+  realtime, and where its types live); hosting and deploy, as chosen in discovery;
+  database (engine, where it runs, the main tables or collections and their
+  relations, how migrations are done); auth and access; repo layout and conventions.
+  Every increment builds on it.
+- **`## Roadmap`** — the increments, numbered, one line each:
+  `N. <title> — <what it delivers> — after: #a, #b` (or `any time`), with
+  `— blocked: <reason>` when something outside the work holds it. Increment 1 is always
+  the skeleton: the scaffold, the stack wired, the database schema and migration setup,
+  an auth stub, and a deploy of the empty app the way the Foundation ships (in its
+  Docker image, through its pipeline, as a store test build). Every feature increment
+  after it is one feature end to end — its screens, its API, its tables and migration,
+  and its tests — so each can be tried on its own; splitting by layer ("all the APIs", then "all the screens")
+  is only for an app with no UI or no backend. Each increment is sized to one ordinary
+  run. Where real people will use the app, the last increment is going live: what
+  the deploy choice still needs (the full pipeline, the production image, store
+  listings and release builds), backups, monitoring and error tracking, and the
+  production deploy. A last line says which must go in order and which can start any
+  time.
+
+The rest of a roadmap plan — Work list, Steps, File manifest, gate — covers increment 1
+only; it is this run's build. The others become child cards at the approval (see
+*Child cards* in `spec-main.md`).
+
+**An increment run builds inside its parent's decisions.** A request with a `Parent:`
+line whose parent run's `01-plan.md` has a `## Roadmap` is an increment. Its planner
+reads that plan's Discovery, Foundation and its own Roadmap line before anything else.
+They bind it: a deviation from the Foundation is an *Open question* to the user, and a
+change to the roadmap is an *Out of scope suggestion*, never a silent edit of the
+parent's plan.
+
 The goals stay the user's. The planner may propose a better solution to what was
 asked, or argue that the request as stated will not achieve what the user wants, but
 it may not widen the goal on its own. Anything beyond the request goes in *Out of
@@ -132,7 +226,7 @@ questions that are open. An alternative rejected gets a line saying what and why
 a case against it.
 
 **Write the parts a person reads for a person.** Framing, the Work list, Goal, Scope,
-Risks and Out of scope suggestions are read by someone deciding whether to approve,
+Discovery, Foundation, Roadmap, Risks and Out of scope suggestions are read by someone deciding whether to approve,
 often on a narrow panel. Write them in everyday words: short sentences, one idea per
 bullet, things named by what the user sees ("the chat bubble", "the Plan tab") rather
 than by function, file, CSS value or gate id. Code names, `path:line` and gate ids

package/skills/kaizen-help/SKILL.md

@@ -31,7 +31,7 @@ anything.
 | `/kaizen backlog` | Print open backlog items across all runs, grouped by source run, rescued items last under `Orphaned` |
 | `/kaizen gather` | Read request sources kaizen cannot read by itself; their requests land in the icebox, nothing starts |
 | `/kaizen discover` | Group what is in the icebox and promote the ideas you pick; nothing starts |
-| `/kaizen docs [lint]` | Write or refresh the project's docs vault in the notebook, which agents read first; `lint` only reports what is stale or broken |
+| `/kaizen docs [lint]` | Write or refresh the project's docs vault in the notebook, which agents read first; `lint` only reports what is stale, broken or uncovered |
 | `/kaizen approve` | Approve whatever the current run is waiting on |
 | `/kaizen reject <reason>` | Reject it; the reason decides revise (back to planner) vs kill (abandon) |
 | `/kaizen abort` | Mark the current run abandoned |

package/web/board/terms.ts

@@ -29,12 +29,18 @@ const save = () => {
 // key -> its tile and the function that unmounts its terminal.
 const tiles = new Map<string, { el: HTMLElement; off: (() => void) | null }>();
 let showing = false;
+// A phone shows one terminal at a time, picked from tabs: stacked, each terminal took every
+// swipe and the page could only be scrolled by its thin headers. The pick is per visit.
+// Made on first show, so importing this module needs no window.
+let phone: MediaQueryList | null = null,
+  pick: string | null = null;
 
 // The header: run name - project name. A run's name is its id without the date, as card chips name runs.
 const nameOf = (c) =>
   c.kind === "run"
     ? String(c.id || c.text).replace(/^\d{4}-\d\d-\d\d-/, "").replace(/-/g, " ")
     : String(c.text).split("\n")[0].slice(0, 80);
+const tst = (c) => (!c.pty.alive ? "ended" : c.pty.asking ? "asking" : "running");
 const projOf = (c) => String(c.where || "").split(/[\\/]/).filter(Boolean).pop() || c.where || "";
 // One card per session; the newest card wins a shared key.
 function sessions() {
@@ -52,6 +58,7 @@ export function termsStop() {
 
 export function openTerms() {
   showing = true;
+  if (!phone) (phone = matchMedia("(max-width:640px)")).onchange = () => showing && openTerms();
   // A /state tick mid-drag would rebuild the handle being dragged.
   if (document.body.classList.contains("tdrag")) return;
   const box = $("terms"),
@@ -68,6 +75,8 @@ export function openTerms() {
   const keys = [...all.keys()].filter((k) => !lay.hidden.includes(k)).sort((a, b) => ended(a) - ended(b) || rank(a) - rank(b));
   for (const k of keys) if (!lay.order.includes(k)) lay.order.push(k);
   if (lay.max && !keys.includes(lay.max)) lay.max = null;
+  // The one tile showing: on a phone the tab picked (the first by default), else the maximised one.
+  const one = phone.matches ? (pick && keys.includes(pick) ? pick : keys[0]) : lay.max;
   let grid = box.querySelector<HTMLElement>(".tgrid"),
     bar = box.querySelector<HTMLElement>(".tbar");
   if (!grid) {
@@ -77,7 +86,15 @@ export function openTerms() {
   }
   // An ended session closed with × has nothing to come back to: no chip for it.
   const hid = [...all.keys()].filter((k) => lay.hidden.includes(k) && all.get(k).pty.alive);
-  bar!.innerHTML = html`<span class="bar" role="group" aria-label="Layout">${MODES.map(([v, l]) => html`<button data-mode="${v}" class="${lay.mode === v ? "on" : ""}" aria-pressed="${String(lay.mode === v)}">${l}</button>`)}</span>${hid.length ? html`<span class="dim">Hidden</span>${hid.map((k) => html`<button class="chip" data-show="${k}" title="Show this terminal">${ico("plus")}${nameOf(all.get(k))} - ${projOf(all.get(k))}</button>`)}` : ""}`.s;
+  bar!.innerHTML = html`<span class="bar" role="group" aria-label="Layout">${MODES.map(([v, l]) => html`<button data-mode="${v}" class="${lay.mode === v ? "on" : ""}" aria-pressed="${String(lay.mode === v)}">${l}</button>`)}</span>${hid.length ? html`<span class="dim">Hidden</span>${hid.map((k) => html`<button class="chip" data-show="${k}" title="Show this terminal">${ico("plus")}${nameOf(all.get(k))} - ${projOf(all.get(k))}</button>`)}` : ""}${phone.matches && keys.length > 1 ? html`<span class="ttabs" role="group" aria-label="Terminals">${keys.map((k) => html`<button class="${k === one ? "on" : ""}" data-pick="${k}" aria-pressed="${String(k === one)}"><span class="tdot ${tst(all.get(k))}"></span>${nameOf(all.get(k))} - ${projOf(all.get(k))}</button>`)}</span>` : ""}`.s;
+  bar!.querySelectorAll<HTMLElement>("[data-pick]").forEach(
+    (b) =>
+      (b.onclick = () => {
+        pick = b.dataset.pick!;
+        openTerms();
+      }),
+  );
+  bar!.querySelector(".ttabs .on")?.scrollIntoView({ block: "nearest", inline: "nearest" });
   bar!.querySelectorAll<HTMLElement>("[data-mode]").forEach(
     (b) =>
       (b.onclick = () => {
@@ -118,24 +135,24 @@ export function openTerms() {
       mount(k, t);
       wire(el);
     }
-    const st = !c.pty.alive ? "ended" : c.pty.asking ? "asking" : "running",
+    const st = tst(c),
       off = st === "ended";
     const hd = t.el.querySelector("header")!;
     hd.title = (c.kind === "run" ? c.id : c.text) + " · " + c.where;
     // An ended run can be resumed from here; an idea whose agent ended has no run to resume.
     hd.innerHTML = html`<span class="tdot ${st}" role="img" title="${st}" aria-label="${st}"></span><b>${nameOf(c)} - ${projOf(c)}</b>${off ? html`<span class="tend">ended</span>` : ""}<span class="sp"></span>${off && c.kind === "run" ? html`<button class="btn sm" data-a="resume" title="Continue this run's agent">Resume</button>` : ""}<button class="ib sm" data-a="card" title="Open card" aria-label="Open card">${ico("open")}</button><button class="ib sm" data-a="max" title="${lay.max === k ? "Restore" : "Maximise"}" aria-label="${lay.max === k ? "Restore" : "Maximise"}">${ico(lay.max === k ? "min" : "max")}</button><button class="ib sm" data-a="hide" title="${off ? "Close" : "Hide"}" aria-label="${off ? "Close" : "Hide"}">${ico("close")}</button>`.s;
     t.el.classList.toggle("ended", off);
-    t.el.classList.toggle("off", !!lay.max && lay.max !== k);
+    t.el.classList.toggle("off", !!one && one !== k);
     t.el.style.gridColumn = "";
     grid.append(t.el); // in order
   }
   // Grid is √n, the last tile spanning what its row leaves empty; side by side is one row, stacked one column.
-  const n = lay.max ? 1 : keys.length,
+  const n = one ? 1 : keys.length,
     cols = lay.mode === "cols" ? n : lay.mode === "rows" ? 1 : Math.ceil(Math.sqrt(n)),
     rows = Math.ceil(n / cols);
   // The column where the last row's tile starts spanning; borders right of it are not inner ones there.
   let spanFrom = cols;
-  if (!lay.max && cols * rows > n) {
+  if (!one && cols * rows > n) {
     tiles.get(keys[keys.length - 1])!.el.style.gridColumn = `span ${cols * rows - n + 1}`;
     spanFrom = n - (rows - 1) * cols - 1;
   }
@@ -143,7 +160,7 @@ export function openTerms() {
     sz = lay.sizes[shape];
   const c = sz?.c?.length === cols ? sz.c : Array(cols).fill(1),
     r = sz?.r?.length === rows ? sz.r : Array(rows).fill(1);
-  layout(grid, c, r, shape, spanFrom);
+  layout(grid, c, r, shape, spanFrom, !one);
 }
 
 function mount(k, t) {
@@ -177,7 +194,8 @@ function wire(el: HTMLElement) {
     openTerms();
   };
   el.querySelector("header")!.ondblclick = (e) => {
-    if ((e.target as HTMLElement).closest("button")) return;
+    // A phone shows one tile anyway: a double-tap there would only leave desktop maximised.
+    if ((e.target as HTMLElement).closest("button") || phone?.matches) return;
     lay.max = lay.max === k ? null : k;
     save();
     openTerms();
@@ -215,7 +233,7 @@ const at = (tr: number[], i: number) => {
     S = tr.slice(0, i + 1).reduce((a, b) => a + b, 0);
   return `calc((100% - ${(tr.length - 1) * GAP}px) * ${S / F} + ${i * GAP + GAP / 2}px)`;
 };
-function layout(grid: HTMLElement, c: number[], r: number[], shape: string, spanFrom: number) {
+function layout(grid: HTMLElement, c: number[], r: number[], shape: string, spanFrom: number, splits: boolean) {
   grid.querySelectorAll(".tsplit").forEach((s) => s.remove());
   const place = () => {
     grid.style.gridTemplateColumns = c.map((x) => x + "fr").join(" ");
@@ -227,7 +245,7 @@ function layout(grid: HTMLElement, c: number[], r: number[], shape: string, span
       h.style.bottom = i >= spanFrom ? `calc(100% - ${at(r, r.length - 2)} + ${GAP / 2}px)` : "0px";
     });
   };
-  if (!lay.max)
+  if (splits)
     for (const [axis, tr] of [["c", c], ["r", r]] as const)
       for (let i = 0; i < tr.length - 1; i++) {
         const h = document.createElement("div");

package/web/board.html

@@ -283,8 +283,9 @@ body.termv #terms{flex:1;min-height:0;display:flex;flex-direction:column;gap:8px
 .tsplit{position:absolute;z-index:2;touch-action:none}.tsplit.c{top:0;width:10px;margin-left:-5px;cursor:col-resize}.tsplit.r{left:0;right:0;height:10px;margin-top:-5px;cursor:row-resize}.tsplit:hover,.tdrag .tsplit:active{background:color-mix(in srgb,var(--accent) 35%,transparent)}
 body.tdrag{user-select:none}body.tdrag .tile{pointer-events:none}
 @media(max-width:900px){body.termv #terms{padding-inline:16px}}
-/* A phone has no room for a grid: tiles stack, each most of a screen tall, and the splits go */
-@media(max-width:640px){.tbar .bar{display:none}.tgrid{display:flex;flex-direction:column;overflow:auto}.tile{flex:none;height:70vh}.tile.off{display:none}.tsplit{display:none}}
+/* A phone has no room for a grid or a stack: one terminal fills the page, and tabs above pick which */
+.ttabs{display:none}
+@media(max-width:640px){.tbar .bar,.tile [data-a=max],.tsplit{display:none}.ttabs{display:flex;order:-1;flex:1 0 100%;min-width:0;gap:6px;overflow-x:auto;scrollbar-width:none}.ttabs button{flex:none;display:inline-flex;align-items:center;gap:6px;height:30px;padding:0 10px;border:1px solid var(--line);border-radius:var(--r-pill);background:none;color:var(--dim);font:inherit;font-size:12px;white-space:nowrap}.ttabs button.on{color:var(--ink);background:var(--hover);border-color:var(--accent)}.tgrid{display:flex;flex-direction:column}.tile{flex:1}.tile.off{display:none}}
 aside.docked{position:static;z-index:auto;flex:1;min-height:0;width:auto;transform:none;visibility:visible;transition:none;box-shadow:none;border:0;background:none}
 aside.docked>header,aside.docked>.body{padding-inline:28px}
 aside.docked>header{border-bottom:0;padding-top:28px;padding-bottom:12px}