cawdev-cli 1.0.4-beta → 1.0.6-beta

package/runner/attach.mjs

@@ -46,18 +46,26 @@
 // curses library.
 
 import { spawn } from 'node:child_process';
+import { rm } from 'node:fs/promises';
 import { connect } from 'node:net';
 import { basename, dirname } from 'node:path';
 import { listSockets, socketPathFor } from './control.mjs';
 import {
   RESTART_FROM_ATTACH, addProject, addWorkspace, agentsOf, pathsOf, readConfigFile, reloadIfRunning,
-  setAcceptsRulesFromConsole, setAgentEnabled, setQuality, slugsOf,
+  removeProject, setAcceptsRulesFromConsole, setAgentEnabled, setQuality, slugsOf,
 } from './configure.mjs';
 import {
   TYPE_A_PATH, absolute, completePath, describe, inspectPath, listDirectories,
 } from './paths.mjs';
 import { clip, keyList, padVisible, painter, stripAnsi, visibleWidth, wrap } from '../lib/ansi.mjs';
 import { restartNeededFor } from '../lib/runner-config.mjs';
+import {
+  BOARD_COLUMNS, MIN_ZONE_HEIGHT, PROMPT_ROWS, SplitScreen, tabsLine, visibleSessions, actionsFor, composeFrame,
+  carriesOnHere, builtNothing, cardLines, cardTitleFor, commandWords, wordsText, subtitleFor, agentModelFor, wordWrap, isAutoCheckout, isPullRequest, parseNew, roadmapStrip, sessionTag, splitLayout, titleFor, toneFor,
+  windowLines,
+} from './split.mjs';
+import { KNOWN_AGENTS, agentOfCommand } from '../lib/agents.mjs';
+import { loadPrefs, savePrefs } from './prefs.mjs';
 import { oneLine } from './brand.mjs';
 import { Scrollback } from './scrollback.mjs';
 import { Session, signInThroughBrowser, storedSession } from './sign-in.mjs';
@@ -127,7 +135,7 @@ export function questionState(questions, email) {
  * let somebody type an answer and then refused it reads as cawdev being broken
  * rather than as the question belonging to a colleague.
  */
-export function questionBanner(asking, width, ink = painter(3)) {
+export function questionBanner(asking, width, ink = painter(3), { entire = false } = {}) {
   if (!asking) return [];
 
   const options = asking.question.options?.length
@@ -135,10 +143,16 @@ export function questionBanner(asking, width, ink = painter(3)) {
     : '';
   // 12 is the label and its spaces: the same arithmetic the permission banner
   // uses, and for the same reason — clip counts visible characters.
-  const head = `${ink.bold(ink.accent(' question '))} ${clip(asking.question.question, width - 12)}`;
+  // `entire` (advanced mode, where the banner is the only place the question
+  // is shown): every word of it, wrapped between words under the label.
+  const label = ink.bold(ink.accent(' question '));
+  const head = entire
+    ? wordWrap(asking.question.question, width - 12)
+      .map((line, i) => `${i === 0 ? label : ' '.repeat(10)} ${line}`)
+    : [`${label} ${clip(asking.question.question, width - 12)}`];
 
   if (asking.yours) {
-    return [head, ` ${ink.success('a')} answer${options}`];
+    return [...head, ` ${ink.success('a')} answer${options}`];
   }
   // The NAME is the last thing to go, the way the session total is on R62's
   // bar: "waiting on alice@…" is the whole answer to "why is that not moving",
@@ -147,7 +161,7 @@ export function questionBanner(asking, width, ink = painter(3)) {
   // answer — which is what looking at this at 40 columns showed.
   const who = ` waiting on ${asking.waitingOn ?? 'somebody else'}`;
   const whole = `${who} — theirs to answer, or somebody they hand it to`;
-  return [head, ink.muted(clip(whole.length <= width ? whole : who, width))];
+  return [...head, ink.muted(clip(whole.length <= width ? whole : who, width))];
 }
 
 /**
@@ -572,11 +586,13 @@ export function footerLines(state, width, ink = painter(3)) {
  * @param argv the command line, for `--runner`, `--url`, `--watch-only`
  * @param options set when the daemon is running IN THIS PROCESS (`--attach`):
  *   its socket is already known, quitting means stopping it, and it can say how
- *   much work would be lost if you did.
+ *   much work would be lost if you did. `url` is where to sign in when the
+ *   caller has read the config (`cawdev.mjs`'s `launchUrl`); without it,
+ *   `urlFrom`, which cannot see a config.
  */
-export async function attach(argv, options = {}) {
+export async function attach(argv, { url, ...options } = {}) {
   const socket = options.socketPath ?? (await chooseSocket(valueOf(argv, '--runner')));
-  const session = await openSession(argv);
+  const session = await openSession(argv, url ?? urlFrom(argv));
 
   // Spread second so `--attach`'s own wiring wins: there the daemon IS this
   // process and quitting has always stopped it.
@@ -590,6 +606,14 @@ export function valueOf(argv, flag) {
   return at === -1 ? null : argv[at + 1];
 }
 
+/**
+ * Whether a failed clone's output is ssh refusing to ask a person — BatchMode
+ * with a key the agent does not hold. Pure, for the test.
+ */
+export function sshNeedsAPerson(said) {
+  return /Permission denied \(publickey|passphrase|Host key verification failed/i.test(String(said ?? ''));
+}
+
 export function urlFrom(argv) {
   return (valueOf(argv, '--url') ?? process.env.CAWDEV_URL ?? 'https://app.cawdev.com')
     .replace(/\/+$/, '');
@@ -628,8 +652,7 @@ async function chooseSocket(wanted) {
  * expired session looks like, and the answer is the same as having none — the
  * browser, once, and then remembered again.
  */
-async function openSession(argv) {
-  const url = urlFrom(argv);
+async function openSession(argv, url) {
   if (argv.includes('--watch-only')) {
     return new Session(url);
   }
@@ -694,8 +717,6 @@ export function splitPrompt(prompt, limit = 40) {
   return { said: question, label: `${bracket ? `${bracket} ` : ''}▸` };
 }
 
-/** The agents the config screen offers a switch for, whether or not they are on. */
-const KNOWN_AGENTS = ['claude', 'agy'];
 
 /**
  * The config screen's rows, with the state of each thing on the row — R288.
@@ -710,7 +731,7 @@ function qualityOf(entry) {
   return entry && typeof entry === 'object' && entry.quality ? entry.quality : null;
 }
 
-export function configMenu(file, runner = {}) {
+export function configMenu(file, runner = {}, gone = new Set()) {
   const slugs = slugsOf(file);
   const agents = agentsOf(file);
   const rulesOn = file.acceptsRulesFromConsole === true;
@@ -747,11 +768,39 @@ export function configMenu(file, runner = {}) {
       ...slugs.map((slug) => (qualityOf(file.projects[slug])
         ? { id: `quality:${slug}`, label: `Stop scanning ${slug} with SonarQube`, hint: `${qualityOf(file.projects[slug]).command ?? 'sonar-scanner'} after TEST now` }
         : { id: `quality:${slug}`, label: `Scan ${slug} with SonarQube after TEST`, hint: 'not scanned here' })),
+      // One row per served project — first the ones cawdev no longer has,
+      // which are the reason anybody comes looking for this row.
+      ...[...slugs].sort((a, b) => Number(gone.has(b)) - Number(gone.has(a))).map((slug) => ({
+        id: `remove:${slug}`,
+        label: `Stop serving ${slug}`,
+        hint: gone.has(slug) ? 'not on cawdev any more' : 'its checkouts stay on disk',
+      })),
       { id: 'show', label: "Show this machine's config", hint: runner.configPath ?? '' },
     ],
   });
 }
 
+/** `/new`'s agent flags: `--claude`, `--codex`, `--agy`. */
+const AGENT_FLAGS = new Set(KNOWN_AGENTS.map((agent) => `--${agent}`));
+
+/** A start's body, naming the agent when one was chosen — and nothing when not. */
+function withAgent(body, agent) {
+  return agent ? { ...body, agent } : body;
+}
+
+/** What was started, saying with which agent when one was named. */
+function withWho(what, agent) {
+  return agent ? `${what} with ${agent}` : what;
+}
+
+/** How many times a finished dev session's zero commits is read again before it is believed — see countCommits. */
+const COMMIT_REREADS = 6;
+
+/** `r29` → `R29`, `I12` → `i12`, `29` as it is: how the API spells a card's ref (R221). */
+function refOf(word) {
+  return word.replace(/^r/i, 'R').replace(/^i/i, 'i');
+}
+
 /** The slash commands, and the one place they are described. */
 const COMMANDS = [
   ['/help', 'this list'],
@@ -761,6 +810,20 @@ const COMMANDS = [
   ['/config', "this machine's config — the same as c"],
   ['/cancel', 'cancel the session you are watching'],
   ['/log', "the daemon's own log, on or off"],
+  ['/advanced-mode', 'one window per session around the prompt, for the projects you tick (@slug names them), or back'],
+  ['/new', 'start a session here: /new plan|dev R3, /new plan|dev <the task>, /new ask … (@project)'],
+  ['/card', 'add an idea to Considering — no session: /card <the idea> (@project)'],
+  ['/agent', 'which agent /new uses: /agent claude|codex|agy, /agent default, /agent to see it'],
+  ['/develop', 'start the development of the card a finished plan was about, or of one named: /develop R30 (--codex) (@project)'],
+  ['/pr', "open the pull request of a finished session's branch"],
+  ['/continue', 'pick a failed or stopped session back up on this machine — the console\'s Carry on'],
+  ['/projects', 'which projects advanced mode shows — tick one or several'],
+  ['/refresh', "read the cards and their statuses from cawdev again — advanced mode's roadmap"],
+  ['/open', "open the session's pull request in your browser — or, on a finished plan, its card and plan on cawdev"],
+  ['/view', "a card here in the terminal: /view R29, /view <words of its title> (@project), /view card for the session's; /view alone opens the session on cawdev"],
+  ['/drop', 'delete the checkout a finished session was made on demand for'],
+  ['/close', "close an ended session's window"],
+  ['/reload', 'quit and start again on the code on disk — the runner too, when nothing is running'],
   ['/quit', 'stop the runner and leave (--leave-running keeps it up)'],
 ];
 
@@ -774,6 +837,47 @@ const COMMANDS = [
  * lesson about rules in a renderer is that they can only be tested by looking at
  * them.
  */
+/**
+ * Why a checkout must not be deleted, in words, or null when nothing in it
+ * would be lost: no uncommitted file, and no commit that is on no branch of
+ * origin.
+ */
+async function checkoutState(path) {
+  const git = (args) => new Promise((done) => {
+    const child = spawn('git', ['-C', path, ...args], { stdio: ['ignore', 'pipe', 'pipe'] });
+    let out = '';
+    child.stdout.on('data', (chunk) => (out += chunk));
+    child.on('error', () => done(null));
+    child.on('close', (code) => done(code === 0 ? out.trim() : null));
+  });
+  const status = await git(['status', '--porcelain']);
+  if (status === null) return 'it could not be read as a git checkout';
+  if (status) return `${status.split('\n').length} file(s) are not committed`;
+  const unpushed = await git(['rev-list', '--count', 'HEAD', '--not', '--remotes=origin']);
+  if (unpushed === null) return 'whether its commits are on origin could not be read';
+  if (Number(unpushed) > 0) return `${unpushed} commit(s) are not on origin — /pr pushes the branch`;
+  return null;
+}
+
+/** The environment variable `/reload` hands its state over in. */
+const RELOAD_STATE = 'CAWDEV_RELOAD_STATE';
+
+/**
+ * The state a `/reload` handed this process, read once and taken out of the
+ * environment — a session this terminal spawns later must not inherit it, and
+ * a second reload writes its own.
+ */
+function readReloadState() {
+  const raw = process.env[RELOAD_STATE];
+  delete process.env[RELOAD_STATE];
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
 export class Attached {
   /**
    * @param options `out` is where to draw — `process.stdout` in the real thing,
@@ -867,6 +971,35 @@ export class Attached {
      * laptop.
      */
     this.configuring = null;
+
+    /**
+     * Advanced mode, when it is on: the alternate screen, the window the
+     * prompt talks to, and what was said while it was up — see split.mjs.
+     */
+    this.split = null;
+    /**
+     * Every session this terminal has seen, ended ones included — the daemon
+     * forgets a run the moment it finishes, and "develop it now" or "open its
+     * pull request" is asked of exactly those. runId -> meta.
+     */
+    this.sessions = new Map();
+    /** Ended sessions whose window somebody closed. */
+    this.closed = new Set();
+    /**
+     * Projects this machine serves that cawdev answered 404 for — deleted in
+     * the console, or the person's access went. The config still names them,
+     * so without this the terminal kept offering them everywhere it offers a
+     * project. Learnt from `refreshPlanned`, and forgotten when one answers.
+     */
+    this.gone = new Set();
+    /** Of those, the ones not yet said — see `sayGone`. */
+    this.goneUnsaid = [];
+    /** A project whose next new CODE session takes the focus — see startNew. */
+    this.focusOnArrival = null;
+    /** The PLANNED cards of the projects this machine serves — advanced mode's top strip. */
+    this.planned = [];
+    // Every card of every served project, whatever its status — the strip.
+    this.cards = [];
   }
 
   /**
@@ -891,6 +1024,8 @@ export class Attached {
   async start() {
     this.screen.open();
     this.history = new History(await loadHistory(this.session.url).catch(() => []));
+    // `/agent`'s choice, from last time — see prefs.mjs.
+    this.agent = (await loadPrefs(this.session.url).catch(() => ({}))).agent ?? null;
     // Raw mode only where there is a terminal to put in it. Through a pipe
     // there are no keys, the transcript is the whole output, and that is the
     // honest degradation rather than a broken one.
@@ -928,6 +1063,7 @@ export class Attached {
     }
     process.stdout.on('resize', () => {
       this.screen.resize();
+      this.split?.screen.resize();
       this.dirty = true;
     });
 
@@ -936,6 +1072,10 @@ export class Attached {
       void this.watchInbox();
       void this.watchQuestions();
     }
+    // `/reload`'s other half: the state the terminal was in before it
+    // restarted — advanced mode, the focus, the windows of sessions that had
+    // ended — so a reload changes the code and nothing else.
+    this.restore(this.options.restore ?? readReloadState());
 
     // One write per tick at most, carrying everything that happened in it. A
     // busy session emits hundreds of lines a second, and a write per line means
@@ -998,7 +1138,9 @@ export class Attached {
     if (event.type === 'hello') {
       this.runner = event.runner;
       this.runs = event.runs;
+      this.trackSessions();
       this.chooseWatched();
+      void this.findStopped();
     } else if (event.type === 'runner') {
       // R294: the daemon re-read its config — after a signal, or because the
       // file's mtime moved — and says what it applied and what it could not.
@@ -1008,18 +1150,21 @@ export class Attached {
       this.runner = event.runner;
     } else if (event.type === 'runs') {
       this.runs = event.runs;
+      this.trackSessions();
       this.chooseWatched();
     } else if (event.type === 'output') {
       const kept = this.lines.get(event.runId) ?? [];
       kept.push(event.line);
       if (kept.length > 5000) kept.splice(0, kept.length - 5000);
       this.lines.set(event.runId, kept);
-      if (event.runId === this.watching && !this.showLog) {
+      // In advanced mode the session's window is where its output goes; the
+      // scrollback gets it when the mode is left.
+      if (event.runId === this.watching && !this.showLog && !this.split) {
         this.say(this.render(event.line));
       }
     } else if (event.type === 'backlog') {
       this.lines.set(event.runId, event.lines);
-      if (event.runId === this.watching && !this.printed.has(event.runId)) {
+      if (event.runId === this.watching && !this.printed.has(event.runId) && !this.split) {
         this.layHistoryIn(event.runId, event.lines);
       }
     } else if (event.type === 'log') {
@@ -1045,17 +1190,73 @@ export class Attached {
    * character and an escape sequence.
    */
   say(text) {
+    // In advanced mode the prompt's window wraps what it shows, to its own
+    // width; wrapping here first, to the whole terminal's, cut every long line
+    // twice.
+    if (this.split) {
+      this.pending.push(...String(text).split('\n'));
+      this.dirty = true;
+      return;
+    }
     for (const line of wrap(text, this.screen.width)) {
       this.pending.push(line);
     }
     this.dirty = true;
   }
 
+  /**
+   * A line that belongs to one question or one permission request. Outside
+   * advanced mode it is printed like any other — the scrollback is a record.
+   * In advanced mode it goes to the prompt window TAGGED, and the window drops
+   * it as soon as what it is about is no longer open (`stillOpen`): answered
+   * here, answered in the console, or its session gone. The prompt is where
+   * the NEXT thing is read, and a question already answered sitting above it
+   * is the text somebody reads by mistake.
+   */
+  sayAbout(about, text) {
+    // `{ prefix, body, paint }` is prose to be wrapped between words at the
+    // width it is DRAWN at — the window's, which changes — rather than now.
+    const prose = typeof text === 'object' && text !== null;
+    if (!this.split) {
+      this.say(prose ? `${text.prefix}${text.paint(text.body)}` : text);
+      return;
+    }
+    // Whatever was queued before it goes first, so the order on screen is the
+    // order things happened in.
+    this.split.messages.push(...this.pending);
+    this.pending = [];
+    if (prose) {
+      this.split.messages.push({ ...text, about });
+    } else {
+      for (const line of String(text).split('\n')) {
+        this.split.messages.push({ text: line, about });
+      }
+    }
+    this.dirty = true;
+  }
+
+  /** The ids of every question and permission request this terminal believes open. */
+  stillOpen() {
+    return new Set([
+      ...[...this.questions.values()].map((state) => state?.question?.id),
+      ...[...this.approvals.values()].map((pending) => pending?.approval?.id),
+    ].filter(Boolean));
+  }
+
   /** Everything queued, plus the footer as it is right now, in one write. */
   flush() {
     const lines = this.pending;
     this.pending = [];
     this.dirty = false;
+    if (this.split) {
+      // What would have been printed is the prompt window's to show.
+      this.split.messages.push(...lines);
+      if (this.split.messages.length > 500) {
+        this.split.messages.splice(0, this.split.messages.length - 500);
+      }
+      this.split.screen.draw(this.splitFrame());
+      return;
+    }
     this.screen.update(lines, this.footer());
   }
 
@@ -1141,9 +1342,19 @@ export class Attached {
 
   note(text) {
     this.status = text;
+    // In advanced mode, which window it was said about — the focused one at
+    // the moment it was said. A note outlives the focus moving, and "a
+    // session is running" read under another window is a note about nobody.
+    this.statusWindow = this.split && text ? this.windowNumberOf(this.split.focus) : null;
     this.dirty = true;
   }
 
+  /** A window's number, as its title shows it; null when it has none. */
+  windowNumberOf(id) {
+    const at = id ? this.windows().findIndex((meta) => meta.id === id) : -1;
+    return at >= 0 ? at + 1 : null;
+  }
+
   // --- what is waiting on a person -----------------------------------------
 
   /**
@@ -1408,6 +1619,23 @@ export class Attached {
       this.confirming = null;
     }
 
+    if (this.split && (key === '\t' || key === `${ESC}[Z`)) {
+      return this.cycleFocus(key === '\t' ? 1 : -1);
+    }
+    if (this.split && key === 'd') {
+      // On a finished plan's window, `d` is that plan's `/develop`: the card
+      // it planned, by the agent that planned it, in the window it leaves.
+      // Anywhere else, the list of planned cards.
+      return void (this.finishedPlan(this.commandTarget()) ? this.develop() : this.pickPlanned());
+    }
+    // ↑ with no line open: the last thing typed, on a line ready to send — as
+    // a shell does. Not in advanced mode, where the wheel arrives as arrows
+    // (`?1007h`) and would pull the history up on every scroll; there ↑ works
+    // on the line itself (`/` or enter, then ↑).
+    if (!this.split && (key === `${ESC}[A` || key === `${ESC}OA`)) {
+      return this.recallIntoALine();
+    }
+
     switch (key) {
       case 'q':
         return this.quit();
@@ -1470,6 +1698,10 @@ export class Attached {
       default:
         if (/^[1-9]$/.test(key)) {
           const at = Number(key) - 1;
+          if (this.split) {
+            const windows = this.windows();
+            return at < windows.length ? this.focusWindow(windows[at].id) : this.note('');
+          }
           if (at < this.runs.length) {
             this.watch(this.runs[at].id);
           }
@@ -1618,7 +1850,8 @@ export class Attached {
       // With a completion list open, enter takes the highlighted command —
       // which is what makes guessing a name stop being a step. With none, it
       // sends what was typed.
-      if (rows.length && this.input.showing !== false && this.input.kind === 'command') {
+      if (rows.length && this.input.showing !== false && this.input.kind === 'command'
+          && !this.input.recalling) {
         line.set(rows[at][0]);
       }
       return this.submit();
@@ -1639,7 +1872,28 @@ export class Attached {
       return undefined;
     }
 
-    if (key === `${ESC}[A` || key === `${ESC}OA` || key === '\x10') {
+    const up = key === `${ESC}[A` || key === `${ESC}OA` || key === '\x10';
+    const down = key === `${ESC}[B` || key === `${ESC}OB` || key === '\x0e';
+    // ↑ on a line nothing has been typed on yet — empty, or the bare `/` a
+    // command line opens with — is HISTORY, as in every shell; so is ↑/↓
+    // while walking it. Only once something is typed do the arrows move in the
+    // list of commands. Before this the `/` line showed every command and ↑
+    // moved in that list, so a command line could never reach its history.
+    const untouched = line.text === '' || line.text === '/';
+    if ((up && (untouched || this.input.recalling)) || (down && this.input.recalling)) {
+      const keep = this.input.kind === 'command' ? (entry) => entry.startsWith('/') : undefined;
+      const recalled = up ? this.history.back(line.text, keep) : this.history.forward(keep);
+      if (recalled !== null) {
+        line.set(recalled);
+        // Walking the history, not the completions: enter sends the line as
+        // recalled rather than swapping it for the highlighted command.
+        this.input.recalling = true;
+        this.input.showing = false;
+        this.dirty = true;
+      }
+      return undefined;
+    }
+    if (up) {
       if (this.input.path && rows.length) {
         this.input.path.at = (at - 1 + rows.length) % rows.length;
         this.dirty = true;
@@ -1653,11 +1907,12 @@ export class Attached {
       const older = this.history.back(line.text);
       if (older !== null) {
         line.set(older);
+        this.input.recalling = true;
         this.dirty = true;
       }
       return undefined;
     }
-    if (key === `${ESC}[B` || key === `${ESC}OB` || key === '\x0e') {
+    if (down) {
       if (this.input.path && rows.length) {
         this.input.path.at = (at + 1) % rows.length;
         this.dirty = true;
@@ -1675,6 +1930,10 @@ export class Attached {
       }
       return undefined;
     }
+    // Anything else edits the line: what is on it is no longer a recollection.
+    if (key !== '\r' && key !== '\n') {
+      this.input.recalling = false;
+    }
 
     if (key === '\x7f' || key === '\b') {
       line.backspace();
@@ -1739,7 +1998,10 @@ export class Attached {
     if (kind === 'command' || (kind === 'prompt' && typed.startsWith('/'))) {
       // After the write, not beside it: `/logout` forgets the history, and a
       // write still in flight would put the command that cleared it back.
-      return void remembered.then(() => this.runCommand(typed));
+      // The EXPANDED text: a command is as much a place to paste into as a
+      // prompt, and running it on the placeholder sent "[pasted, 12 lines]"
+      // as the task in place of the twelve lines.
+      return void remembered.then(() => this.runCommand(text));
     }
     if (kind === 'prompt') {
       return void this.send(text);
@@ -1818,9 +2080,24 @@ export class Attached {
       // makes everywhere else.
       return this.note('');
     }
+    if (select.many) {
+      this.mode = 'keys';
+      this.select = null;
+      return this.choseMany(select, outcome.rows ?? []);
+    }
     return this.chose(select, outcome.row);
   }
 
+  /** Several rows were ticked and confirmed — a picker opened with `many`. */
+  choseMany(select, rows) {
+    if (select.kind === 'split-projects') {
+      const slugs = rows.map((row) => row.id);
+      if (!slugs.length) return this.note('');
+      return this.split ? this.focusProjects(slugs) : this.enterSplit(slugs);
+    }
+    return this.note('');
+  }
+
   /**
    * A row was chosen, whichever way it was chosen.
    *
@@ -1855,6 +2132,29 @@ export class Attached {
       }
       return void this.allow(row.id);
     }
+    if (select.kind === 'drop') {
+      return void this.droppedCheckout(row);
+    }
+    if (select.kind === 'view-card') {
+      const [slug, ref] = String(row.id).split(' ');
+      return void this.showCard(slug, ref);
+    }
+    if (select.kind === 'planned') {
+      const [slug, ref] = String(row.id).split(' ');
+      return void this.startNew(['dev', ref, `@${slug}`]).then(() => this.refreshPlanned());
+    }
+    if (select.kind === 'card-project') {
+      // `/card` asked which project; the same card, with it named.
+      const words = this.cardWaitingForProject ?? [];
+      this.cardWaitingForProject = null;
+      return void this.addCard([...words, `@${row.id}`]);
+    }
+    if (select.kind === 'project') {
+      // `/new` asked which project; the same command again, with it named.
+      const words = this.newWaitingForProject ?? [];
+      this.newWaitingForProject = null;
+      return void this.startNew([...words, `@${row.id}`]);
+    }
     if (select.kind === 'config') {
       // R288: the walk asked, the walk gets the row. Nothing is decided here.
       this.configuring?.answer?.(row);
@@ -1961,7 +2261,8 @@ export class Attached {
     }
     return this.openPicker(new Select({
       kind: 'question',
-      title: clip(asking.question.question, Math.max(20, this.screen.width - 2)),
+      title: clip(`${this.tagOf(this.current())} asks: ${asking.question.question}`,
+        Math.max(20, this.screen.width - 2)),
       rows: [
         ...options.map((option) => ({ id: option, label: option })),
         // Always last, and always there.
@@ -1989,7 +2290,7 @@ export class Attached {
       kind: 'permission',
       // The call, on the title, as well as printed in full above: the picker
       // may still be on screen when the transcript under it has moved on.
-      title: `${approval.toolName} · ${approval.summary}`,
+      title: `${this.tagOf(this.current())} wants ${approval.toolName} · ${approval.summary}`,
       rows: [
         { id: 'y', label: 'Allow once', hint: 'this call and no more' },
         // R78: the middle grant NAMES what it covers, and it says so in the
@@ -2036,11 +2337,13 @@ export class Attached {
     if (pending && !this.announced.has(pending.approval.id)) {
       this.announced.add(pending.approval.id);
       const ink = this.ink;
-      this.say('');
-      this.say(`${ink.bold(ink.warn(' permission '))} ${ink.text(pending.approval.toolName)}`);
+      const about = pending.approval.id;
+      this.sayAbout(about, '');
+      this.sayAbout(about, `${ink.bold(ink.warn(' permission '))} ${ink.muted('from')} ${ink.bold(this.tagOf(run))}`);
+      this.sayAbout(about, `  ${ink.text(pending.approval.toolName)}`);
       // Not clipped: this is the thing being decided about, and a command cut
       // at the width is a command you have not read.
-      this.say(`  ${ink.text(pending.approval.summary)}`);
+      this.sayAbout(about, { prefix: '  ', body: pending.approval.summary, paint: ink.text });
       if (this.mode === 'keys') {
         this.askPermission(pending);
       }
@@ -2053,13 +2356,20 @@ export class Attached {
     }
     this.announced.add(asking.question.id);
     const ink = this.ink;
-    this.say('');
-    this.say(`${ink.bold(ink.accent(' question '))} ${ink.text(asking.question.question)}`);
+    // In advanced mode the question is the prompt's BANNER alone, whole and
+    // wrapped, and it goes when the question does: written into the messages
+    // as well, it was on screen twice — once whole, once cut — and stayed
+    // after it was answered.
+    if (!this.split) {
+      this.say('');
+      this.say(`${ink.bold(ink.accent(' question '))} ${ink.muted('from')} ${ink.bold(this.tagOf(run))}`);
+      this.say(`  ${ink.text(asking.question.question)}`);
+    }
     // R58: a watcher who does not own the question is told whose it is and is
     // offered nothing. A picker here would take an answer the platform then
     // refuses, which reads as cawdev being broken.
     if (!asking.yours) {
-      this.say(`  ${ink.muted(`waiting on ${asking.waitingOn ?? 'somebody else'}`)}`);
+      if (!this.split) this.say(`  ${ink.muted(`waiting on ${asking.waitingOn ?? 'somebody else'}`)}`);
       return;
     }
     if (this.mode === 'keys' && this.session.signedIn && asking.question.options?.length) {
@@ -2152,7 +2462,7 @@ export class Attached {
     const ask = { line: (prompt) => this.askLine(prompt) };
     const pick = (_ask, _say, select) => this.askPick(select).then((row) => ({ done: 'chosen', row }));
 
-    const chosen = await this.askPick(configMenu(file, this.runner));
+    const chosen = await this.askPick(configMenu(file, this.runner, this.gone));
     this.say('');
     this.say(`${ink.bold(ink.accent(' config '))} ${ink.text(chosen.label)}`);
 
@@ -2204,6 +2514,15 @@ export class Attached {
       });
       return this.reloadDaemon(file, next);
     }
+    if (chosen.id.startsWith('remove:')) {
+      const slug = chosen.id.slice('remove:'.length);
+      const next = await removeProject({ file, configPath, ask, say, ink, slug });
+      // Off the screen now, though the daemon serves it until a restart.
+      this.gone.add(slug);
+      this.cards = this.cards.filter((card) => card.slug !== slug);
+      this.planned = this.planned.filter((card) => card.slug !== slug);
+      return this.reloadDaemon(file, next);
+    }
     if (chosen.id === 'rules') {
       const next = await setAcceptsRulesFromConsole({
         file, configPath, ask, say, ink, enabled: file.acceptsRulesFromConsole !== true,
@@ -2377,14 +2696,27 @@ export class Attached {
    * a terminal in raw mode, and `GIT_TERMINAL_PROMPT=0` because a clone that
    * stops to ask for a password here would hang the screen with no prompt on
    * it: the credential helper may answer, a person cannot.
+   *
+   * ssh does not read that variable: a key with a passphrase is asked for on
+   * `/dev/tty` directly, over this screen, while the screen's own raw-mode
+   * reader takes half the keys. So ssh runs in BatchMode — a key the agent
+   * holds (or one with no passphrase) still works, and one that would have to
+   * ask fails at once and says how to make it not ask. A GIT_SSH_COMMAND the
+   * person set themselves is theirs and left alone.
    */
   cloneInto(gitUrl, path) {
     return new Promise((done, fail) => {
       const child = spawn('git', ['clone', '--progress', gitUrl, path], {
         stdio: ['ignore', 'pipe', 'pipe'],
-        env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+        env: {
+          ...process.env,
+          GIT_TERMINAL_PROMPT: '0',
+          GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND ?? 'ssh -o BatchMode=yes',
+        },
       });
+      let said = '';
       const print = (chunk) => {
+        said += chunk;
         for (const line of String(chunk).split(/\r?\n|\r/)) {
           if (line.trim()) this.say(`  ${this.ink.muted(line)}`);
         }
@@ -2392,14 +2724,25 @@ export class Attached {
       child.stdout.on('data', print);
       child.stderr.on('data', print);
       child.on('error', (failure) => fail(new Error(`Could not run git: ${failure.message}`)));
-      child.on('close', (code) => (code === 0 ? done() : fail(new Error(`git clone exited ${code}.`))));
+      child.on('close', (code) => {
+        if (code === 0) {
+          done();
+          return;
+        }
+        fail(new Error(`git clone exited ${code}.${sshNeedsAPerson(said)
+          ? ' ssh needed to ask you something — a key\'s passphrase, or whether to trust the host '
+            + '— and this screen cannot ask. Add the key to your agent once (macOS: `ssh-add '
+            + '--apple-use-keychain ~/.ssh/id_ed25519`) and try again, or run `cawdev config '
+            + 'add-project` from a shell, which can ask.'
+          : ''}`));
+      });
     });
   }
 
   // --- slash commands ---------------------------------------------------------
 
   async runCommand(text) {
-    const [word, ...rest] = text.slice(1).split(/\s+/);
+    const [word, ...rest] = commandWords(text.slice(1));
     switch (word) {
       case 'help':
         this.say('');
@@ -2435,6 +2778,40 @@ export class Attached {
       case 'log':
         this.showLog = !this.showLog;
         return this.note(this.showLog ? "printing the daemon's log" : 'printing the session');
+      case 'advanced-mode':
+      case 'advanced': {
+        const want = rest[0] === 'off' ? false : rest[0] === 'on' ? true : !this.split;
+        if (!want) return this.leaveSplit();
+        // `@slug` names the projects outright; otherwise they are asked.
+        const named = rest.filter((word) => word.startsWith('@')).map((word) => word.slice(1));
+        return named.length ? this.enterSplit(named) : this.askSplitProjects();
+      }
+      case 'projects':
+        return this.askSplitProjects();
+      case 'refresh':
+        return void this.refreshCards();
+      case 'new':
+        return void this.startNew(rest);
+      case 'card':
+        return void this.addCard(rest);
+      case 'agent':
+        return void this.chooseAgent(rest[0]);
+      case 'develop':
+        return void this.develop(rest);
+      case 'pr':
+        return void this.openPullRequest();
+      case 'continue':
+        return void this.carryOn();
+      case 'open':
+        return void this.openInBrowser();
+      case 'view':
+        return rest.length ? void this.viewCard(rest) : this.viewOnCawdev();
+      case 'drop':
+        return void this.dropCheckout();
+      case 'close':
+        return this.closeWindow();
+      case 'reload':
+        return void this.reload();
       case 'quit':
       case 'exit':
         return this.quit();
@@ -2452,6 +2829,9 @@ export class Attached {
    * the moment it is decided.
    */
   async signIn() {
+    if (this.split) {
+      this.leaveSplit();
+    }
     // Everything queued goes out first and the footer comes down, so what
     // `runSignIn` prints with `console.log` lands under the transcript rather
     // than through the middle of a live region nothing is going to erase.
@@ -2466,11 +2846,1301 @@ export class Attached {
     if (this.session.signedIn) {
       void this.watchInbox();
       void this.watchQuestions();
+      void this.findStopped();
+    }
+    this.dirty = true;
+    return undefined;
+  }
+
+  // --- advanced mode — split.mjs ----------------------------------------------
+
+  /**
+   * What this terminal knows of every session it has seen, after the daemon's
+   * list changed. A session that left the list has ENDED — the daemon forgets
+   * it there and then — and the platform is asked how, because what can be done
+   * next (develop the plan, open the pull request) is decided by that.
+   */
+  trackSessions() {
+    const live = new Set();
+    for (const run of this.runs) {
+      live.add(run.id);
+      const known = this.sessions.get(run.id);
+      if (known?.ended && this.lines.has(run.id)) {
+        // Back to life (a carry-on): what was said about how it stopped is
+        // over, and the new output is what the window is for.
+        this.lines.set(run.id, this.lines.get(run.id).filter((line) => !line.seed));
+      }
+      const meta = known ?? { id: run.id, view: null, prAsked: null };
+      Object.assign(meta, {
+        projectSlug: run.projectSlug,
+        label: run.label,
+        profile: run.profile ?? meta.profile ?? null,
+        state: run.state,
+        why: run.why ?? null,
+        // Where a live session is working — the daemon's word, and the one a
+        // window names (`subtitleFor`); kept once it ends, with the view's.
+        workspace: run.workspace ?? meta.workspace ?? null,
+        // Which CLI and model it runs on — per stage, so kept up to date.
+        // A daemon that sends the field is believed even when it is null (a
+        // stage asking for no model); an older one that sends nothing keeps
+        // what was known.
+        agent: run.agent !== undefined ? run.agent : meta.agent ?? null,
+        model: run.model !== undefined ? run.model : meta.model ?? null,
+        ended: false,
+        // A carried-on run the daemon has taken: the ask is answered.
+        carryAsked: false,
+      });
+      if (!known) {
+        this.sessions.set(run.id, meta);
+        void this.readView(meta);
+        // The development `d` started in place of a plan's window takes the
+        // focus that window had, so it reads as the plan's successor.
+        if (this.split && this.focusOnArrival === run.projectSlug && (run.profile ?? 'CODE') === 'CODE') {
+          this.focusOnArrival = null;
+          this.split.focus = run.id;
+        }
+      }
+      if (this.split) {
+        this.requestBacklogFor(run.id);
+      }
+    }
+    for (const meta of this.sessions.values()) {
+      if (!meta.ended && !live.has(meta.id)) {
+        meta.ended = true;
+        void this.readView(meta, 5);
+      }
+    }
+    if (this.split && !this.windows().some((meta) => meta.id === this.split.focus)) {
+      this.split.focus = this.windows()[0]?.id ?? null;
+    }
+  }
+
+  /**
+   * The platform's view of a session — its card, its kind, how it ended, its
+   * pull request. Needs a person's session; without one a window says what the
+   * daemon knows and no more.
+   *
+   * @param retries how many times to read again while the platform still says
+   *   the run is live: the daemon drops a run a moment before its last
+   *   transition lands, and an ended window saying "running" offers nothing.
+   */
+  async readView(meta, retries = 0) {
+    if (!this.session.signedIn) return;
+    try {
+      meta.view = await this.session.request(`/api/projects/${meta.projectSlug}/runs/${meta.id}`);
+      this.dirty = true;
+      await this.countCommits(meta);
+      this.sayWhyItFailed(meta);
+      if (meta.ended && meta.view?.live && retries > 0) {
+        const again = setTimeout(() => void this.readView(meta, retries - 1), 2000);
+        again.unref?.();
+      }
+    } catch {
+      // A window with the daemon's title is still a window.
+    }
+  }
+
+  /**
+   * A session that ended FAILED says why, in its own window — once. The
+   * reason is the run's summary on the platform (a refusal before anything
+   * was spawned — Codex on a machine that has not allowed everything — never
+   * reaches the daemon's live transcript), and a window reading "failed" and
+   * nothing else sent people to the console to find out what to do.
+   */
+  sayWhyItFailed(meta) {
+    const view = meta.view;
+    const failed = view?.state === 'FAILED';
+    // A dev session that finished having built nothing says why too — its
+    // summary is where the session explained stopping (R24: "the plan is
+    // incomplete"), and the window otherwise read as work done.
+    if (!meta.ended || meta.failureSaid || !(failed || builtNothing(meta)) || !view.exitSummary) return;
+    meta.failureSaid = true;
+    const kept = this.lines.get(meta.id) ?? [];
+    const said = kept.some((line) => line.body === view.exitSummary.split('\n')[0]);
+    if (said) return;
+    const lines = String(view.exitSummary).split('\n').map((body) => ({ kind: 'ERROR', body }));
+    this.lines.set(meta.id, [...kept, { kind: 'ERROR', body: failed ? 'failed:' : 'nothing built:' }, ...lines]);
+    this.dirty = true;
+  }
+
+  /**
+   * How many commits a finished dev session made — read once it has finished,
+   * so `builtNothing` can tell "finished" from "finished having built nothing".
+   * A read that fails leaves it unknown, and unknown claims nothing: the
+   * window reads "finished" as it always did.
+   *
+   * A ZERO is not believed at once. The runner's last reading of the commits
+   * lands AFTER the run is FINISHED — the agent ends its own run, and the
+   * runner pushes, opens the pull request and only then reports — so the
+   * first read of a run that committed twice and pushed can answer none. That
+   * zero, cached, told a Codex session with two commits on origin that
+   * "nothing was committed". A zero is read again `COMMIT_REREADS` times,
+   * `commitRereadMs` apart, and claimed only if it is still a zero after that.
+   */
+  async countCommits(meta, rereads = COMMIT_REREADS) {
+    const view = meta.view;
+    if (!meta.ended || meta.commits !== undefined || view?.state !== 'FINISHED'
+        || (view.profile ?? 'CODE') !== 'CODE') return;
+    if (rereads === COMMIT_REREADS && meta.countingCommits) return;
+    meta.countingCommits = true;
+    let count;
+    try {
+      const commits = await this.session.request(
+        `/api/projects/${meta.projectSlug}/runs/${meta.id}/commits`);
+      count = Array.isArray(commits) ? commits.length : undefined;
+    } catch {
+      // Unknown: nothing claimed.
+    }
+    if (count === 0 && rereads > 0) {
+      const again = setTimeout(async () => {
+        await this.countCommits(meta, rereads - 1);
+        this.sayWhyItFailed(meta);
+      }, this.options.commitRereadMs ?? 5_000);
+      again.unref?.();
+      return;
+    }
+    meta.countingCommits = false;
+    meta.commits = count;
+    this.dirty = true;
+  }
+
+  /**
+   * Which session a question or a request in the prompt comes from, by the
+   * number its window carries (the position in the run list outside
+   * advanced mode) — see split.mjs's `sessionTag`.
+   */
+  tagOf(run) {
+    if (!run) return '';
+    const meta = this.sessions.get(run.id) ?? run;
+    const n = this.split
+      ? this.windows().findIndex((each) => each.id === run.id) + 1
+      : this.runs.findIndex((each) => each.id === run.id) + 1;
+    return sessionTag(n, meta);
+  }
+
+  /** The sessions that get a window: every one seen, less those closed. */
+  windows() {
+    const only = this.split?.projects;
+    return [...this.sessions.values()].filter((meta) => !this.closed.has(meta.id)
+      && (!only || only.has(meta.projectSlug)));
+  }
+
+  /** The projects this machine serves that cawdev still has — see `gone`. */
+  servedProjects() {
+    return (this.runner?.projects ?? []).filter((slug) => !this.gone.has(slug));
+  }
+
+  /** The projects on screen: advanced mode's pick, else every one served here. */
+  shownProjects() {
+    const served = this.servedProjects();
+    return this.split?.projects ? served.filter((slug) => this.split.projects.has(slug)) : served;
+  }
+
+  /** The session a command like /pr is about: the focused window, else the one watched. */
+  commandTarget() {
+    if (this.split) {
+      return this.sessions.get(this.split.focus) ?? null;
+    }
+    return this.sessions.get(this.watching)
+      ?? [...this.sessions.values()].reverse().find((meta) => meta.ended) ?? null;
+  }
+
+  /** The backlog of any live session, once — a window needs its history too. */
+  requestBacklogFor(runId) {
+    if (!runId || this.asked.has(runId) || !this.connected
+        || !this.runs.some((run) => run.id === runId)) {
+      return;
+    }
+    this.asked.add(runId);
+    try {
+      this.client.write(`${JSON.stringify({ type: 'backlog', runId })}\n`);
+    } catch {
+      this.asked.delete(runId);
+    }
+  }
+
+  /**
+   * `/advanced-mode` on a machine serving several projects: which of them to
+   * show, ticked in a picker (all ticked to start with, so enter alone keeps
+   * today's behaviour). One project served: nothing to ask. `/projects` asks
+   * again from inside the mode.
+   */
+  async askSplitProjects() {
+    if (this.plain) return this.note('advanced mode needs a terminal it can draw on');
+    // Read first, so a project deleted in the console is not offered — and
+    // say so AFTER the mode is entered, or the sentence lands on the normal
+    // screen the alternate one is about to cover.
+    await this.refreshPlanned({ hold: true });
+    const served = this.servedProjects();
+    if (served.length <= 1) {
+      const entered = this.split ? this.note('this machine serves one project') : this.enterSplit(served);
+      this.sayGone();
+      return entered;
+    }
+    this.sayGone();
+    const current = this.split?.projects ? [...this.split.projects] : served;
+    return this.openPicker(new Select({
+      kind: 'split-projects',
+      title: 'which projects should advanced mode show?',
+      rows: served.map((slug) => ({ id: slug, label: slug })),
+      many: true,
+      picked: current,
+      // On what is shown now, so space alone takes it off.
+      at: Math.max(0, served.findIndex((slug) => current.includes(slug))),
+    }));
+  }
+
+  /**
+   * Never a prompt to a session of a project advanced mode is not showing: a
+   * watched session KNOWN to be in a hidden project hands over to the focused
+   * window. One not known yet (a reload, before the daemon has said hello) is
+   * left alone — it may well be in a project that is shown.
+   */
+  leaveHiddenWatch() {
+    const watched = this.sessions.get(this.watching);
+    const only = this.split?.projects;
+    if (watched && only && !only.has(watched.projectSlug) && this.split.focus) {
+      this.watching = this.split.focus;
+    }
+  }
+
+  /** Advanced mode, narrowed to `slugs` — its windows, its roadmap, its `/new`. */
+  focusProjects(slugs) {
+    if (!this.split) return this.enterSplit(slugs);
+    this.split.projects = new Set(slugs);
+    if (!this.windows().some((meta) => meta.id === this.split.focus)) {
+      this.split.focus = this.windows()[0]?.id ?? null;
+    }
+    this.leaveHiddenWatch();
+    this.say(this.ink.muted(`showing ${slugs.join(', ')} — /projects changes it`));
+    this.dirty = true;
+    return undefined;
+  }
+
+  enterSplit(projects = null) {
+    if (this.split) return this.note('already in advanced mode — /advanced-mode off to leave');
+    if (this.plain) return this.note('advanced mode needs a terminal it can draw on');
+    const shown = projects?.length ? new Set(projects) : null;
+    // The footer comes down first, so the normal screen is left as a clean
+    // scrollback for when this mode is left.
+    this.screen.update(this.pending, []);
+    this.pending = [];
+    const screen = new SplitScreen(this.options.out ?? process.stdout);
+    this.split = {
+      screen,
+      // The projects this mode shows; null is every one this machine serves.
+      projects: shown,
+      focus: null,
+      messages: [],
+      enteredWatching: this.watching,
+      mark: new Map([...this.lines].map(([id, lines]) => [id, lines.length])),
+    };
+    const watched = this.windows().find((meta) => meta.id === this.watching);
+    this.split.focus = watched?.id ?? this.windows()[0]?.id ?? null;
+    this.leaveHiddenWatch();
+    screen.enter();
+    for (const meta of this.windows()) {
+      this.requestBacklogFor(meta.id);
+    }
+    void this.refreshPlanned();
+    this.split.plannedTimer = setInterval(() => void this.refreshPlanned(), 30_000);
+    this.split.plannedTimer.unref?.();
+    this.say(this.ink.muted('advanced mode — tab moves between windows · /new starts a session'
+      + ' · /projects picks what is shown · /advanced-mode leaves'));
+    if (shown) {
+      this.say(this.ink.muted(`showing ${[...shown].join(', ')}`));
+    }
+    this.dirty = true;
+    return undefined;
+  }
+
+  /**
+   * Back to the scrollback, which is as it was left. What the watched session
+   * said meanwhile is laid into it now — or, if the focus moved, that
+   * session's history, which is what switching sessions has always done.
+   */
+  leaveSplit() {
+    if (!this.split) return this.note('advanced mode is not on — /advanced-mode starts it');
+    const { screen, enteredWatching, mark, plannedTimer } = this.split;
+    clearInterval(plannedTimer);
+    this.split = null;
+    screen.leave();
+    const watched = this.watching;
+    const lines = this.lines.get(watched) ?? [];
+    if (watched && watched === enteredWatching) {
+      for (const line of lines.slice(mark.get(watched) ?? lines.length)) {
+        this.say(this.render(line));
+      }
+    } else if (watched) {
+      this.printed.delete(watched);
+      this.layHistoryIn(watched, lines);
+    }
+    this.note('back to the scrollback');
+    return undefined;
+  }
+
+  /** The window the prompt talks to. A live one becomes the session watched. */
+  focusWindow(id) {
+    this.split.focus = id;
+    this.split.recent = [id, ...(this.split.recent ?? []).filter((each) => each !== id)];
+    if (this.runs.some((run) => run.id === id)) {
+      this.watching = id;
+    }
+    this.note('');
+  }
+
+  cycleFocus(step) {
+    const windows = this.windows();
+    if (!windows.length) return this.note('no session windows yet — /new starts one');
+    const at = windows.findIndex((meta) => meta.id === this.split.focus);
+    return this.focusWindow(windows[(at + step + windows.length) % windows.length].id);
+  }
+
+  /** The whole alternate screen, as rows — see split.mjs. */
+  splitFrame() {
+    const { width, height } = this.split.screen;
+    const ink = this.ink;
+    const windows = this.windows();
+    const inner = Math.max(8, width - 2);
+
+    const overlay = this.overlayLines(inner);
+    const current = this.current();
+    const pending = this.pendingOn(current);
+    const banner = this.select && this.select.kind !== 'runs' ? [] : pending
+      ? permissionBanner(pending, inner, ink, this.runner ?? {})
+      : questionBanner(this.askingOn(current), inner, ink, { entire: true });
+    // Which window a command or a prompt will act on, before it is sent.
+    const target = this.windowNumberOf(this.split.focus);
+    const tag = target ? ink.bold(ink.accent(`[${target}] `)) : '';
+    const input = this.mode === 'typing'
+      ? `${tag}${this.input.label} ${this.input.line.render(
+        Math.max(8, inner - visibleWidth(tag) - visibleWidth(this.input.label) - 1), ink)}`
+      : tag + ink.muted(`enter prompts ${current ? `“${current.label}”` : 'the focused session'}`
+        + ' · / commands · tab next window');
+    // A question or a request on screen says which window it came from.
+    const from = banner.length ? [ink.bold(ink.warn(` from ${this.tagOf(current)}`))] : [];
+    const fixed = [...from, ...banner, ...overlay, input];
+    const promptRows = Math.max(PROMPT_ROWS, fixed.length + 5);
+    // The roadmap across the top: as tall as its fullest column needs, never
+    // more than a third of the screen, and never so tall that no window fits
+    // under it — a short terminal drops it before it drops the sessions.
+    const stripRoom = Math.min(Math.max(4, Math.floor(height / 3)), height - promptRows - MIN_ZONE_HEIGHT);
+    // A rule under it, from the strip's own room: the roadmap is the board and
+    // the windows are the sessions, and without it the strip's last card line
+    // ran straight into the first window's border.
+    const stripLines = stripRoom >= 4
+      ? [...roadmapStrip(width, stripRoom - 1, this.cards, ink, this.shownProjects()),
+        ink.muted('─'.repeat(width))]
+      : [];
+    const strip = stripLines.length <= Math.max(0, stripRoom) ? stripLines.length : 0;
+    // Four windows at most; the rest are named on one line above the prompt,
+    // and Tab onto one of them brings it up in place of the least recent.
+    const shown = visibleSessions(windows, this.split.recent ?? [], this.split.focus);
+    const hidden = windows.filter((meta) => !shown.includes(meta));
+    const tabs = hidden.length ? 1 : 0;
+    const layout = splitLayout(width, height - strip - tabs, shown.length, promptRows);
+    for (const rect of layout.zones) {
+      rect.top += strip;
+    }
+    layout.prompt.top += strip + tabs;
+
+    const pieces = layout.zones.map((rect, i) => {
+      const meta = shown[i];
+      const n = windows.indexOf(meta) + 1;
+      const asking = this.askingOn(this.runs.find((run) => run.id === meta.id));
+      const waiting = this.pendingOn(this.runs.find((run) => run.id === meta.id))
+        ? 'waiting for permission'
+        : asking ? 'waiting for an answer' : null;
+      const lines = (this.lines.get(meta.id) ?? []).map((line) => this.render(line));
+      const body = lines.length ? lines : [ink.muted(meta.state === 'queued'
+        ? `  waiting — ${meta.why ?? 'no reason recorded'}`
+        : meta.ended ? '  nothing was said on this session here' : '  nothing said yet')];
+      return {
+        rect,
+        lines: windowLines(rect, {
+          title: `${n} ${titleFor(meta, waiting)}`,
+          // The agent and its model first, bold and underlined — which CLI and
+          // which model is what somebody comparing two windows looks for.
+          subtitle: (() => {
+            const who = agentModelFor(meta);
+            const lead = who ? `${ink.strong(who)} ` : '';
+            return lead + ink.muted(subtitleFor(meta, rect.width - 4 - (who ? who.length + 1 : 0)));
+          })(),
+          body,
+          footer: actionsFor(meta),
+          focused: meta.id === this.split.focus,
+          dotted: meta.id !== this.split.focus,
+          tone: toneFor(meta),
+        }, ink),
+      };
+    });
+
+    if (tabs) {
+      pieces.push({
+        rect: { top: layout.prompt.top - 1, left: 0, width, height: 1 },
+        lines: [tabsLine(hidden.map((meta) => ({ n: windows.indexOf(meta) + 1, meta })), width, ink)],
+      });
+    }
+    const unseen = layout.hidden ? ` · ${layout.hidden} more not shown` : '';
+    // A question's lines leave with the question — see `sayAbout`.
+    const open = this.stillOpen();
+    this.split.messages = this.split.messages
+      .filter((line) => typeof line === 'string' || open.has(line.about));
+    const messages = this.split.messages.flatMap((line) => {
+      if (typeof line === 'string') return [line];
+      if (line.body === undefined) return [line.text];
+      return wordWrap(line.body, inner - 2 - line.prefix.length).map((part) => `${line.prefix}${line.paint(part)}`);
+    });
+    const promptTitle = `cawdev ▸ ${this.runner?.name ?? 'runner'}`
+      + `${this.session.email ? ` · ${this.session.email}` : ' · not signed in'}`
+      + `${this.agent ? ` · ${this.agent}` : ''}${unseen}`;
+    pieces.push({
+      rect: layout.prompt,
+      lines: windowLines(layout.prompt, {
+        title: promptTitle,
+        // The input line sits on the bottom row, the way a prompt does:
+        // messages fill from above it, and blank rows pad a short log.
+        body: [
+          ...new Array(Math.max(0, layout.prompt.height - 3 - messages.length - fixed.length))
+            .fill(''),
+          ...messages,
+          ...fixed,
+        ],
+        footer: this.status
+          ? ink.warn(`${this.statusWindow ? `[${this.statusWindow}] ` : ''}${this.status}`)
+          : keyList(this.keys(), '', inner, ink),
+      }, ink),
+    });
+    if (strip) {
+      pieces.push({
+        rect: { top: 0, left: 0, width, height: strip },
+        lines: stripLines,
+      });
+    }
+    return composeFrame(width, height, pieces);
+  }
+
+  /**
+   * Every card of every project this machine serves, whatever its status —
+   * the strip draws them all, and `d` offers the PLANNED ones. One request
+   * per project, the board's own (`brief`, so no bodies). Needs a person's
+   * session, like everything read off the roadmap here.
+   *
+   * A project that cannot be read keeps ITS last cards and no other's: this
+   * used to give up on the first failure and keep the whole last list, so one
+   * served slug the session could not reach left every column at 0 — a strip
+   * saying "nothing considered" about a board full of ideas, and saying it
+   * silently. What failed is returned so `/refresh` can say it.
+   */
+  async refreshPlanned({ hold = false } = {}) {
+    if (!this.session.signedIn) return { signedIn: false, read: [], failed: [] };
+    const read = [];
+    const failed = [];
+    const all = [];
+    for (const slug of this.runner?.projects ?? []) {
+      try {
+        const cards = await this.session.request(`/api/projects/${slug}/roadmap?brief=true`);
+        for (const card of Array.isArray(cards) ? cards : []) {
+          all.push({ ref: card.ref, title: card.title, slug, status: card.status, live: Boolean(card.activeRun) });
+        }
+        read.push(slug);
+        this.gone.delete(slug);
+      } catch (failure) {
+        if (failure?.status === 404) {
+          this.forgetGone(slug);
+          continue;
+        }
+        failed.push({ slug, message: failure?.message ?? String(failure) });
+        all.push(...this.cards.filter((card) => card.slug === slug));
+      }
+    }
+    this.cards = all;
+    this.planned = all.filter((card) => card.status === 'PLANNED');
+    this.dirty = true;
+    if (!hold) this.sayGone();
+    return { signedIn: true, read, failed };
+  }
+
+  /** A served project cawdev answered 404 for: hidden, and said once. */
+  forgetGone(slug) {
+    if (this.gone.has(slug)) return;
+    this.gone.add(slug);
+    this.goneUnsaid.push(slug);
+  }
+
+  /** What `forgetGone` learnt, said where it will be read. */
+  sayGone() {
+    for (const slug of this.goneUnsaid.splice(0)) {
+      this.say(this.ink.warn(`  this machine serves ${slug}, but cawdev has no such project for you any more`
+        + ' — deleted, or your access went. It is hidden here;'
+        + ` c → Stop serving ${slug} takes it off this machine.`));
+    }
+  }
+
+  /**
+   * `/refresh`: the cards and their statuses read again now, rather than on
+   * the strip's thirty-second timer — somebody who just moved a card in the
+   * console should not have to wait for the terminal to believe it. Says what
+   * it read per project shown, and which could not be read and why.
+   */
+  async refreshCards() {
+    if (!this.requireSignIn('read the roadmap')) return;
+    const { read, failed } = await this.refreshPlanned();
+    const shown = new Set(this.shownProjects());
+    const counts = read.filter((slug) => shown.has(slug)).map((slug) => {
+      const mine = this.cards.filter((card) => card.slug === slug);
+      const tally = BOARD_COLUMNS
+        .map(([status, label]) => `${mine.filter((card) => card.status === status).length} ${label.toLowerCase()}`)
+        .join(' · ');
+      return `${slug}: ${tally}`;
+    });
+    for (const { slug, message } of failed) {
+      this.say(this.ink.danger(`  could not read the roadmap of ${slug}: ${message}`));
+    }
+    if (!read.length && !failed.length) {
+      return this.note('refreshed — this machine serves no project yet');
+    }
+    this.note(failed.length && !counts.length
+      ? `refresh failed for ${failed.map((each) => each.slug).join(', ')}`
+      : `refreshed — ${counts.join('; ')}${failed.length ? ` (${failed.length} could not be read)` : ''}`);
+  }
+
+  /**
+   * `d`, or `/new dev` with nothing after it: the planned cards as a list, and
+   * the one picked is developed — `/new dev R3 @slug`, on this machine.
+   */
+  async pickPlanned(slug = null) {
+    if (!this.requireSignIn('start a session')) return;
+    await this.refreshPlanned();
+    const cards = this.planned.filter((card) => !slug || card.slug === slug);
+    if (!cards.length) {
+      this.note(slug ? `nothing planned in ${slug}` : 'nothing planned — /new dev <the task in words> starts one anyway');
+      return;
+    }
+    const several = new Set(cards.map((card) => card.slug)).size > 1;
+    this.openPicker(new Select({
+      kind: 'planned',
+      title: 'develop which planned card?',
+      rows: cards.map((card) => ({
+        id: `${card.slug} ${card.ref}`,
+        label: `${card.ref} ${card.title}`,
+        ...(several ? { hint: card.slug } : {}),
+      })),
+    }));
+  }
+
+  /** `/new plan|dev R3` · `/new plan|dev <the task in words>` · `/new ask …` — on this machine. */
+  async startNew(words) {
+    if (!this.requireSignIn('start a session')) return;
+    // Advanced mode narrowed to ONE project: that is the project. Asking would
+    // be asking somebody to repeat the choice they made on entering — this is
+    // not the guess the question exists to prevent (a machine serving one
+    // project, or the focused window), it is a choice already stated.
+    const shown = this.split?.projects ? this.shownProjects() : [];
+    if (shown.length === 1 && !words.some((word) => word.startsWith('@'))) {
+      words = [...words, `@${shown[0]}`];
+    }
+    const bare = words.filter((word) => word && !word.startsWith('@') && word !== '--anyway');
+    if (bare.length === 1 && ['dev', 'code'].includes(bare[0].toLowerCase())) {
+      const named = words.find((word) => word.startsWith('@'));
+      await this.pickPlanned(named ? named.slice(1) : null);
+      return;
+    }
+    const anyway = words.includes('--anyway');
+    // `--codex`, `--claude`, `--agy`: this session's agent, over `/agent`'s.
+    const flagged = words.find((word) => AGENT_FLAGS.has(word));
+    let agent = flagged ? flagged.slice(2) : this.agent;
+    const parsed = parseNew(words.filter((word) => word !== '--anyway' && !AGENT_FLAGS.has(word)), {
+      // In advanced mode, among the projects it shows.
+      projects: this.shownProjects(),
+    });
+    if (parsed.needsProject) {
+      // Several projects here and nothing says which: ASK, from the list of
+      // what this machine serves, and run the same command again with the
+      // one picked. A sentence telling somebody to retype it with @slug is a
+      // question the terminal could have asked itself.
+      this.openPicker(new Select({
+        kind: 'project',
+        title: `which project is this ${words.find((word) => !word.startsWith('@')) ?? 'session'} for?`,
+        rows: parsed.projects.map((slug) => ({ id: slug, label: slug })),
+      }));
+      this.newWaitingForProject = words;
+      return;
+    }
+    if (parsed.error) {
+      this.note(parsed.error);
+      return;
+    }
+    if (parsed.kind === 'dev' && !parsed.ref) {
+      // A dev from words writes its CARD first, then develops it exactly as
+      // `/new dev R12` would. It used to be a manual session on a `task-…`
+      // branch with no card: no number, nothing on the development board,
+      // and a prompt that never said "commit" — so the work ended
+      // uncommitted and `/pr` had nothing to propose.
+      await this.developNewCard(parsed.slug, parsed.text, anyway, agent);
+      return;
+    }
+    // Developing a card whose finished plan has a window here: the agent that
+    // planned it develops it unless one was named on the line — it has read
+    // the code once already, and swapping CLIs between the two halves of one
+    // card was a choice nobody made — and the plan's window gives way to the
+    // development's once it has started.
+    const plan = parsed.kind === 'dev' && parsed.ref ? this.planWindowFor(parsed.slug, parsed.ref) : null;
+    const planAgent = plan ? plan.agent ?? plan.view?.agent ?? null : null;
+    if (!flagged && planAgent) {
+      agent = planAgent;
+    }
+    const [path, body, what] = parsed.kind === 'ask'
+      ? ['runs/ask', { prompt: parsed.text }, 'a question']
+      : parsed.kind === 'plan'
+        ? parsed.ref
+          ? ['runs/plan', { entryNumber: parsed.ref }, `a plan of ${parsed.ref}`]
+          // R150: the session writes the card first, then plans it.
+          : ['runs/plan', { prompt: parsed.text }, 'a plan — it writes its card first']
+        : ['runs', { entryNumber: parsed.ref }, `the development of ${parsed.ref}`];
+    const started = await this.startSession(parsed.slug, path, withAgent(body, agent), withWho(what, agent), anyway);
+    if (started && plan) {
+      this.closeWindowOf(plan);
+      this.focusOnArrival = plan.projectSlug;
+    }
+  }
+
+  /** A FINISHED plan on a card, ended here — what `d` and `/develop` develop. */
+  finishedPlan(meta) {
+    return Boolean(meta?.ended && meta.view?.state === 'FINISHED'
+      && meta.view.profile === 'PLAN' && meta.view.entryRef);
+  }
+
+  /** The open window of a finished plan of `ref` in `slug`, if there is one. */
+  planWindowFor(slug, ref) {
+    return [...this.sessions.values()].reverse().find((meta) => !this.closed.has(meta.id)
+      && meta.projectSlug === slug && this.finishedPlan(meta)
+      && meta.view.entryRef.toLowerCase() === String(ref).toLowerCase()) ?? null;
+  }
+
+  /**
+   * `/agent` — which CLI `/new` asks for when a command names none. Kept
+   * across launches (prefs.mjs). `default` goes back to the project's own
+   * choice. A `--codex` on one `/new` still wins over it.
+   */
+  async chooseAgent(name) {
+    if (!name) {
+      return this.note(this.agent
+        ? `/new uses ${this.agent} — /agent default goes back to the project's choice`
+        : "/new uses the project's default agent — /agent claude|codex|agy picks one here");
+    }
+    const wanted = name.toLowerCase();
+    if (['default', 'auto', 'none', 'project'].includes(wanted)) {
+      this.agent = null;
+      await savePrefs(this.session.url, { agent: null }).catch(() => undefined);
+      this.dirty = true;
+      return this.note("/new uses the project's default agent again");
+    }
+    if (!KNOWN_AGENTS.includes(wanted)) {
+      return this.note(`no agent called ${name} — ${KNOWN_AGENTS.join(', ')}`);
     }
+    this.agent = wanted;
+    await savePrefs(this.session.url, { agent: wanted }).catch(() => undefined);
     this.dirty = true;
+    // Said, not refused: the platform may send the run to another machine,
+    // and this one can be told to spawn it (`c` → Enable) in a second.
+    const here = (this.runner?.agents ?? []).map((command) => agentOfCommand(command));
+    return this.note(this.runner?.agents && !here.includes(wanted)
+      ? `/new uses ${wanted} — but this machine does not spawn it: c → Enable ${wanted}`
+      : `/new uses ${wanted}`);
+  }
+
+  /**
+   * `/card <the idea in words>` — a card in CONSIDERING, and nothing else: no
+   * session, no branch, nothing spent. The roadmap's first column is where an
+   * idea waits to be decided on, and writing one down should not need a model
+   * to do it. The project is chosen as `/new` chooses it: `@slug`, else
+   * advanced mode narrowed to one, else asked — never guessed.
+   */
+  async addCard(words) {
+    if (!this.requireSignIn('write a card')) return;
+    const named = words.find((word) => word.startsWith('@'))?.slice(1) ?? null;
+    const text = wordsText(words.filter((word) => word && !word.startsWith('@')));
+    if (!text) {
+      this.note('/card what? — /card <the idea in words> (@project)');
+      return;
+    }
+    const served = this.servedProjects();
+    const shown = this.shownProjects();
+    const slug = named ?? (this.split?.projects && shown.length === 1 ? shown[0] : null);
+    if (named && !served.includes(named)) {
+      this.note(`this machine does not serve ${named} — ${served.join(', ') || 'no project'}`);
+      return;
+    }
+    if (!slug) {
+      if (!shown.length) {
+        this.note('this machine serves no project to write a card in');
+        return;
+      }
+      this.openPicker(new Select({
+        kind: 'card-project',
+        title: 'which project is this card for?',
+        rows: shown.map((each) => ({ id: each, label: each })),
+      }));
+      this.cardWaitingForProject = words;
+      return;
+    }
+    let card;
+    try {
+      card = await this.session.request(`/api/projects/${slug}/roadmap`, {
+        method: 'POST',
+        body: { title: cardTitleFor(text), body: text, status: 'CONSIDERING' },
+      });
+    } catch (failure) {
+      this.note(`could not write the card: ${failure.message}`);
+      return;
+    }
+    const ref = card?.ref ?? (card?.number ? `R${card.number}` : 'the card');
+    this.say(this.ink.success(`  wrote ${ref} ${card?.title ?? cardTitleFor(text)} in Considering on ${slug}`));
+    this.note('');
+    void this.refreshPlanned();
+  }
+
+  /**
+   * `/new dev <the task in words>`: the card, then its development. Two
+   * requests, and the first is said on its own line — a card that was written
+   * but whose run was refused (a usage window, say) is still on the board,
+   * and the person should know which half happened.
+   */
+  async developNewCard(slug, text, anyway, agent = this.agent) {
+    let card;
+    try {
+      card = await this.session.request(`/api/projects/${slug}/roadmap`, {
+        method: 'POST',
+        body: { title: cardTitleFor(text), body: text },
+      });
+    } catch (failure) {
+      this.note(`could not write the card: ${failure.message}`);
+      return;
+    }
+    const ref = card?.ref ?? (card?.number ? `R${card.number}` : null);
+    if (!ref) {
+      this.note('the card was written but the platform did not say its number — start it from the board');
+      return;
+    }
+    this.say(this.ink.success(`  wrote ${ref} ${card.title ?? ''} on ${slug}`));
+    await this.startSession(slug, 'runs', withAgent({ entryNumber: ref }, agent),
+      withWho(`the development of ${ref}`, agent), anyway);
+    void this.refreshPlanned();
+  }
+
+  /**
+   * The sessions that stopped before this terminal saw them and can be picked
+   * back up HERE — a failed run holding its checkout on this machine above
+   * all. The daemon forgets a run as it ends, so after a restart nothing on
+   * this side knew it existed and only the console could carry it on. Each
+   * gets a window like any session that ended while watched, and the window
+   * offers `/carry-on`.
+   *
+   * The first page of each served project's runs, which carries every run not
+   * over plus the fifty newest that are — a failed run older than that is on
+   * the console's Sessions page, and a terminal that paged through a
+   * project's whole history on every attach would be slow for everybody to
+   * find one that rarely exists. Once per attach and once per sign-in.
+   */
+  async findStopped() {
+    if (!this.session.signedIn || !this.runner?.id) return;
+    const found = [];
+    for (const slug of this.runner.projects ?? []) {
+      const page = await this.session.request(`/api/projects/${slug}/runs?limit=50`)
+        .catch(() => []);
+      for (const view of Array.isArray(page) ? page : []) {
+        if (this.sessions.has(view.id) || this.closed.has(view.id)
+            || this.runs.some((run) => run.id === view.id)
+            || !carriesOnHere(view, this.runner.id, this.session.email)) {
+          continue;
+        }
+        const meta = {
+          id: view.id, projectSlug: slug, label: view.label, profile: view.profile,
+          state: view.state, ended: true, view, prAsked: null,
+        };
+        this.sessions.set(view.id, meta);
+        // Its window has no transcript to show — the daemon never streamed it
+        // to this terminal — so it opens on why it stopped.
+        if (!this.lines.has(view.id)) {
+          const why = view.exitSummary ?? view.failureReason ?? `${String(view.state).toLowerCase()}`;
+          // `seed`: it stands for a transcript this terminal never had, and
+          // leaves when the session comes back (`trackSessions`) — above live
+          // output it reads as the session failing again.
+          this.lines.set(view.id, [{ kind: 'ERROR', body: `stopped: ${why}`, seed: true }]);
+        }
+        found.push(meta);
+      }
+    }
+    if (!found.length) return;
+    this.say(this.ink.warn(`  ${found.length} session(s) stopped here and can be carried on:`));
+    for (const meta of found) {
+      this.say(`    ${meta.projectSlug} · ${String(meta.state).toLowerCase()} · ${meta.label ?? meta.id}`);
+    }
+    this.say(this.ink.muted(this.split
+      ? '  focus its window and type /continue'
+      : '  /continue picks up the latest — /advanced-mode gives each one a window'));
+    this.dirty = true;
+  }
+
+  /**
+   * `/carry-on` — the console's Carry on, for the focused (or last ended)
+   * session, on THIS machine: a failed run's checkout is here, and it resumes
+   * where its work is or nowhere. The platform re-queues the same run; its
+   * window comes back to life when the daemon claims it.
+   */
+  async carryOn() {
+    if (!this.requireSignIn('carry a session on')) return;
+    const meta = this.commandTarget();
+    const view = meta?.view;
+    if (!meta || !view) {
+      this.note('/continue needs a session that stopped — focus its window');
+      return;
+    }
+    if (!meta.ended) {
+      this.note(`${view.label ?? 'that session'} is still going — say something to it instead`);
+      return;
+    }
+    if (!view.canCarryOn) {
+      this.note(`that session is ${String(view.state ?? 'over').toLowerCase()} and cannot be carried on`);
+      return;
+    }
+    if (!this.runner?.id) {
+      this.note('this machine has not said which runner it is yet — try again in a moment');
+      return;
+    }
+    try {
+      meta.view = await this.session.request(
+        `/api/projects/${meta.projectSlug}/runs/${meta.id}/carry-on`,
+        { method: 'POST', body: { runnerId: this.runner.id } });
+      meta.carryAsked = true;
+      this.say(this.ink.success(`  carrying on ${view.label ?? meta.id} — its window comes back when this machine takes it`));
+      this.note('');
+    } catch (failure) {
+      this.note(failure.message);
+    }
+  }
+
+  /**
+   * `/develop` — start the development of a card on this machine: the card a
+   * finished plan was about (the focused session's), or the one named —
+   * `/develop R30`, `@slug` for its project. It is `/new dev R30` said from a
+   * plan's window, and it goes THROUGH `startNew` so the agent is chosen the
+   * same way: `--codex`/`--claude`/`--agy`, else `/agent`'s. It used to ignore
+   * every word after it, so `/develop R30 --codex` started the focused plan's
+   * card with the runner's default agent — Claude — and said nothing.
+   * Words that are none of those (`starts`, from the window's own hint) are
+   * passed over.
+   */
+  async develop(words = []) {
+    if (!this.requireSignIn('start a session')) return;
+    const flags = words.filter((word) => word.startsWith('--'));
+    const named = words.find((word) => word.startsWith('@'));
+    const typed = words.find((word) => /^r?\d+$/i.test(word));
+    if (typed) {
+      const ref = typed.replace(/^r/i, 'R').replace(/^(\d)/, 'R$1');
+      const slug = named?.slice(1) ?? this.commandTarget()?.projectSlug;
+      await this.startNew(['dev', ref, ...(slug ? [`@${slug}`] : []), ...flags]);
+      return;
+    }
+    const meta = this.commandTarget();
+    const ref = meta?.view?.entryRef;
+    if (!meta || !ref) {
+      this.note('/develop needs a session on a card — focus a finished plan, or name one: /develop R30');
+      return;
+    }
+    if (!meta.ended) {
+      this.note(`${ref} is still being worked on — wait for it to end`);
+      return;
+    }
+    await this.startNew(['dev', ref, `@${meta.projectSlug}`, ...flags]);
+  }
+
+  /**
+   * One POST that starts a session, aimed at THIS machine so its window opens
+   * here. A usage window over the machine's threshold is refused by the
+   * platform in a sentence; `--anyway` is the same decision the console's
+   * panel asks for.
+   */
+  async startSession(slug, path, body, what, anyway) {
+    try {
+      await this.session.request(`/api/projects/${slug}/${path}`, {
+        method: 'POST',
+        body: {
+          ...body,
+          ...(this.runner?.id ? { targetRunnerId: this.runner.id } : {}),
+          ...(anyway ? { acknowledgeUsage: true } : {}),
+        },
+      });
+      this.say(this.ink.success(`  started ${what} on ${slug} — its window opens when this machine takes it`));
+      this.note('');
+      return true;
+    } catch (failure) {
+      this.note(/usage|window/i.test(failure.message)
+        ? `${failure.message} — add --anyway to start it regardless`
+        : failure.message);
+      return false;
+    }
+  }
+
+  /**
+   * `/pr` — the pull request of a finished session's branch. The machine pushes and runs `gh`, so the answer comes
+   * back later: the window says it was asked for, and shows the URL when the
+   * run carries one.
+   */
+  async openPullRequest() {
+    if (!this.requireSignIn('open a pull request')) return;
+    const meta = this.commandTarget();
+    const view = meta?.view;
+    if (!meta || !view?.branch) {
+      this.note('/pr needs a session that wrote a branch — focus one');
+      return;
+    }
+    if (!meta.ended) {
+      this.note(`${view.branch} is still being written — wait for the session to end`);
+      return;
+    }
+    if (isPullRequest(view.prUrl)) {
+      this.note(`${view.branch} already has one: ${view.prUrl}`);
+      return;
+    }
+    try {
+      // Through the RUN: a card's run goes to its work item on the platform,
+      // and a session started from a sentence — which has none — is proposed
+      // from the run itself.
+      const asked = await this.session.request(
+        `/api/projects/${meta.projectSlug}/runs/${meta.id}/pull-request`, { method: 'POST' });
+      meta.prAsked = true;
+      this.say(this.ink.success(`  asked this machine to open the pull request for ${view.branch}`));
+      this.note('');
+      // The answer is the REQUEST the machine was handed, and its result is
+      // the URL or the reason there is none. A platform older than that
+      // answers with the run, and only the run's prUrl can be watched.
+      void (asked?.id && asked?.runnerId && asked?.kind === 'OPEN_PR'
+        ? this.followPullRequest(meta, asked, 60)
+        : this.awaitPullRequest(meta, 60));
+    } catch (failure) {
+      this.note(failure.message);
+    }
+  }
+
+  /**
+   * Reads the machine's answer to `/pr` until there is one: the URL, which
+   * the daemon checked the host for before saying so — or why not, in the
+   * daemon's words (gh missing or signed out, a push refused). Before this the
+   * terminal watched the run's prUrl, which a failure never writes, and said
+   * "pull request asked for…" for as long as the window was open.
+   */
+  async followPullRequest(meta, request, tries) {
+    const read = await this.session.request(
+      `/api/runners/${request.runnerId}/workspace-requests/${request.id}`).catch(() => null);
+    const state = read?.state;
+    if (state === 'DONE') {
+      const url = String(read.result ?? '').split('\n')[0].trim();
+      if (isPullRequest(url)) {
+        meta.prAsked = null;
+        meta.view = { ...(meta.view ?? {}), prUrl: url };
+        this.dirty = true;
+        this.say(this.ink.success(`  pull request: ${url}`));
+        return;
+      }
+    }
+    if (state === 'FAILED' || state === 'DONE') {
+      const why = String(read.result ?? 'the machine did not say why').trim();
+      meta.prAsked = `no pull request — ${why.split('\n')[0]}`;
+      this.dirty = true;
+      this.say(this.ink.danger(`  no pull request for ${meta.view?.branch ?? 'this branch'}:`));
+      for (const line of why.split('\n')) this.say(this.ink.danger(`    ${line}`));
+      return;
+    }
+    if (tries <= 0) {
+      meta.prAsked = 'no answer from the machine yet — is its daemon running?';
+      this.dirty = true;
+      return;
+    }
+    const again = setTimeout(() => void this.followPullRequest(meta, request, tries - 1), 2000);
+    again.unref?.();
+  }
+
+  /** Reads the run until its pull request shows, or gives up and says so. */
+  async awaitPullRequest(meta, tries) {
+    await this.readView(meta);
+    if (isPullRequest(meta.view?.prUrl)) {
+      meta.prAsked = null;
+      this.say(this.ink.success(`  pull request: ${meta.view.prUrl}`));
+      return;
+    }
+    if (tries <= 0) {
+      meta.prAsked = 'no pull request yet — the board says why';
+      this.dirty = true;
+      return;
+    }
+    const again = setTimeout(() => void this.awaitPullRequest(meta, tries - 1), 3000);
+    again.unref?.();
+  }
+
+  /**
+   * `/open` — the session's pull request, in the browser. A finished plan has
+   * none: what it produced is the card's plan of record, so `/open` there is
+   * the card on cawdev, opened on its plan (`?show=plan`).
+   */
+  async openInBrowser() {
+    const meta = this.commandTarget();
+    if (!meta) {
+      return this.note('/open needs a session — focus one');
+    }
+    if (this.finishedPlan(meta)) {
+      const ref = meta.view.entryRef;
+      const board = /^i/i.test(ref) ? 'issues' : 'roadmap';
+      const url = this.consoleUrl(meta.projectSlug ?? meta.view?.projectSlug, `${board}/${ref}?show=plan`);
+      if (!url) {
+        return this.note('cannot tell where this card is on cawdev');
+      }
+      this.openLink(url);
+      return this.note(`opened ${url}`);
+    }
+    // Read again, not the view taken when the session ended: the runner opens
+    // the pull request and records its link AFTER the run is FINISHED, so the
+    // copy read at that moment had none — and /open said "no pull request"
+    // about a branch with one open on GitHub.
+    await this.readView(meta);
+    let url = meta.view?.prUrl;
+    // A staged run's pull request can be the card's, through its work item
+    // (i168) — the branch's, whichever run opened it.
+    const ref = meta.view?.entryRef;
+    if (!isPullRequest(url) && ref && this.session.signedIn) {
+      const card = await this.session.request(`/api/projects/${meta.projectSlug}/roadmap/${ref}`)
+        .catch(() => null);
+      url = card?.workItem?.prUrl ?? card?.review?.prUrl ?? url;
+    }
+    if (!isPullRequest(url)) {
+      return this.note('no pull request on this session yet — /pr opens one');
+    }
+    this.openLink(url);
+    return this.note(`opened ${url}`);
+  }
+
+  /** A link, in this machine's browser. */
+  openLink(url) {
+    const opener = this.options.openUrl ?? ((link) => {
+      const command = process.platform === 'darwin' ? 'open'
+        : process.platform === 'win32' ? 'explorer' : 'xdg-open';
+      spawn(command, [link], { stdio: 'ignore', detached: true }).on('error', () => undefined).unref();
+    });
+    opener(url);
+  }
+
+  /**
+   * `/view` alone — the focused session's page on cawdev (its transcript,
+   * stages, card and checkout). On the console this terminal signed in to:
+   * the sign-in URL is the console's, where the daemon's may be the API
+   * behind it.
+   */
+  viewOnCawdev() {
+    const meta = this.commandTarget();
+    if (!meta) {
+      return this.note('/view needs a session — focus one, or name a card: /view R29');
+    }
+    const url = this.consoleUrl(meta.projectSlug ?? meta.view?.projectSlug, `runs/${meta.id}`);
+    if (!url) {
+      return this.note('cannot tell where this session is on cawdev');
+    }
+    this.openLink(url);
+    return this.note(`opened ${url}`);
+  }
+
+  /** A page of a project on the console this terminal signed in to, or null. */
+  consoleUrl(slug, path) {
+    const base = String(this.session.url ?? '').replace(/\/+$/, '');
+    return base && slug ? `${base}/projects/${slug}/${path}` : null;
+  }
+
+  /**
+   * `/view R29` · `/view i12` · `/view <words of its title>` · `/view card`
+   * — a card printed here, rather than a browser opened on it: somebody at
+   * this terminal wants to read what a card says without leaving it. `card`
+   * is the focused session's own. `@slug` names the project; otherwise every
+   * project on screen is looked in, and a ref or words matching cards in
+   * several are offered as a list rather than guessed between.
+   */
+  async viewCard(words) {
+    if (!this.requireSignIn('read a card')) return;
+    const named = words.filter((word) => word.startsWith('@')).map((word) => word.slice(1));
+    const bare = words.filter((word) => word && !word.startsWith('@'));
+    if (bare.length === 1 && bare[0].toLowerCase() === 'card') {
+      const meta = this.commandTarget();
+      const ref = meta?.view?.entryRef;
+      if (!ref) {
+        return this.note(meta ? 'this session has no card — /view R29 names one' : '/view card needs a session — focus one');
+      }
+      return this.showCard(meta.projectSlug, ref);
+    }
+    const projects = named.length ? named
+      : this.shownProjects().length ? this.shownProjects() : this.servedProjects();
+    if (!projects.length) {
+      return this.note('no project here to look in — name one: /view R29 @slug');
+    }
+    const asRef = bare.length === 1 && /^[ri]?\d+$/i.test(bare[0]) ? refOf(bare[0]) : null;
+    let found;
+    if (asRef) {
+      const reads = await Promise.all(projects.map((slug) => this.session
+        .request(`/api/projects/${slug}/roadmap/${asRef}`)
+        .then((card) => (card ? { slug, ref: card.ref ?? asRef, title: card.title } : null))
+        .catch(() => null)));
+      found = reads.filter(Boolean);
+      if (!found.length) {
+        return this.note(`no ${asRef} in ${projects.join(', ')}`);
+      }
+    } else {
+      const wanted = bare.map((word) => word.toLowerCase());
+      if (!wanted.length) {
+        return this.note('/view which card? /view R29, or words of its title');
+      }
+      await this.refreshPlanned();
+      found = this.cards.filter((card) => projects.includes(card.slug)
+        && wanted.every((word) => String(card.title ?? '').toLowerCase().includes(word)));
+      if (!found.length) {
+        return this.note(`no card titled like "${bare.join(' ')}" in ${projects.join(', ')}`);
+      }
+    }
+    if (found.length === 1) {
+      return this.showCard(found[0].slug, found[0].ref);
+    }
+    const several = new Set(found.map((card) => card.slug)).size > 1;
+    this.openPicker(new Select({
+      kind: 'view-card',
+      title: 'view which card?',
+      rows: found.map((card) => ({
+        id: `${card.slug} ${card.ref}`,
+        label: `${card.ref} ${card.title ?? ''}`.trim(),
+        ...(several ? { hint: card.slug } : {}),
+      })),
+    }));
     return undefined;
   }
 
+  /** One card, read fresh off the platform and printed into the transcript. */
+  async showCard(slug, ref) {
+    let card;
+    try {
+      card = await this.session.request(`/api/projects/${slug}/roadmap/${ref}`);
+    } catch (failure) {
+      return this.note(`could not read ${ref} on ${slug}: ${failure.message}`);
+    }
+    if (!card) {
+      return this.note(`no ${ref} on ${slug}`);
+    }
+    const url = this.consoleUrl(slug, `roadmap/${card.ref ?? ref}`);
+    this.say('');
+    for (const line of cardLines(card, this.ink, url)) this.say(line);
+    this.say('');
+    return this.note(`${card.ref ?? ref} on ${slug}`);
+  }
+
+  /** ↑ with no line open: the most recent entry, on the line it belongs to. */
+  recallIntoALine() {
+    const last = this.history.entries.at(-1);
+    if (last === undefined) {
+      return this.note('nothing typed yet to go back to');
+    }
+    const command = last.startsWith('/');
+    // The line first — opening one resets the history — then one step back,
+    // so the next ↑ goes further rather than to the same entry again.
+    this.type(command ? 'command' : 'prompt', command ? 'cawdev ▸' : 'prompt ▸', '');
+    this.input.line.set(this.history.back(''));
+    this.input.recalling = true;
+    this.input.showing = false;
+    this.dirty = true;
+    return undefined;
+  }
+
+  /**
+   * `/drop` — delete the checkout a finished session was cloned into.
+   *
+   * Only a checkout the daemon made on demand (`-auto-<n>`), so the project
+   * always keeps the ones in the config. Refused while anything is in it: a
+   * run on it, a run that failed and holds it (R80), uncommitted files, or a
+   * commit origin does not have — deleting any of those is deleting work. It
+   * asks first, naming the path. The daemon owns the list of checkouts and the
+   * socket cannot change anything (R52), so the directory is removed here and
+   * the daemon is sent SIGHUP, which makes it look again (auto-workspaces.mjs).
+   */
+  async dropCheckout() {
+    const meta = this.commandTarget();
+    const path = meta?.view?.workspace;
+    if (!meta || !isAutoCheckout(path)) {
+      return this.note('/drop deletes a checkout made on demand (…-auto-N) — this session was not in one');
+    }
+    if (meta.dropped) {
+      return this.note(`${path} is already deleted`);
+    }
+    if (!meta.ended || this.runs.some((run) => run.workspace === path)) {
+      return this.note(`a session is working in ${path} — wait for it to end`);
+    }
+    if (meta.view?.holdsACheckout) {
+      return this.note(`the run keeps ${path} for its unfinished work — carry it on or discard it first`);
+    }
+    const unsafe = await (this.options.checkoutState ?? checkoutState)(path);
+    if (unsafe) {
+      return this.note(`not deleting ${path}: ${unsafe}`);
+    }
+    const noPr = isPullRequest(meta.view?.prUrl) ? '' : ' (no pull request yet — the branch is on origin)';
+    this.dropping = { meta, path };
+    this.openPicker(new Select({
+      kind: 'drop',
+      title: `delete ${path}?${noPr}`,
+      rows: [
+        { id: 'delete', label: `Delete ${path}` },
+        { id: 'keep', label: 'Keep it' },
+      ],
+    }));
+    return undefined;
+  }
+
+  /** The choice `/drop` asked for. */
+  async droppedCheckout(row) {
+    const { meta, path } = this.dropping ?? {};
+    this.dropping = null;
+    if (!meta || row.id !== 'delete') {
+      return this.note('kept');
+    }
+    try {
+      await (this.options.removeDir ?? ((dir) => rm(dir, { recursive: true, force: true })))(path);
+    } catch (failure) {
+      return this.note(`could not delete ${path}: ${failure.message}`);
+    }
+    meta.dropped = true;
+    if (this.runner?.pid) {
+      (this.options.signalDaemon ?? ((pid) => {
+        try {
+          process.kill(pid, 'SIGHUP');
+        } catch {
+          // Gone; the next one will not find the checkout either.
+        }
+      }))(this.runner.pid);
+    }
+    this.say(this.ink.success(`  deleted ${path}`));
+    return this.note('');
+  }
+
+  /** `/close` — an ended session's window goes; a live one's stays. */
+  closeWindow() {
+    const meta = this.commandTarget();
+    if (!meta) return this.note('no window to close');
+    if (!meta.ended) return this.note('that session is still running — /cancel stops it');
+    this.closeWindowOf(meta);
+    return this.note('closed');
+  }
+
+  /** An ended session's window goes; focus moves to the first one left. */
+  closeWindowOf(meta) {
+    this.closed.add(meta.id);
+    if (this.split && (this.split.focus === meta.id || !this.sessions.has(this.split.focus))) {
+      this.split.focus = this.windows()[0]?.id ?? null;
+    }
+    this.dirty = true;
+  }
+
   // --- the things a person can do ---------------------------------------------
 
   async send(text) {
@@ -2650,6 +4320,13 @@ export class Attached {
     }
 
     this.stopped = true;
+    // Off the alternate screen before anything is printed, or the goodbye
+    // lands on a buffer that vanishes the moment the program exits.
+    if (this.split) {
+      clearInterval(this.split.plannedTimer);
+      this.split.screen.release();
+      this.split = null;
+    }
     try {
       this.client?.destroy();
     } catch {
@@ -2690,6 +4367,131 @@ export class Attached {
     return process.exit(0);
   }
 
+  /**
+   * `/reload` — quitting and starting again, in one word, for when the client's
+   * own code changed on disk.
+   *
+   * The same argv is run again in a fresh process, which is the only way a
+   * module already loaded is read again; this one hands it the terminal and
+   * waits, and leaves with its exit code. The daemon goes too — `q`'s SIGINT,
+   * then waiting for it to be gone — when nothing is running here, so the
+   * relaunch starts a daemon on the new code as well. When sessions are live
+   * it is kept, and said: restarting it would end them, and a reload is not a
+   * reason to lose somebody's work. `--attach` is refused: there the daemon IS
+   * this process.
+   */
+  async reload() {
+    if (this.options.onQuit) {
+      return this.note('here the runner is this process (runner.mjs --attach) — quit and start it again');
+    }
+    const live = this.liveHere();
+    const pid = this.runner?.pid ?? null;
+    const restartDaemon = Boolean(pid) && live === 0;
+    // Taken before anything is torn down: leaving advanced mode below would
+    // otherwise be what gets saved.
+    const state = this.reloadState();
+
+    this.stopped = true;
+    if (this.split) {
+      clearInterval(this.split.plannedTimer);
+      this.split.screen.release();
+      this.split = null;
+    }
+    try {
+      this.client?.destroy();
+    } catch {
+      // Going anyway.
+    }
+    if (this.pending.length) {
+      this.screen.update(this.pending, []);
+      this.pending = [];
+    }
+    this.screen.close();
+    if (!this.plain && process.stdin.isTTY) {
+      process.stdout.write(`${ESC}[?2004l`);
+    }
+    process.stdin.setRawMode?.(false);
+    process.stdin.removeAllListeners('data');
+    process.stdin.pause();
+
+    if (restartDaemon) {
+      this.stopDaemon(pid);
+      const alive = this.options.alive ?? ((each) => {
+        try {
+          process.kill(each, 0);
+          return true;
+        } catch {
+          return false;
+        }
+      });
+      for (let waited = 0; waited < 100 && alive(pid); waited++) {
+        await new Promise((done) => setTimeout(done, 100));
+      }
+      console.log(`\n  ${this.ink.muted('reloading — the runner and this terminal, on the code on disk')}\n`);
+    } else {
+      console.log(`\n  ${this.ink.muted(live
+        ? `reloading this terminal — the runner keeps running, ${live} session${live === 1 ? ' is' : 's are'}`
+          + ' live on it; /reload again once they end to reload it too'
+        : 'reloading this terminal')}\n`);
+    }
+
+    // `--setup` was a request to walk setup once, not every time.
+    const argv = process.argv.slice(1).filter((arg) => arg !== '--setup');
+    const relaunch = this.options.relaunch ?? ((args, env) => {
+      const child = spawn(process.execPath, [...process.execArgv, ...args],
+        { stdio: 'inherit', env: { ...process.env, ...env } });
+      child.on('exit', (code, signal) => process.exit(code ?? (signal ? 1 : 0)));
+      return child;
+    });
+    relaunch(argv, { [RELOAD_STATE]: JSON.stringify(state) });
+    return undefined;
+  }
+
+  /**
+   * What `/reload` carries across the restart — only what the person arranged,
+   * never what the daemon will say again anyway. Ended sessions go with their
+   * daemon-side facts, because the daemon forgot them and their windows (and
+   * the /develop or /pr on them) would otherwise be gone.
+   */
+  reloadState() {
+    return {
+      advanced: Boolean(this.split),
+      projects: this.split?.projects ? [...this.split.projects] : null,
+      focus: this.split?.focus ?? null,
+      watching: this.watching,
+      showLog: this.showLog,
+      closed: [...this.closed],
+      ended: [...this.sessions.values()]
+        .filter((meta) => meta.ended && !this.closed.has(meta.id))
+        .map(({ id, projectSlug, label, profile, state }) => ({ id, projectSlug, label, profile, state })),
+    };
+  }
+
+  /** Puts back what `reloadState` saved. Anything missing is simply not restored. */
+  restore(state) {
+    if (!state || typeof state !== 'object') return;
+    for (const meta of Array.isArray(state.ended) ? state.ended : []) {
+      if (meta?.id && !this.sessions.has(meta.id)) {
+        const restored = { ...meta, ended: true, view: null, prAsked: null };
+        this.sessions.set(meta.id, restored);
+        void this.readView(restored);
+      }
+    }
+    for (const id of Array.isArray(state.closed) ? state.closed : []) {
+      this.closed.add(id);
+    }
+    if (state.watching) {
+      this.watching = state.watching;
+    }
+    this.showLog = state.showLog === true;
+    if (state.advanced && !this.plain) {
+      this.enterSplit(Array.isArray(state.projects) ? state.projects : null);
+      if (state.focus && this.sessions.has(state.focus)) {
+        this.split.focus = state.focus;
+      }
+    }
+  }
+
   /**
    * Whether leaving here ends the daemon — R123.
    *
@@ -2844,6 +4646,11 @@ export class Attached {
       parts.push(`${ink.warn(pending.approval?.suggestion ? 'y/s/Y/n' : 'y/s/n')} `
         + `${ink.muted('permission')}`);
     }
+    if (this.split) {
+      parts.push(`${ink.text('tab')} ${ink.muted('next window')}`);
+      parts.push(`${ink.text('d')} ${ink.muted(this.finishedPlan(this.commandTarget())
+        ? `develop ${this.commandTarget().view.entryRef}` : 'develop a planned card')}`);
+    }
     parts.push(`${ink.text('x')} ${ink.muted('cancel')}`);
     parts.push(`${ink.text('c')} ${ink.muted('config')}`);
     parts.push(`${ink.text('q')} ${ink.muted(this.stopsTheDaemon() ? 'stop' : 'quit')}`);