cawdev-cli 1.0.3-beta → 1.0.5-beta

package/runner/attach.mjs

@@ -46,18 +46,25 @@
 // 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, slugsOf,
+  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 {
+  MIN_ZONE_HEIGHT, PROMPT_ROWS, SplitScreen, tabsLine, visibleSessions, actionsFor, composeFrame,
+  carriesOnHere, cardTitleFor, subtitleFor, agentModelFor, wordWrap, isAutoCheckout, isPullRequest, parseNew, roadmapStrip, sessionTag, splitLayout, titleFor, toneFor,
+  windowLines,
+} from './split.mjs';
+import { KNOWN_AGENTS } from '../lib/agents.mjs';
 import { oneLine } from './brand.mjs';
 import { Scrollback } from './scrollback.mjs';
 import { Session, signInThroughBrowser, storedSession } from './sign-in.mjs';
@@ -127,7 +134,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 +142,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 +160,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 +585,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 +605,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 +651,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 +716,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.
@@ -705,6 +725,11 @@ const KNOWN_AGENTS = ['claude', 'agy'];
  * "enable" would ask the person to remember what the file says. The hint is
  * where the current value lives; the label is the change.
  */
+/** A project entry's `quality` block, whatever shape the entry is — R300. */
+function qualityOf(entry) {
+  return entry && typeof entry === 'object' && entry.quality ? entry.quality : null;
+}
+
 export function configMenu(file, runner = {}) {
   const slugs = slugsOf(file);
   const agents = agentsOf(file);
@@ -737,6 +762,11 @@ export function configMenu(file, runner = {}) {
       rulesOn
         ? { id: 'rules', label: 'Stop accepting permission rules from the console', hint: 'on now' }
         : { id: 'rules', label: 'Accept permission rules from the console', hint: 'off now' },
+      // R300: one row per served project, saying whether its branches are
+      // scanned here now — the state the row would change, R288's rule.
+      ...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' })),
       { id: 'show', label: "Show this machine's config", hint: runner.configPath ?? '' },
     ],
   });
@@ -751,6 +781,16 @@ 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)'],
+  ['/develop', 'start the development of the card a finished plan was about'],
+  ['/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'],
+  ['/open', "open the session's pull request in your browser"],
+  ['/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)'],
 ];
 
@@ -764,6 +804,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,
@@ -857,6 +938,24 @@ 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();
+    /** 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 = [];
   }
 
   /**
@@ -918,6 +1017,7 @@ export class Attached {
     }
     process.stdout.on('resize', () => {
       this.screen.resize();
+      this.split?.screen.resize();
       this.dirty = true;
     });
 
@@ -926,6 +1026,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
@@ -988,7 +1092,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.
@@ -998,18 +1104,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') {
@@ -1035,17 +1144,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());
   }
 
@@ -1398,6 +1563,13 @@ 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') {
+      return void this.pickPlanned();
+    }
+
     switch (key) {
       case 'q':
         return this.quit();
@@ -1460,6 +1632,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);
           }
@@ -1808,9 +1984,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.
    *
@@ -1845,6 +2036,19 @@ export class Attached {
       }
       return void this.allow(row.id);
     }
+    if (select.kind === 'drop') {
+      return void this.droppedCheckout(row);
+    }
+    if (select.kind === 'planned') {
+      const [slug, ref] = String(row.id).split(' ');
+      return void this.startNew(['dev', ref, `@${slug}`]).then(() => this.refreshPlanned());
+    }
+    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);
@@ -1951,7 +2155,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.
@@ -1979,7 +2184,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
@@ -2026,11 +2231,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);
       }
@@ -2043,13 +2250,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) {
@@ -2187,6 +2401,13 @@ export class Attached {
       this.runner.agents = agentsOf(next);
       return this.reloadDaemon(file, next);
     }
+    if (chosen.id.startsWith('quality:')) {
+      const slug = chosen.id.slice('quality:'.length);
+      const next = await setQuality({
+        file, configPath, ask, say, ink, slug, enabled: !qualityOf(file.projects?.[slug]),
+      });
+      return this.reloadDaemon(file, next);
+    }
     if (chosen.id === 'rules') {
       const next = await setAcceptsRulesFromConsole({
         file, configPath, ask, say, ink, enabled: file.acceptsRulesFromConsole !== true,
@@ -2360,14 +2581,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)}`);
         }
@@ -2375,7 +2609,18 @@ 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.'
+          : ''}`));
+      });
     });
   }
 
@@ -2418,6 +2663,32 @@ 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 'new':
+        return void this.startNew(rest);
+      case 'develop':
+        return void this.develop();
+      case 'pr':
+        return void this.openPullRequest();
+      case 'continue':
+        return void this.carryOn();
+      case 'open':
+        return this.openInBrowser();
+      case 'drop':
+        return void this.dropCheckout();
+      case 'close':
+        return this.closeWindow();
+      case 'reload':
+        return void this.reload();
       case 'quit':
       case 'exit':
         return this.quit();
@@ -2435,6 +2706,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.
@@ -2449,11 +2723,846 @@ 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);
+      }
+      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;
+      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.
+    }
+  }
+
+  /**
+   * 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 on screen: advanced mode's pick, else every one served here. */
+  shownProjects() {
+    const served = this.runner?.projects ?? [];
+    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.
+   */
+  askSplitProjects() {
+    if (this.plain) return this.note('advanced mode needs a terminal it can draw on');
+    const served = this.runner?.projects ?? [];
+    if (served.length <= 1) {
+      return this.split ? this.note('this machine serves one project') : this.enterSplit(served);
+    }
+    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 });
+    const input = this.mode === 'typing'
+      ? `${this.input.label} ${this.input.line.render(
+        Math.max(8, inner - visibleWidth(this.input.label) - 1), ink)}`
+      : 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);
+    const stripLines = stripRoom >= 3
+      ? roadmapStrip(width, stripRoom, this.cards, ink, this.shownProjects())
+      : [];
+    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'}${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.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 failure keeps the
+   * last list rather than blanking the strip.
+   */
+  async refreshPlanned() {
+    if (!this.session.signedIn) return;
+    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) });
+        }
+      } catch {
+        return;
+      }
+    }
+    this.cards = all;
+    this.planned = all.filter((card) => card.status === 'PLANNED');
+    this.dirty = true;
+  }
+
+  /**
+   * `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');
+    const parsed = parseNew(words.filter((word) => word !== '--anyway'), {
+      // 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);
+      return;
+    }
+    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}`];
+    await this.startSession(parsed.slug, path, body, what, anyway);
+  }
+
+  /**
+   * `/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) {
+    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', { entryNumber: ref }, `the development of ${ref}`, 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` — the card a finished plan was about, on this machine. */
+  async develop() {
+    if (!this.requireSignIn('start a session')) 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');
+      return;
+    }
+    if (!meta.ended) {
+      this.note(`${ref} is still being worked on — wait for it to end`);
+      return;
+    }
+    await this.startSession(meta.projectSlug, 'runs', { entryNumber: ref }, `the development of ${ref}`, false);
+  }
+
+  /**
+   * 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('');
+    } catch (failure) {
+      this.note(/usage|window/i.test(failure.message)
+        ? `${failure.message} — add --anyway to start it regardless`
+        : failure.message);
+    }
+  }
+
+  /**
+   * `/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. */
+  openInBrowser() {
+    const url = this.commandTarget()?.view?.prUrl;
+    if (!isPullRequest(url)) {
+      return this.note('no pull request on this session yet — /pr opens one');
+    }
+    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);
+    return this.note(`opened ${url}`);
+  }
+
+  /**
+   * `/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.closed.add(meta.id);
+    if (this.split) {
+      this.split.focus = this.windows()[0]?.id ?? null;
+    }
+    return this.note('closed');
+  }
+
   // --- the things a person can do ---------------------------------------------
 
   async send(text) {
@@ -2633,6 +3742,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 {
@@ -2673,6 +3789,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.
    *
@@ -2827,6 +4068,10 @@ 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('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')}`);