@cruxy/cli 1.10.0 → 1.11.1

package/dist/routing/router.js

@@ -2,16 +2,11 @@ import { MODEL_TIERS } from "../brand/voice.js";
 import { routingTierUnavailable } from "../errors/index.js";
 import { resolveModelId } from "./resolve.js";
 import { AUTO_MODEL, } from "./types.js";
-/**
- * The tier a config resolves to when nothing else pins one down — mirrors the
- * gateway's `auto` fallback (`AUTO_FALLBACK_TIER` in the SDK), so an unrouted
- * cruxy session lands on exactly the tier it does today.
- */
-export const DEFAULT_TIER = "vaani";
 /**
  * The config-driven {@link Router}: maps a declared task class to a tier from
  * `{ default, map }`, and fails loud when the resolved tier is not offered. It
- * NEVER inspects prompt content — selection is purely `map[taskClass] ?? default`.
+ * NEVER inspects prompt content — selection is purely
+ * `map[taskClass] ?? default ?? null`.
  */
 export class ConfigRouter {
     cfg;
@@ -28,9 +23,17 @@ export class ConfigRouter {
         this.offered = new Set(offered);
     }
     select(taskClass) {
-        // Explicit override, else the default — an unmapped/unknown class is not an
-        // error, it just takes the default (never a crash, never the cheapest).
-        const tier = this.cfg.map[taskClass] ?? this.cfg.default;
+        // Explicit override, else the table's default, else DECLINE. An unmapped
+        // class is not an error and never a crash — but with no `default` it is not
+        // a tier either. Declining means `auto`: the gateway routes that request
+        // (see `Router.select`), which is what a table saying nothing about a class
+        // actually asked for. Picking some tier here instead would be the same
+        // silent substitution the throw below refuses, just quieter — a user who
+        // wrote `map: { summarize: kavi }` and no default said nothing whatsoever
+        // about the other four classes, and "nothing" is not a vote for a tier.
+        const tier = this.cfg.map[taskClass] ?? this.cfg.default ?? null;
+        if (tier === null)
+            return null;
         // Fail loud: a configured tier the gateway does not offer is a usage error
         // to fix, NOT a silent substitution to some other tier (a user who asked for
         // mira reasoning must never be quietly handed kavi).
@@ -42,14 +45,16 @@ export class ConfigRouter {
 }
 /**
  * The base tier implied by the session's `model.model`: a real tier passes
- * through; `auto` (and any non-tier value) falls back to {@link DEFAULT_TIER}.
- * Used so that when a user has pinned a single tier, an opt-in routing table
- * that omits `routing.default` still defaults to THEIR tier, not a fixed one.
+ * through, and `auto` (or any non-tier value) implies none — `undefined`, not a
+ * stand-in. Used so that when a user has pinned a single tier, an opt-in routing
+ * table that omits `routing.default` still defaults to THEIR tier, not a fixed
+ * one; and so that when they pinned nothing, the table does not acquire a
+ * default they never wrote.
  */
 function baseTierFromModel(model) {
     return MODEL_TIERS.includes(model)
         ? model
-        : DEFAULT_TIER;
+        : undefined;
 }
 /**
  * Build a router from resolved config, or `null` when routing should stay
@@ -68,6 +73,21 @@ export function routerForConfig(config) {
     const configured = def !== undefined || Object.keys(map).length > 0;
     if (!configured)
         return null;
+    // The fill is deliberate in ONE direction. When `model.model` names a real
+    // tier the user declared a session-wide model, so a table without a `default`
+    // inherits it — dropping those classes to `auto` would substitute the
+    // gateway's judgement for a choice they made, which is the same wrong as
+    // substituting vaani for `auto`, from the other side. When it names no tier
+    // (`auto`, the schema default) `baseTierFromModel` returns undefined and the
+    // table keeps its silence.
+    //
+    // NOT DEAD CODE, despite looking it from the session path: `session-factory`
+    // hands this router to a `SessionModel` that consults it only while the choice
+    // is `auto` (session-factory.ts:341), and a `model.model` naming a tier makes
+    // the choice that tier — so the tier branch never fires there. `cruxy pr`
+    // calls `routerForConfig` directly (cli/commands/pr.ts:69) with no
+    // `SessionModel` in front of it, and that is where a pinned `model.model`
+    // reaches this line.
     return new ConfigRouter({
         default: def ?? baseTierFromModel(config.model.model),
         map,

package/dist/routing/types.js

@@ -20,8 +20,6 @@ export const TASK_CLASSES = [
     "plan",
     /** Commit / pull-request text generation. */
     "commit-msg",
-    /** A cheap one-shot classification. */
-    "classify",
     /** Context compaction / summarization. */
     "summarize",
 ];

package/dist/session/prune.js

@@ -1,5 +1,6 @@
 import { unlinkSync } from "node:fs";
 import path from "node:path";
+import { INTERRUPTED, idKey, jobLogFilesByRecency, readJobLogTerminal, sessionKeysPresent, } from "../jobs/log-store.js";
 import { SESSION_RETENTION_FLOOR, } from "../config/index.js";
 import { sessionFilesByRecency } from "./list.js";
 import { SESSION_FILE_EXT } from "./paths.js";
@@ -30,6 +31,8 @@ export function pruneSessions(cwd, opts) {
         kept: 0,
         bytesFreed: 0,
         failed: 0,
+        jobLogsRemoved: 0,
+        jobLogBytesFreed: 0,
     };
     if (!opts.sessions.enabled)
         return result;
@@ -72,35 +75,92 @@ export function pruneSessions(cwd, opts) {
             result.kept++;
         }
     }
-    sweepOrphanedJobLogs();
+    sweepOrphanedJobLogs(cwd, result, opts);
     return result;
 }
 /**
- * Drop retained job logs whose owning session has just been pruned.
+ * Drop the job logs this project no longer has a reason to keep (#172 item 1).
  *
- * DELIBERATELY EMPTY, and reserved rather than forgotten. #172 item 1 will
- * write background-job output to the `subagents/` subtree `paths.ts` reserves
- * under this same project directory, and #257 exists because that issue asked
- * "whether the retained-on-disk log is pruned with the session or independently"
- * and found no answer. The answer is HERE, and it is: with the session, keyed on
- * the session.
+ * This is the second phase of the same mark-and-sweep `CheckpointService.prune`
+ * runs: the doomed sessions are already gone above, and what follows is the
+ * content that belonged to them. A job log IS content owned by its session,
+ * keyed on the session, exactly as a checkpoint's shadow objects are content
+ * owned by its manifest — which is the answer #172 asked for in passing and
+ * #257 was filed to settle: pruned WITH the session, not independently.
  *
- * That makes a job log content owned by its session in exactly the way a
- * checkpoint's shadow objects are content owned by its manifest — so this is
- * `CheckpointService.prune`'s second phase, the mark-and-sweep that runs after
- * the doomed manifests are gone. Filling it in needs one thing the writer does
- * not have yet: a job log has to record which session owns it, in its path or
- * its first line.
+ * ## The three rules, and why each one is where the line falls
  *
- * The hook is here so item 1 fills it rather than inventing a parallel
- * retention policy alongside this one. Whatever lands must not `rm -r` this
- * directory and must not assume every entry is a session's — `subagents/` is a
- * sibling of the session files, not one of them.
+ * **A finished job's log goes at the next start.** A `done` job's OUTCOME is
+ * already durable somewhere better: the dispatch tool's result is a
+ * `tool_result` in the session's own transcript, its file mutations are a
+ * checkpoint set `cruxy rollback <id>` still finds, and its spend is a usage
+ * record under the same id. What only this file holds is the intermediate
+ * chatter of a run that went fine — the least interesting artefact in the set.
+ * Dropping it eagerly is what keeps the steady-state cost of this subtree near
+ * zero, so the logs that survive are the ones somebody would actually open: the
+ * failed and the interrupted.
  *
- * It takes nothing today because it does nothing; item 1 will want the `cwd`
- * and the {@link PruneResult} whose `removed` names the sessions whose logs are
- * now orphaned.
+ * **An orphan goes when its session does.** Not only the sessions THIS prune
+ * removed: the rule is "no session file with this key is present", which also
+ * covers `cruxy sessions rm`, a prune from another process, and a file the user
+ * deleted by hand. Keying it on what the directory holds rather than on
+ * `result.removed` means there is no path by which a log outlives its session
+ * unnoticed.
+ *
+ * **Nothing without a terminal record is deleted while it is young.** A log
+ * with no `end` record is one of two things, and this sweep cannot tell them
+ * apart: a job that was interrupted (the whole reason to keep logs at all) or a
+ * job that is RUNNING RIGHT NOW in another terminal, whose session may not have
+ * flushed its own file yet. Treating it as garbage would delete a live job's
+ * output from under it. Both cases are handled by leaving it alone until it is
+ * older than `maxAgeDays`, at which point it is certainly not live and its
+ * session is certainly gone.
+ *
+ * The active session is skipped outright, for the reason `pruneSessions` spares
+ * its own file: "almost always survives" is not a policy to hand a user's
+ * running work.
+ *
+ * ## What it must not do
+ *
+ * No `rm -r`, and no assumption that every entry here is a session's — the
+ * scan behind {@link jobLogFilesByRecency} filters to regular `.jsonl` files
+ * whose name splits into exactly two ids, so anything else in `subagents/`
+ * (including the subtree's own subdirectories, should P3 add any) is never even
+ * considered. Never throws: a log that cannot be unlinked is left, exactly as a
+ * session that cannot be is.
  */
-function sweepOrphanedJobLogs() {
-    // #172 item 1.
+function sweepOrphanedJobLogs(cwd, result, opts) {
+    const refs = jobLogFilesByRecency(cwd);
+    if (refs.length === 0)
+        return;
+    // Derived from the directory as it stands NOW — after the deletes above — so
+    // the sessions this prune just removed are absent from it by construction and
+    // need no separate bookkeeping.
+    const present = sessionKeysPresent(sessionFilesByRecency(cwd));
+    const activeKey = opts.activeSessionId === undefined
+        ? undefined
+        : idKey(opts.activeSessionId);
+    const now = opts.now ?? Date.now();
+    const cutoff = now - opts.sessions.maxAgeDays * 24 * 60 * 60 * 1000;
+    for (const ref of refs) {
+        if (activeKey !== undefined && ref.sessionKey === activeKey)
+            continue;
+        // One bounded tail read per file, never a full one: see `TAIL_BYTES`.
+        const status = readJobLogTerminal(ref.file);
+        const orphaned = !present.has(ref.sessionKey);
+        const doomed = status === "done" ||
+            (orphaned && (status !== INTERRUPTED || ref.mtimeMs < cutoff));
+        if (!doomed)
+            continue;
+        try {
+            unlinkSync(ref.file);
+            result.jobLogsRemoved++;
+            result.jobLogBytesFreed += ref.size;
+        }
+        catch {
+            // Left in place, and deliberately NOT counted in `failed` — that field
+            // counts sessions, and inflating it here would report a conversation that
+            // could not be deleted when none was even tried.
+        }
+    }
 }

package/dist/subagent/orchestrator.js

@@ -147,7 +147,6 @@ export class SubagentOrchestrator {
         const startedAt = new Date().toISOString();
         try {
             return await this.runChild({
-                spec,
                 opts,
                 messages,
                 registry,
@@ -193,7 +192,7 @@ export class SubagentOrchestrator {
      * usage fold above can be a `finally` over every path this can leave by. */
     async runChild(args) {
         const { deps } = this;
-        const { spec, opts, messages, registry, budget, ctx, artifacts } = args;
+        const { opts, messages, registry, budget, ctx, artifacts } = args;
         const { label, noun, tag, usage } = args;
         let run;
         try {
@@ -211,7 +210,13 @@ export class SubagentOrchestrator {
                 subagent: true,
                 budget,
                 router: deps.router,
-                taskClass: spec.taskClass ?? "subagent",
+                // A LITERAL, not a per-spawn override (cli#281). Every child is a
+                // `subagent` by construction; letting the spec name its own class would
+                // hand the model a lever to route itself out of `routing.map.subagent`
+                // by relabelling, and would put the difficulty guess back in a call site
+                // whose whole contract (`routing/types.ts`) is that callers declare and
+                // nobody sniffs.
+                taskClass: "subagent",
                 signal: opts.signal,
                 // Both, and in this order (cli#244). The child's OWN collector is what
                 // the budget fold below reads — it needs a per-child record — while the
@@ -439,6 +444,14 @@ export class SubagentOrchestrator {
             return undefined; // no cruxy routing — not a weighted-pool request
         // No tier means the router chose `auto` and the gateway decides — a request
         // that still draws on the pool, so it is weighed at the worst case.
+        //
+        // A routing table that maps some classes and declares no `default` now
+        // lands here for `subagent` (it used to be filled with vaani), so such a
+        // fan-out is weighed at MAX_TIER_MULTIPLIER 3.8 rather than vaani's 3.25 —
+        // about 17% heavier against the pool. That is the intended answer, not
+        // drift: the tier genuinely is not known before the request, and a
+        // fan-out the gateway sends to kavi must not have been admitted on
+        // vaani's arithmetic.
         return resolveTaskModel(router, "subagent").tier ?? UNRESOLVED_TIER;
     }
     /**

package/dist/tui/app.js

@@ -3,13 +3,14 @@ import { completeLine } from "../components/autocomplete.js";
 import { SHARED_COMMANDS, SHARED_HELP, announceMode, dispatchCommand, } from "../cli/session-commands.js";
 import { TUI_ONLY_COMMANDS } from "../cli/command-catalog.js";
 import { selectList } from "../components/select.js";
-import { viewLabel, viewOrder } from "./views.js";
+import { CONVERSATION_VIEW, viewLabel, viewOrder } from "./views.js";
 import { canOverlay, createKeyLease, createOverlayIO, } from "./overlay.js";
 import { ModeRing } from "./mode-ring.js";
 import { openPalette } from "./palette.js";
 import { formatError, fromUnknown, isVerbose, shouldUseColor, } from "../errors/index.js";
 import { CLOSABLE_PANELS, columnOf, RAIL_PANELS, } from "./layout.js";
 import { COLUMN_LABELS, PANEL_LABELS } from "./panels.js";
+import { WHEEL_LINES } from "./renderer.js";
 /**
  * The TUI's input loop (P1) — the piece that replaces `repl.ts`'s readline
  * loop. It owns exactly two things: the edit buffer and command dispatch.
@@ -59,7 +60,10 @@ const HELP = [
     "  Ctrl+K           open the command palette",
     "  Ctrl+B           focus the sidebar nav (arrows switch view, Esc leaves)",
     "  Shift+Tab        cycle mode (manual · auto-approve · plan · full-auto)",
-    "  PgUp / PgDn      scroll the pane; Esc returns to the live view",
+    "  PgUp / PgDn      scroll the pane (the mouse wheel does too; to select",
+    "                   text hold Shift — Option in Terminal.app — or set",
+    "                   CRUXY_NO_MOUSE=1 to give the wheel back to the terminal)",
+    "  Esc              back to the live view, then back to the conversation",
     "  Ctrl+D           leave cruxy",
 ];
 /**
@@ -177,6 +181,10 @@ async function readLine(keys, renderer, hooks) {
                     // answering into a pane they cannot see is the one case where holding
                     // still is wrong.
                     renderer.scrollToLive();
+                    // And clears the last command's output from under a view (cli#7b):
+                    // what this line produces must not stack beneath what the last one
+                    // did. It is all still in the conversation.
+                    renderer.dismissNotices();
                     paint();
                     return text;
                 }
@@ -282,12 +290,23 @@ async function readLine(keys, renderer, hooks) {
                     // schedules its own repaint for the rows that did.
                     renderer.scrollPage(key.kind === "page-up" ? 1 : -1);
                     break;
+                case "wheel-up":
+                case "wheel-down":
+                    // The mouse wheel (cli#1) is the same scroll at a finer grain. It
+                    // only arrives because the renderer turned mouse reporting on; the
+                    // terminal would otherwise have scrolled its own window (Terminal.app)
+                    // or sent arrows this loop ignores (iTerm2).
+                    renderer.scrollBy(key.kind === "wheel-up" ? WHEEL_LINES : -WHEEL_LINES);
+                    break;
                 case "escape":
-                    // Esc leaves the scrolled view — a mode needs a visible exit, and the
-                    // notice names this key. It stays inert at the live tail rather than
-                    // being claimed unconditionally, so the binding remains free for
-                    // whatever a later track wants Esc to mean when nothing is scrolled.
-                    renderer.scrollToLive();
+                    // Esc peels one layer (cli#7b): out of scrollback first — a mode
+                    // needs a visible exit, and the notice names this key — and, at the
+                    // live tail, out of a view and back to the conversation. Two presses
+                    // from anywhere reach the home position; each one is a step the
+                    // screen can show. Inert at the conversation's live tail, so the
+                    // binding stays free for whatever a later track wants it to mean.
+                    if (!renderer.scrollToLive())
+                        renderer.setView(CONVERSATION_VIEW);
                     break;
                 case "ctrl-b":
                     // Take the keyboard to the sidebar nav (P7 track 2). Refused when the
@@ -485,6 +504,10 @@ export async function runTui(session, renderer, opts = {}) {
         print: (line = "") => renderer.println(line),
         theme: renderer.theme,
         fit: (line) => line,
+        // `/clear` (cli#2): the TUI owns its scrollback, so a cleared history is
+        // also a cleared screen. The REPL has no equivalent — its transcript is the
+        // terminal's own scrollback, which is not the CLI's to erase.
+        clear: () => renderer.clearScrollback(),
     };
     // The mode ring (Q5). The chip follows every press; the session is told once,
     // when the presses stop — see `mode-ring.ts` for why passing through a mode is

package/dist/tui/approval-overlay.js

@@ -1,3 +1,4 @@
+import { readAnswerKey } from "../components/input.js";
 import { themeForColor } from "../theme/index.js";
 /**
  * The approval prompt as an in-viewport modal (P5 track 2).
@@ -88,7 +89,9 @@ export function createOverlayPromptIO(surface, lease, color) {
             paint();
         },
         async readKey() {
-            const key = await read(keys);
+            // A wheel notch scrolls the conversation behind the drawer; it is not an
+            // answer, and mapping it to "" would deny the action being asked about.
+            const key = keys === null ? await read(keys) : await readAnswerKey(keys);
             return keyToChar(key);
         },
         /**

package/dist/tui/layout.js

@@ -124,6 +124,28 @@ export function fitBlock(lines, rows, width) {
         out.push(" ".repeat(Math.max(0, width)));
     return out;
 }
+/**
+ * Take the FIRST `rows` lines of a block and pad it to exactly that many rows —
+ * the mirror of {@link fitBlock}, for a column whose top is the part that must
+ * survive.
+ *
+ * The sidebar is that column (cli#7a). It opens with the view nav: a heading
+ * and one row per view, fixed-height, and NAVIGABLE — Ctrl+B puts the keyboard
+ * on it, and the arrows move a pointer down its rows. `fitBlock`'s tail rule
+ * applied to that column ate the heading and the first four view rows at 30
+ * rows, which left Ctrl+B moving a pointer the screen never showed. Nothing
+ * at the bottom of the sidebar is worth that: the session list below the nav
+ * is composed to its own budget by the renderer (see `sidebarLines`), so what
+ * reaches here already fits, and when it does not — a terminal too short for
+ * the nav itself — the rows to lose are the last ones, not the first.
+ */
+export function fitHead(lines, rows, width) {
+    const head = lines.length > rows ? lines.slice(0, Math.max(0, rows)) : lines;
+    const out = head.map((l) => padTo(l, width));
+    while (out.length < rows)
+        out.push(" ".repeat(Math.max(0, width)));
+    return out;
+}
 /**
  * Window `rows` lines out of a block, `offset` display lines up from the end
  * (P7 track 1). `offset === 0` is the tail view {@link fitBlock} gives, and the
@@ -293,8 +315,10 @@ export function composeScreen(vm, width, height, open, theme) {
     const drawer = fitOverlay(vm.overlay ?? [], overlayRows(height));
     const columnRows = Math.max(1, rows - drawer.length);
     const columns = [];
+    // HEAD-fitted, not tail: the sidebar is a nav over a list, and the nav is the
+    // part that has to be on screen — see `fitHead`. `main` stays a tail view.
     if (budget.sidebar > 0)
-        columns.push(fitBlock(vm.sidebar, columnRows, budget.sidebar));
+        columns.push(fitHead(vm.sidebar, columnRows, budget.sidebar));
     columns.push(fitBlock(vm.main, columnRows, budget.main));
     if (budget.rail > 0)
         columns.push(fitBlock(vm.rail, columnRows, budget.rail));

package/dist/tui/panels.js

@@ -50,22 +50,44 @@ function title(text, theme) {
  * The column is narrow (18 columns), so each session takes two lines: its short
  * id and age, then its title. The layout truncates per line, which keeps the id
  * — the part you would type into `--resume` — always fully visible.
+ *
+ * `rows` is the HEIGHT budget (cli#7a), and the list is fitted to it here the
+ * way `stackPanels` fits the rail: whole sessions, newest first, and a count of
+ * what did not fit rather than a session cut in half or silently absent. The
+ * list sits under the view nav, which is fixed-height and keyboard-driven, so
+ * it is the list that yields — and because it is newest-first, the rows to
+ * yield are at the END. The old tail-fit lost the nav heading and the newest
+ * sessions at once, which is the wrong end of both blocks.
  */
-export function sidebarLines(theme, sessions = [], activeSessionId, now = Date.now()) {
+export function sidebarLines(theme, sessions = [], activeSessionId, now = Date.now(), rows = Infinity) {
+    if (rows <= 0)
+        return [];
     const lines = title("sessions", theme);
     if (sessions.length === 0) {
         lines.push(theme.muted("no saved sessions"));
         lines.push(theme.muted("for this project yet."));
-        return lines;
+        return lines.slice(0, rows);
     }
-    for (const s of sessions) {
+    // Rows left for sessions after the title. Each session costs two, and when
+    // not all fit, one row is charged for the notice BEFORE deciding how many do
+    // — reserving it afterwards could evict a session just counted as shown.
+    const room = Math.max(0, rows - lines.length);
+    const fitsWhole = sessions.length * 2 <= room;
+    const shown = fitsWhole
+        ? sessions.length
+        : Math.max(0, Math.floor((room - 1) / 2));
+    for (const s of sessions.slice(0, shown)) {
         const active = s.sessionId === activeSessionId;
         const mark = active ? theme.accent(theme.glyph.pointer) : " ";
         const head = `${mark} ${shortId(s.sessionId)} ${relativeAge(s.updatedAt, now)}`;
         lines.push(active ? theme.strong(head) : head);
         lines.push(theme.muted(`  ${s.title}`));
     }
-    return lines;
+    if (!fitsWhole && room > 0) {
+        const hidden = sessions.length - shown;
+        lines.push(theme.muted(`${theme.glyph.ellipsis}${hidden} more session${hidden === 1 ? "" : "s"}`));
+    }
+    return lines.slice(0, rows);
 }
 /** A panel with no state yet: says so, rather than inventing a plausible value. */
 function pending(theme) {
@@ -236,19 +258,35 @@ function shortTokens(n) {
  *
  * The compaction threshold is shown because it is the only actionable thing
  * here: it says when the CLI will start folding history away.
+ *
+ * THE ALLOWANCE IS NAMED (cli#4). `used` includes `context.reserveTokens` — a
+ * fixed 4,500 by default — because the compaction seam adds it, and the panel
+ * must measure what the seam measures. But shown as a bare figure it read as
+ * consumption: an empty session opened at "~5k / 100k", as if something had
+ * already been spent. Nothing had. The constant is a fair size for what it
+ * stands in for (the system prompt plus the default tool catalogue measure
+ * about 3.7k), and it is an ALLOWANCE, not a reading: it does not move when
+ * CRUXY.md, memory recall, LSP, web or MCP schemas make the real request
+ * larger. The second row says so, in the room a 24-column strip has.
  */
 export function contextPanelLines(theme, reading) {
     if (reading === undefined) {
         return [theme.muted(`measuring${theme.glyph.ellipsis}`)];
     }
-    const { used, total, compactAt } = reading;
+    const { used, total, compactAt, reserve } = reading;
     const figure = `~${shortTokens(used)} / ${shortTokens(total)} budget`;
     // Past the threshold the next turn compacts, which is worth flagging — but as
     // a statement of what happens next, not as an alarm about a guessed number.
     // Compared on `used`, not the clamped fraction: the clamp is for display, and
     // a history that has overrun the budget must not compare as merely "at" it.
     const style = used >= compactAt ? theme.warning : theme.strong;
-    return [style(figure), theme.muted(`compacts at ${shortTokens(compactAt)}`)];
+    return [
+        style(figure),
+        ...(reserve === undefined || reserve <= 0
+            ? []
+            : [theme.muted(`incl. ~${shortTokens(reserve)} allowance`)]),
+        theme.muted(`compacts at ${shortTokens(compactAt)}`),
+    ];
 }
 /** The opening lines of the main column, before any turn has run. */
 export function mainWelcome(theme, hint) {