cawdev-cli 1.0.5-beta → 1.0.7-beta

package/runner/attach.mjs

@@ -52,7 +52,7 @@ 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,
@@ -60,11 +60,12 @@ import {
 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,
+  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 } from '../lib/agents.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';
@@ -481,7 +482,7 @@ export function elapsed(ms) {
  */
 export function footerLines(state, width, ink = painter(3)) {
   const {
-    runner, runs = [], email, watching, connected = true,
+    runner, runs = [], email, expired = false, watching, connected = true,
     banner = [], overlay = [], input = null, keys = '', status = '',
     running = null, now = Date.now(), matches = [],
   } = state;
@@ -518,6 +519,16 @@ export function footerLines(state, width, ink = painter(3)) {
     ), width));
   }
 
+  // The platform refused the stored session (401). Pinned for the same reason
+  // as the row above: one line in the scrollback is gone with the next
+  // transcript line, and every action from here on would fail without it.
+  if (expired) {
+    lines.push(padVisible(clip(
+      ` ${ink.warn('!')} ${ink.muted('session expired —')} ${ink.text('/login')} ${ink.muted('to sign in again')}`,
+      width,
+    ), width));
+  }
+
   // Who and where. The runner's NAME is what the console shows and what
   // `--runner` takes, so it is the word somebody would type; the email is what
   // every action here is done as, and "watching only" is not a lesser state,
@@ -678,19 +689,19 @@ async function openSession(argv, url) {
  * too is not belt and braces: a machine over ssh has no browser to open, and
  * this is the only thing that makes it work at all.
  */
-async function runSignIn(session, ink = painter()) {
+async function runSignIn(session, ink = painter(), say = (line) => console.log(line)) {
   const outcome = await signInThroughBrowser(session, ({ url, code }) => {
-    console.log(`  ${ink.muted('If your browser did not open, go to')}`);
-    console.log(`      ${ink.accent(url)}`);
-    console.log(`  ${ink.muted('and check it is showing')}  ${ink.bold(code)}\n`);
-    console.log(`  ${ink.muted('Waiting…')}`);
+    say(`  ${ink.muted('If your browser did not open, go to')}`);
+    say(`      ${ink.accent(url)}`);
+    say(`  ${ink.muted('and check it is showing')}  ${ink.bold(code)}\n`);
+    say(`  ${ink.muted('Waiting…')}`);
   });
   if (outcome.signedIn) {
-    console.log(`  ${ink.success('Signed in')} as ${ink.bold(outcome.email)}.\n`);
+    say(`  ${ink.success('Signed in')} as ${ink.bold(outcome.email)}.\n`);
   } else if (outcome.refused) {
-    console.log(`  ${ink.danger('Refused')} in the browser.\n`);
+    say(`  ${ink.danger('Refused')} in the browser.\n`);
   } else {
-    console.log(`  ${ink.warn('The code expired.')}\n`);
+    say(`  ${ink.warn('The code expired.')}\n`);
   }
   return outcome;
 }
@@ -730,7 +741,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;
@@ -767,11 +778,42 @@ 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');
+}
+
+/** How many matching commands advanced mode's prompt shows at once. */
+const SPLIT_COMPLETIONS = 6;
+
 /** The slash commands, and the one place they are described. */
 const COMMANDS = [
   ['/help', 'this list'],
@@ -783,11 +825,15 @@ const COMMANDS = [
   ['/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'],
+  ['/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'],
-  ['/open', "open the session's pull request in your browser"],
+  ['/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'],
@@ -854,6 +900,11 @@ export class Attached {
   constructor(socketPath, session, options = {}) {
     this.socketPath = socketPath;
     this.session = session;
+    if (session) {
+      session.onExpired = () => this.sessionExpired();
+    }
+    /** True from a 401 on a session that was signed in until `/login` works. */
+    this.expired = false;
     this.options = options;
     this.ink = painter();
     this.screen = new Scrollback(options.out ?? process.stdout);
@@ -952,6 +1003,17 @@ export class Attached {
     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.
@@ -980,6 +1042,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.
@@ -1296,9 +1360,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 -----------------------------------------
 
   /**
@@ -1567,7 +1641,17 @@ export class Attached {
       return this.cycleFocus(key === '\t' ? 1 : -1);
     }
     if (this.split && key === 'd') {
-      return void this.pickPlanned();
+      // 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) {
@@ -1784,7 +1868,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();
@@ -1797,15 +1882,44 @@ export class Attached {
       }
       if (rows.length) {
         // As far as they agree, which is what every shell does and nobody has
-        // to be taught. One match completes it whole.
-        line.set(commonPrefix(rows.map(([name]) => name)));
+        // to be taught. One match completes it whole. Once the line is already
+        // that far, Tab moves down the list instead — `/log` is a command AND
+        // the prefix of `/login` and `/logout`, and Tab stopping there for
+        // good left those two reachable only by the arrows.
+        const prefix = commonPrefix(rows.map(([name]) => name));
+        if (rows.length > 1 && line.text.toLowerCase() === prefix.toLowerCase() && this.input.showing !== false) {
+          this.input.at = (at + 1) % rows.length;
+        } else {
+          line.set(prefix);
+        }
         this.input.showing = true;
         this.dirty = true;
       }
       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;
@@ -1819,11 +1933,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;
@@ -1841,6 +1956,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();
@@ -1905,7 +2024,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);
@@ -2039,10 +2161,20 @@ export class Attached {
     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 ?? [];
@@ -2356,7 +2488,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)}`);
 
@@ -2408,6 +2540,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,
@@ -2627,7 +2768,7 @@ export class Attached {
   // --- 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('');
@@ -2673,16 +2814,24 @@ export class Attached {
       }
       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();
+        return void this.develop(rest);
       case 'pr':
         return void this.openPullRequest();
       case 'continue':
         return void this.carryOn();
       case 'open':
-        return this.openInBrowser();
+        return void this.openInBrowser();
+      case 'view':
+        return rest.length ? void this.viewCard(rest) : this.viewOnCawdev();
       case 'drop':
         return void this.dropCheckout();
       case 'close':
@@ -2706,21 +2855,31 @@ export class Attached {
    * the moment it is decided.
    */
   async signIn() {
+    let say;
     if (this.split) {
-      this.leaveSplit();
+      // Advanced mode stays: the URL and the code go to the prompt window,
+      // where everything said there is read, and the browser opens anyway.
+      say = (line) => this.say(line);
+    } else {
+      // 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.
+      this.say('');
+      this.screen.update(this.pending, []);
+      this.pending = [];
     }
-    // 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.
-    this.say('');
-    this.screen.update(this.pending, []);
-    this.pending = [];
-    const outcome = await runSignIn(this.session, this.ink)
+    const outcome = await runSignIn(this.session, this.ink, say)
       .catch((failure) => ({ signedIn: false, message: failure.message }));
     if (outcome.message) {
       this.say(this.ink.danger(`  could not sign in: ${outcome.message}`));
     }
-    if (this.session.signedIn) {
+    if (this.session.signedIn && this.expired) {
+      // After an expiry the watchers never stopped — they have been failing
+      // quietly and pick up on their own — so a second set would poll twice.
+      this.expired = false;
+      this.note('signed in again');
+      void this.findStopped();
+    } else if (this.session.signedIn) {
       void this.watchInbox();
       void this.watchQuestions();
       void this.findStopped();
@@ -2729,6 +2888,20 @@ export class Attached {
     return undefined;
   }
 
+  /**
+   * The platform answered 401 to a session that was signed in: it expired, was
+   * signed out from the console, or the account went. Said once, where it is
+   * read — the prompt window in advanced mode, the scrollback otherwise — and
+   * the footer keeps a row until `/login` succeeds. The watchers keep polling
+   * and fail quietly; they pick up again on their own after the sign-in.
+   */
+  sessionExpired() {
+    if (this.expired) return;
+    this.expired = true;
+    this.say(this.ink.warn('  your cawdev session has expired or is no longer valid — type /login to sign in again'));
+    this.note('session expired — /login to sign in again');
+  }
+
   // --- advanced mode — split.mjs ----------------------------------------------
 
   /**
@@ -2770,6 +2943,12 @@ export class Attached {
       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);
@@ -2800,6 +2979,8 @@ export class Attached {
     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?.();
@@ -2809,6 +2990,70 @@ export class Attached {
     }
   }
 
+  /**
+   * 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
@@ -2830,9 +3075,14 @@ export class Attached {
       && (!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.runner?.projects ?? [];
+    const served = this.servedProjects();
     return this.split?.projects ? served.filter((slug) => this.split.projects.has(slug)) : served;
   }
 
@@ -2865,12 +3115,19 @@ export class Attached {
    * today's behaviour). One project served: nothing to ask. `/projects` asks
    * again from inside the mode.
    */
-  askSplitProjects() {
+  async askSplitProjects() {
     if (this.plain) return this.note('advanced mode needs a terminal it can draw on');
-    const served = this.runner?.projects ?? [];
+    // 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) {
-      return this.split ? this.note('this machine serves one project') : this.enterSplit(served);
+      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',
@@ -3002,21 +3259,37 @@ export class Attached {
     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'
-      ? `${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'}`
+      ? `${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];
+    // The commands matching what is typed, above the line as in the footer —
+    // advanced mode drew none, so enter took a highlighted command nobody saw.
+    const matches = this.mode === 'typing' && this.input?.showing !== false ? this.matching() : { rows: [], at: 0 };
+    // Six rows at most, scrolled to the highlighted one: a bare `/` matches
+    // every command, and the prompt grows with what it holds.
+    const first = Math.max(0, Math.min(matches.at - 2, matches.rows.length - SPLIT_COMPLETIONS));
+    const completing = completionLines(
+      matches.rows.slice(first, first + SPLIT_COMPLETIONS), matches.at - first, inner, ink,
+    );
+    const fixed = [...from, ...banner, ...overlay, ...completing, 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())
+    // 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,
@@ -3078,7 +3351,8 @@ export class Attached {
       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}`;
+      + `${this.session.email ? ` · ${this.session.email}` : ' · not signed in'}`
+      + `${this.agent ? ` · ${this.agent}` : ''}${unseen}`;
     pieces.push({
       rect: layout.prompt,
       lines: windowLines(layout.prompt, {
@@ -3091,7 +3365,9 @@ export class Attached {
           ...messages,
           ...fixed,
         ],
-        footer: this.status ? ink.warn(this.status) : keyList(this.keys(), '', inner, ink),
+        footer: this.status
+          ? ink.warn(`${this.statusWindow ? `[${this.statusWindow}] ` : ''}${this.status}`)
+          : keyList(this.keys(), '', inner, ink),
       }, ink),
     });
     if (strip) {
@@ -3107,11 +3383,18 @@ export class Attached {
    * 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.
+   * 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() {
-    if (!this.session.signedIn) return;
+  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 {
@@ -3119,13 +3402,66 @@ export class Attached {
         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;
+        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)` : ''}`);
   }
 
   /**
@@ -3170,7 +3506,10 @@ export class Attached {
       return;
     }
     const anyway = words.includes('--anyway');
-    const parsed = parseNew(words.filter((word) => word !== '--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(),
     });
@@ -3197,9 +3536,19 @@ export class Attached {
       // 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);
+      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'
@@ -3208,7 +3557,107 @@ export class Attached {
           // 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);
+    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();
   }
 
   /**
@@ -3217,7 +3666,7 @@ export class Attached {
    * 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) {
+  async developNewCard(slug, text, anyway, agent = this.agent) {
     let card;
     try {
       card = await this.session.request(`/api/projects/${slug}/roadmap`, {
@@ -3234,7 +3683,8 @@ export class Attached {
       return;
     }
     this.say(this.ink.success(`  wrote ${ref} ${card.title ?? ''} on ${slug}`));
-    await this.startSession(slug, 'runs', { entryNumber: ref }, `the development of ${ref}`, anyway);
+    await this.startSession(slug, 'runs', withAgent({ entryNumber: ref }, agent),
+      withWho(`the development of ${ref}`, agent), anyway);
     void this.refreshPlanned();
   }
 
@@ -3330,20 +3780,39 @@ export class Attached {
     }
   }
 
-  /** `/develop` — the card a finished plan was about, on this machine. */
-  async develop() {
+  /**
+   * `/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');
+      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.startSession(meta.projectSlug, 'runs', { entryNumber: ref }, `the development of ${ref}`, false);
+    await this.startNew(['dev', ref, `@${meta.projectSlug}`, ...flags]);
   }
 
   /**
@@ -3364,10 +3833,12 @@ export class Attached {
       });
       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;
     }
   }
 
@@ -3467,21 +3938,181 @@ export class Attached {
     again.unref?.();
   }
 
-  /** `/open` — the session's pull request, in the browser. */
-  openInBrowser() {
-    const url = this.commandTarget()?.view?.prUrl;
+  /**
+   * `/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.
    *
@@ -3556,11 +4187,17 @@ export class Attached {
     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) {
+    if (this.split && (this.split.focus === meta.id || !this.sessions.has(this.split.focus))) {
       this.split.focus = this.windows()[0]?.id ?? null;
     }
-    return this.note('closed');
+    this.dirty = true;
   }
 
   // --- the things a person can do ---------------------------------------------
@@ -3983,6 +4620,7 @@ export class Attached {
       runner: this.runner,
       runs: this.runs,
       email: this.session.email,
+      expired: this.expired,
       watching: run,
       connected: this.connected,
       // R83's status line is about what this machine is DRIVING, which is not
@@ -4070,7 +4708,8 @@ export class Attached {
     }
     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('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')}`);