cawdev-cli 1.2.1 → 1.2.2

package/runner/runner.mjs

@@ -1750,11 +1750,22 @@ async function readingCopy(source, defaultBranch) {
   }
 }
 
-async function prepareWorkingCopy(path, branch, defaultBranch, allowDirty, baseBranch = null) {
+async function prepareWorkingCopy(path, branch, defaultBranch, allowDirty, baseBranch = null, { resumingMerge = false } = {}) {
   await access(join(path, '.git')).catch(() => {
     throw new Error(`${path} is not a git repository.`);
   });
 
+  // R621. A checkout mid-merge was left by something the daemon did not see (a
+  // daemon killed between the merge and the RUNNING post, or a person). Whose
+  // merge it is cannot be known, so it is said and not touched. A MERGE run
+  // carrying on its own branch is the one run that is meant to find it so.
+  if (!resumingMerge && await git(path, ['rev-parse', '-q', '--verify', 'MERGE_HEAD']).then(() => true, () => false)) {
+    throw new Error(
+      `${path} is in the middle of a merge (MERGE_HEAD is set): from a merge run on its branch that did not finish, ` +
+        `or one started by hand. Finish it (resolve and \`git -C ${path} commit\`) or abandon it ` +
+        `(\`git -C ${path} merge --abort\`), then start the run again.`);
+  }
+
   const dirty = await git(path, ['status', '--porcelain']);
   if (dirty && !allowDirty) {
     throw new Error(
@@ -1869,7 +1880,7 @@ async function prepareWorkingCopy(path, branch, defaultBranch, allowDirty, baseB
  * — an older runner that did not say why — and it is the property that makes
  * being wrong there cost a fetch rather than a model.
  */
-async function prepareMerge(cwd, branch, defaultBranch) {
+async function prepareMerge(cwd, branch, defaultBranch, from = null) {
   const base = defaultBranch || 'main';
   await git(cwd, ['fetch', '--prune', 'origin']).catch((failure) => {
     log(`  fetch skipped: ${failure.message.split('\n')[0]}`);
@@ -1881,6 +1892,10 @@ async function prepareMerge(cwd, branch, defaultBranch) {
   const into = await git(cwd, ['rev-parse', '--verify', `origin/${base}`])
     .then(() => `origin/${base}`)
     .catch(() => base);
+  // R621. Told to the caller BEFORE the merge runs, so a throw below still leaves it known.
+  if (from) {
+    from.into = into;
+  }
 
   let clean = true;
   try {
@@ -1915,6 +1930,55 @@ async function prepareMerge(cwd, branch, defaultBranch) {
   };
 }
 
+/**
+ * R621. Puts a checkout back as `prepareMerge` found it, when the run it was
+ * prepared for never started. `from` is `{ before, into, branch }`: HEAD before
+ * `git merge` ran, and the ref merged in (null when not known).
+ *
+ * Never throws. Returns one sentence, or null when there was nothing to undo.
+ * `reset --keep`, never `--hard`: an allowDirty tree's own work must survive,
+ * and git had already refused any dirty file the merge touches.
+ */
+async function undoPreparedMerge(cwd, from) {
+  const couldNot = (why) => {
+    const said = `!! could not undo the prepared merge in ${cwd}: ${String(why).split('\n')[0]}`;
+    log(said);
+    return said;
+  };
+  try {
+    const midMerge = await git(cwd, ['rev-parse', '-q', '--verify', 'MERGE_HEAD']).then(() => true, () => false);
+    if (midMerge) {
+      await git(cwd, ['merge', '--abort']);
+      return `the merge prepared in ${cwd} was undone (git merge --abort), because the run did not start`;
+    }
+    const before = from?.before;
+    if (!before) {
+      return null;
+    }
+    const head = await git(cwd, ['rev-parse', 'HEAD']);
+    if (head === before) {
+      return null;
+    }
+    const merged = from.into ? await git(cwd, ['rev-parse', from.into]) : null;
+    // A fast-forward (the branch was strictly behind) moves HEAD onto `into` with no
+    // merge commit; anything else must be a merge commit of `before` and `into`.
+    const fastForward = merged !== null && head === merged
+      && await git(cwd, ['merge-base', '--is-ancestor', before, head]).then(() => true, () => false);
+    if (!fastForward) {
+      if ((await git(cwd, ['rev-parse', 'HEAD^1'])) !== before) {
+        return couldNot('HEAD is not a merge commit on top of the pre-merge head');
+      }
+      if (merged && (await git(cwd, ['rev-parse', 'HEAD^2'])) !== merged) {
+        return couldNot(`HEAD's second parent is not ${from.into}`);
+      }
+    }
+    await git(cwd, ['reset', '--keep', before]);
+    return `the merge commit prepared on ${from.branch} was undone (reset to ${before.slice(0, 7)}), because the run did not start`;
+  } catch (failure) {
+    return couldNot(failure.message);
+  }
+}
+
 /**
  * Each live run's protected-file guard — R562: `{ globs, mode, allowed, base }`.
  *
@@ -2750,10 +2814,10 @@ async function scanQuality(config, run, cwd, branch) {
         return report({ headSha, error: ran.said.split('\n')[0] || 'the scanner failed and said nothing' });
       }
       const reportTask = parseProperties(await readFile(join(workDir, 'report-task.txt'), 'utf8'));
-      const askServer = sonarAsker((reportTask.serverUrl ?? url).replace(/\/$/, ''), token);
-      const settled = await waitForAnalysis(askServer, reportTask.ceTaskId, deadline, quality.timeoutSeconds);
+      const serverUrl = (reportTask.serverUrl ?? url).replace(/\/$/, '');
+      const settled = await waitForAnalysis(sonarAsker(serverUrl, token), reportTask.ceTaskId, deadline, quality.timeoutSeconds);
       return await reportBranchReading({
-        ask: askServer, reportTask, settled, key, branch, analysedAs: 'MAIN',
+        ask: sonarReadAsker(serverUrl, token), reportTask, settled, key, branch, analysedAs: 'MAIN',
         warning: "This server does not analyse branches; the branch was analysed as the project's main analysis.",
         headSha, report, findings: run.findingsToProve,
       });
@@ -2797,10 +2861,10 @@ async function scanQuality(config, run, cwd, branch) {
 
     // What the scanner left behind: where the server queued the analysis.
     const reportTask = parseProperties(await readFile(join(workDir, 'report-task.txt'), 'utf8'));
-    const askServer = sonarAsker((reportTask.serverUrl ?? url).replace(/\/$/, ''), token);
-    const settled = await waitForAnalysis(askServer, reportTask.ceTaskId, deadline, quality.timeoutSeconds);
+    const serverUrl = (reportTask.serverUrl ?? url).replace(/\/$/, '');
+    const settled = await waitForAnalysis(sonarAsker(serverUrl, token), reportTask.ceTaskId, deadline, quality.timeoutSeconds);
     await reportBranchReading({
-      ask: askServer, reportTask, settled, key, branch, analysedAs, warning, headSha, report,
+      ask: sonarReadAsker(serverUrl, token), reportTask, settled, key, branch, analysedAs, warning, headSha, report,
       findings: run.findingsToProve,
     });
   } catch (failure) {
@@ -2817,6 +2881,11 @@ function trimSlash(url) {
   return url.replace(/\/$/, '');
 }
 
+// Once the analysis has settled, the gate, measures, issue and hotspot pages and finding proofs
+// together get two minutes: not killed because the wait used up the scan's budget, not unbounded either (R622).
+const SONAR_READ_BUDGET_MS = 120_000;
+const sonarReadAsker = (serverUrl, token) => sonarAsker(serverUrl, token, { deadline: Date.now() + SONAR_READ_BUDGET_MS });
+
 /** The gate and the new-code measures, for a BRANCH or MAIN reading — never for PROJECT, which has neither. */
 async function reportBranchReading({ ask, reportTask, settled, key, branch, analysedAs, warning, headSha, report, findings }) {
   const { projectStatus } = await ask(`/api/qualitygates/project_status?analysisId=${encodeURIComponent(settled.analysisId)}`);
@@ -2989,8 +3058,9 @@ async function scanAsScratchProject({ quality, run, cwd, branch, key, url, token
   }
 
   const reportTask = parseProperties(await readFile(join(workDir, 'report-task.txt'), 'utf8'));
-  const ask = sonarAsker((reportTask.serverUrl ?? url).replace(/\/$/, ''), token);
-  await waitForAnalysis(ask, reportTask.ceTaskId, deadline, quality.timeoutSeconds);
+  const serverUrl = (reportTask.serverUrl ?? url).replace(/\/$/, '');
+  await waitForAnalysis(sonarAsker(serverUrl, token), reportTask.ceTaskId, deadline, quality.timeoutSeconds);
+  const ask = sonarReadAsker(serverUrl, token);
 
   const changed = await changedLines(cwd, mergeBase);
   const counted = (component, line) => {
@@ -6935,6 +7005,9 @@ async function startRun(config, offered, workspace, source = null) {
   let shield = null;
   // R155. What `git merge` did before anything was spawned, on a MERGE run.
   let merge = null;
+  // R621. What `undoPreparedMerge` needs, and whether RUNNING was accepted.
+  let mergeFrom = null;
+  let started = false;
 
   try {
     log(`claiming ${run.projectSlug} ${run.label} on ${run.branch}`);
@@ -7107,8 +7180,10 @@ async function startRun(config, offered, workspace, source = null) {
       if (!allowDirty) {
         await resetWorkspace(resolve(path));
       }
+      const resumingMerge = run.profile === 'MERGE'
+        && await git(resolve(path), ['rev-parse', '--abbrev-ref', 'HEAD']).then((now) => now === run.branch, () => false);
       const prepared = await prepareWorkingCopy(
-        resolve(path), run.branch, defaultBranch, allowDirty, run.baseBranch);
+        resolve(path), run.branch, defaultBranch, allowDirty, run.baseBranch, { resumingMerge });
       branch = prepared.branch;
       baseCommit = prepared.base;
       if (handoff) {
@@ -7157,7 +7232,19 @@ async function startRun(config, offered, workspace, source = null) {
         // R155. The daemon does the merge, BEFORE anything is spawned, and what
         // git conflicts on becomes the session's whole write scope. A clean
         // merge needs no session at all and gets none.
-        merge = await prepareMerge(resolve(path), branch, run.baseBranch ?? defaultBranch);
+        // R621. Recorded here and not inside `prepareMerge`, so that a throw after
+        // `git merge` ran still has it. A null `before` is kept: there is nothing
+        // safe to reset to, but `git merge --abort` still covers MERGE_HEAD.
+        // Not set at all when the checkout is ALREADY mid-merge (a Carry-on): that
+        // merge is not this attempt's to abort.
+        const alreadyMerging = await git(resolve(path), ['rev-parse', '-q', '--verify', 'MERGE_HEAD'])
+          .then(() => true, () => false);
+        mergeFrom = alreadyMerging ? null : {
+          before: await git(resolve(path), ['rev-parse', 'HEAD']).catch(() => null),
+          into: null,
+          branch,
+        };
+        merge = await prepareMerge(resolve(path), branch, run.baseBranch ?? defaultBranch, mergeFrom ?? undefined);
         run.conflictedFiles = merge.conflicted;
         log(merge.clean
           ? `  ${merge.into} merged into ${branch} with no conflict — nothing to resolve`
@@ -7193,9 +7280,16 @@ async function startRun(config, offered, workspace, source = null) {
         // run's path is worse than one showing nothing.
         body: { state: 'RUNNING', workspace: workspace ?? null },
       });
+      started = true;
     } catch (refused) {
       if (PLATFORM_REFUSALS.has(refused.status)) {
         log(`  the platform did not let this run start (${refused.message}); leaving it as the platform has it`);
+        if (mergeFrom) {
+          const undone = await undoPreparedMerge(resolve(path), mergeFrom);
+          if (undone) {
+            log(`  ${undone}`);
+          }
+        }
         protectedGuards.delete(run.id);
         return;
       }
@@ -7226,9 +7320,16 @@ async function startRun(config, offered, workspace, source = null) {
     // Anything that goes wrong before or during the spawn is the run's failure,
     // and the reason belongs on the run where someone will see it.
     log(`  failed: ${failure.message}`);
+    let summary = failure.message;
+    if (mergeFrom && !started) {
+      const undone = await undoPreparedMerge(resolve(path), mergeFrom);
+      if (undone) {
+        summary = `${summary}\n\n${undone}`;
+      }
+    }
     await api(config, `/api/projects/${run.projectSlug}/runs/${run.id}/transition`, {
       method: 'POST',
-      body: { state: 'FAILED', summary: failure.message },
+      body: { state: 'FAILED', summary },
     }).catch((second) => log(`  could not record the failure: ${second.message}`));
   } finally {
     reader?.release();
@@ -7663,7 +7764,8 @@ async function walkLifecycle(config, run, runToken, cwd, baseCommit, workspace,
     // the tree the tests just ran against, by the daemon and not the session.
     // AWAITED: the workspace is released in `perform`'s finally, and a
     // scanner still reading files when the next run's reset runs is the
-    // hazard; the block's `timeoutSeconds` bounds the wait. It never throws.
+    // hazard; the block's `timeoutSeconds` bounds the wait and
+    // SONAR_READ_BUDGET_MS the reads after it (R622). It never throws.
     if (stage.stage === 'TEST' && run.branch && writesAnythingProfile(run)) {
       await scanQuality(config, run, cwd, run.branch);
     }

package/runner/session-cards.mjs

@@ -87,7 +87,7 @@ function spread(width, n) {
 const BADGES = {
   PLAN: ['PLAN', 'violetLight'],
   CODE: ['DEV', 'accent'],
-  REVIEW: ['REVIEW', 'text'],
+  TEST: ['TEST', 'text'],
   MERGE: ['MERGE', 'text'],
   RELEASE: ['RELEASE', 'text'],
 };
@@ -109,17 +109,19 @@ export function badgeOf(profile, ink) {
  * @param waiting a word when it waits on you (`waiting for an answer`), else null
  * @param now ms, for how long a live session has run
  */
-export function cardStatus(meta, waiting = null, now = Date.now()) {
+export function cardStatus(meta, waiting = null, now = Date.now(), tick = 0) {
   if (waiting) {
     return { key: 'waiting', mark: '◆', word: waiting };
   }
   if (!meta.ended) {
+    const shape = spinnerFor(meta.view?.profile ?? meta.profile, meta.stage);
     if (meta.state === 'queued' || meta.state === 'claiming') {
-      return { key: 'queued', mark: '◌', word: meta.state };
+      // Nothing moves while queued: the spinner rests on its first frame, grey.
+      return { key: 'queued', mark: shape[0], word: meta.state };
     }
     const since = Date.parse(meta.startedAt ?? '');
     const ran = Number.isFinite(since) ? ` · ${elapsed(now - since)}` : '';
-    return { key: 'running', mark: '●', word: `${meta.state ?? 'running'}${ran}` };
+    return { key: 'running', mark: spinnerFrame(shape, tick), word: `${meta.state ?? 'running'}${ran}` };
   }
   const state = meta.view?.state;
   if (!state || meta.view?.live) {
@@ -137,6 +139,36 @@ export function cardStatus(meta, waiting = null, now = Date.now()) {
   return { key: 'stopped', mark: '✕', word: String(state).toLowerCase().replace(/_/g, ' ') };
 }
 
+// --- the spinner ---------------------------------------------------------------
+
+/** A stage that writes turns the solid quadrant counter-clockwise: the rule `cawdev-actions.js` draws. */
+export const SPINNER_WRITES = ['◴', '◵', '◶', '◷'];
+/** A stage that only reads turns the thin arc clockwise. */
+export const SPINNER_READS = ['◜', '◝', '◞', '◟'];
+/** Stages that only read; every other action — plan, code, merge, release, roadmap, interview — writes. */
+const READING_STAGES = new Set(['test', 'ask', 'audit', 'scope', 'show']);
+const READING_PROFILES = new Set(['TEST', 'ASK', 'AUDIT', 'SCOPE']);
+
+/** The frames a session turns through: by its stage when it walks stages, else by its profile. */
+export function spinnerFor(profile, stage = null) {
+  const word = String(stage ?? '').toLowerCase();
+  if (word) return READING_STAGES.has(word) ? SPINNER_READS : SPINNER_WRITES;
+  return READING_PROFILES.has(String(profile ?? '').toUpperCase()) ? SPINNER_READS : SPINNER_WRITES;
+}
+
+/** One frame every two ticks, so every spinner on the screen is in phase. */
+export function spinnerFrame(shape, tick = 0) {
+  return shape[Math.floor(Math.max(0, tick) / 2) % shape.length];
+}
+
+/** How many ticks a changed value is drawn bright before it settles. */
+export const BEAT_TICKS = 4;
+
+/** Whether a value that changed at `changedAt` is still in its beat at `tick`. */
+export function beating(changedAt, tick) {
+  return Number.isFinite(changedAt) && tick - changedAt >= 0 && tick - changedAt < BEAT_TICKS;
+}
+
 /** `42s`, `12m`, `2h05`. */
 export function elapsed(ms) {
   const seconds = Math.max(0, Math.floor(ms / 1000));
@@ -149,7 +181,7 @@ export function elapsed(ms) {
 /** The colour of each status — the frame's, the mark's and the rain's. */
 const STATUS_PAINT = {
   running: 'success', waiting: 'warn', queued: 'muted', done: 'success', planned: 'success', merging: 'muted',
-  idle: 'warn', stopped: 'danger', ended: 'muted',
+  idle: 'warn', stopped: 'danger', ended: 'muted', landed: 'success',
 };
 
 export function statusPaint(key, ink) {
@@ -161,13 +193,15 @@ export function statusPaint(key, ink) {
  * one it is on. Too long for `width`, it says the count and the stage instead,
  * which still answers "how far has it got".
  */
-export function stageWalk(stages, current, width, ink) {
+export function stageWalk(stages, current, width, ink, tick = null) {
   if (!Array.isArray(stages) || !stages.length || !current) return '';
   const at = stages.indexOf(current);
+  // The mark on the current stage turns when a tick is given, as the status's does.
+  const mark = tick === null ? '●' : spinnerFrame(spinnerFor(null, current), tick);
   const words = stages.map((name, i) => {
     const word = String(name).toLowerCase();
     if (at < 0 || i > at) return ink.muted(`${word} ○`);
-    return i === at ? ink.bold(`${word} ●`) : ink.muted(`${word} ✓`);
+    return i === at ? ink.bold(`${word} ${mark}`) : ink.muted(`${word} ✓`);
   });
   const line = words.join(ink.muted(' ─ '));
   if (visibleWidth(line) <= width) return line;
@@ -227,8 +261,12 @@ export const RAIN = {
   ended: { speed: 0, density: 0.12, trail: 1 },
 };
 
-/** Half-width katakana and digits: one column each, which is what the rain is measured in. */
-const GLYPHS = 'ｱｲｳｴｵｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓﾔﾕﾖﾗﾘﾙﾚﾛﾜﾝ0123456789';
+/**
+ * Plain ASCII: one column in every terminal and every font. Half-width
+ * katakana are East Asian "halfwidth" — a terminal or font that draws them two
+ * columns wide pushed every rain row past the card's right border.
+ */
+export const GLYPHS = '0123456789=+*<>:ZXJ';
 
 /** A small integer hash — the same inputs, the same drop. */
 function mix(...values) {
@@ -384,6 +422,168 @@ export function mergingRobotLines(width, rows, { tick = 0, still = false, base =
   return [...new Array(Math.max(0, rows - drawn.length)).fill(' '.repeat(width)), ...drawn].slice(-rows);
 }
 
+// --- the robots' moments ----------------------------------------------------------
+//
+// Each is a pure function of `since`, the ticks since the card's status changed
+// (attach.mjs records the tick when it marks a session ended), so a test can
+// name the frame it wants. The pacing and merging robots above are unchanged.
+
+/** The tick the walk-in of a finished plan takes: from x = -6, a column every two ticks, in by x = 0. */
+export const WALK_IN_TICKS = 14;
+
+/** `text` placed at column `x` of a row `width` wide; a negative `x` cuts the text's front off. */
+function placed(text, x, width) {
+  const cut = x < 0 ? text.slice(Math.min(text.length, -x)) : text;
+  const left = Math.max(0, x);
+  return (' '.repeat(left) + cut).slice(0, width).padEnd(width);
+}
+
+/** Overlays plain `text` on the plain row `base` at `x`; spaces in `text` leave `base` alone. */
+function overlay(base, text, x) {
+  const chars = [...base];
+  [...text].forEach((ch, i) => {
+    const at = x + i;
+    if (at >= 0 && at < chars.length && ch !== ' ') chars[at] = ch;
+  });
+  return chars.join('');
+}
+
+/** Three plain rows → exactly `rows` painted ones, bottom-aligned, as the other robots are. */
+function stand(rowsOf, width, rows, paintRow) {
+  const drawn = (rows >= 3 ? rowsOf : rows === 2 ? [rowsOf[0], rowsOf[2]] : [rowsOf[0]])
+    .map((row, i, all) => paintRow(row, i, all.length));
+  return [...new Array(Math.max(0, rows - drawn.length)).fill(' '.repeat(width)), ...drawn].slice(-rows);
+}
+
+/** A finished plan, the moment it finishes: the robot walks in from the left carrying `✓ plan done`, then paces. */
+export function planWalkInLines(width, rows, { since = 0, tick = 0, still = false } = {}, ink) {
+  if (still || since >= WALK_IN_TICKS) {
+    return robotLines(width, rows, { tick: still ? 0 : Math.max(0, since - WALK_IN_TICKS), still }, ink);
+  }
+  const x = -6 + Math.floor(since / 2);
+  const sign = ` ${ROBOT_SIGN}`;
+  const legs = since % 2 ? ' / \\ ' : ' | | ';
+  const rowsOf = [`[o_o]${sign}`, '\\[_]/', legs];
+  return stand(rowsOf, width, rows, (row, i) => {
+    const plain = placed(row, x, width);
+    return i === 0 && row.length > 5
+      ? ink.bold(ink.success(plain.slice(0, Math.max(0, x + 5)))) + ink.success(plain.slice(Math.max(0, x + 5)))
+      : ink.bold(ink.success(plain));
+  });
+}
+
+/** Where a development's robot sets the branch down: just left of the dock's sign. */
+function dockOf(width, word) {
+  const dock = ` ▶ ${word}`;
+  return { dock, dockAt: Math.max(0, width - dock.length), branchX: Math.max(8, width - dock.length - 4) };
+}
+
+/** A plain row painted in `[from, to, paint]` segments, the rest in `base`. */
+function segments(plain, spans, base) {
+  let out = '';
+  let at = 0;
+  for (const [from, to, paint] of [...spans].sort((a, b) => a[0] - b[0])) {
+    if (from > at) out += base(plain.slice(at, from));
+    out += paint(plain.slice(from, to));
+    at = to;
+  }
+  return out + (at < plain.length ? base(plain.slice(at)) : '');
+}
+
+/** The dock's sign set on the row the branch sits on (the middle one, or the last when there is no room for three). */
+function withDock(rowsOf, rows, dock, width) {
+  const at = rows >= 3 ? 1 : rowsOf.length - 1;
+  return rowsOf.map((row, i) => (i === at && width > dock.length
+    ? row.slice(0, width - dock.length) + dock : row));
+}
+
+/**
+ * A finished development, the moment it finishes: the robot walks in carrying
+ * the branch (`[>_>]`, `/[_]=[■]`) to `▶ review`, sets it down (the `[■]` stays
+ * by the dock), steps back three columns and waits beside it — `[o_o]`, a blink
+ * every 23 ticks, a look at the branch (`[>_>]`) three ticks in every forty —
+ * under the sign `✓ built · /pr`.
+ */
+export function devDoneRobotLines(width, rows, { since = 0, still = false } = {}, ink) {
+  const { dock, dockAt, branchX } = dockOf(width, 'review');
+  const endX = Math.max(0, branchX - 5);
+  const walk = 2 * (endX + 8);
+  const t = still ? walk + 4 : since;
+  const carrying = t < walk + 1;
+  const back = carrying ? 0 : Math.min(3, t - walk - 1);
+  const x = carrying ? Math.min(endX, -8 + Math.floor(t / 2)) : Math.max(0, endX - back);
+  const waited = t - walk - 4;
+  const blink = !still && waited >= 0 && waited % 23 === 22;
+  const looking = !still && waited >= 0 && waited % 40 >= 37;
+  const head = carrying || looking ? '[>_>]' : blink ? '[-_-]' : '[o_o]';
+  const legs = !carrying || still ? ' | | ' : Math.floor(t / 2) % 2 ? ' / \\ ' : ' | | ';
+  const sign = '✓ built · /pr';
+  const signed = !carrying && x >= sign.length + 2;
+  let top = placed(head, x, width);
+  if (signed) top = overlay(top, sign, 1);
+  const plain = withDock([
+    top,
+    carrying ? placed('/[_]=[■]', x, width) : overlay(placed('/[_]\\', x, width), '[■]', branchX),
+    placed(legs, x, width),
+  ], rows, dock, width);
+  return stand(plain, width, rows, (row, i, n) => {
+    const onDock = (n >= 3 ? i === 1 : i === n - 1);
+    const spans = [];
+    if (onDock) spans.push([dockAt, width, ink.muted]);
+    if (signed && (n >= 3 ? i === 0 : i === 0)) spans.push([1, 1 + sign.length, ink.success]);
+    return segments(row, spans, (text) => ink.bold(ink.accent(text)));
+  });
+}
+
+/** Nothing built: the robot walks in empty-handed, amber, stands at the left and shrugs. */
+export function nothingBuiltRobotLines(width, rows, { since = 0, still = false, ref = null } = {}, ink) {
+  const paint = (text) => ink.bold(ink.warn(text));
+  const x = still ? 1 : Math.min(1, -6 + Math.floor(since / 2));
+  const waited = still ? 0 : since - 14;
+  const shrug = waited >= 0 && waited % 30 >= 24;
+  const blink = waited >= 0 && waited % 23 === 22;
+  const head = blink ? '[-_-]' : '[o_o]';
+  const arms = shrug ? '¯[_]¯' : '/[_]\\';
+  const sign = ` ✗ nothing built · /new plan ${ref ?? '<card>'}`;
+  const shown = width - 6 - 1 >= sign.length ? sign : ' ✗ nothing built';
+  const rowsOf = [head + (x >= 0 ? shown : ''), arms, ' | | '];
+  return stand(rowsOf, width, rows, (row, i) => {
+    const plain = placed(row, x, width);
+    return i === 0 && x >= 0
+      ? paint(plain.slice(0, x + 5)) + ink.warn(plain.slice(x + 5))
+      : paint(plain);
+  });
+}
+
+/** Ticks the robot waves for after a landing, and ticks it then takes to walk off a card `width` wide. */
+export const WAVE_TICKS = 12;
+/** A landed card closes itself this many ticks after it lands (3 s at 120 ms). */
+export const CLOSE_AFTER_TICKS = 25;
+
+/**
+ * The landing: the branch is set down at `▶ main`, the robot waves (`[^_^]`,
+ * arms alternating) for twelve ticks and walks off the right edge.
+ */
+export function landingRobotLines(width, rows, { since = 0, still = false, base = 'main' } = {}, ink) {
+  const { dock, dockAt, branchX } = dockOf(width, base);
+  const stands = Math.max(0, branchX - 8);
+  const t = still ? 0 : since;
+  const waving = t < WAVE_TICKS;
+  // Off the edge before the card closes itself, however wide the card is.
+  const pace = Math.max(1, Math.ceil((width - stands) / (CLOSE_AFTER_TICKS - WAVE_TICKS - 1)));
+  const x = stands + Math.max(0, t - WAVE_TICKS) * pace;
+  const arms = !waving ? '/[_]\\' : Math.floor(t / 2) % 2 ? '\\[_]/' : '/[_]\\';
+  const head = waving ? '[^_^]' : '[>_>]';
+  const legs = !waving && Math.floor(t / 2) % 2 ? ' / \\ ' : ' | | ';
+  const plain = withDock([
+    placed(head, x, width),
+    overlay(placed(arms, x, width), '[■]', branchX),
+    placed(legs, x, width),
+  ], rows, dock, width);
+  return stand(plain, width, rows, (row, i, n) => segments(
+    row, (n >= 3 ? i === 1 : i === n - 1) ? [[dockAt, width, ink.muted]] : [], (text) => ink.bold(ink.accent(text))));
+}
+
 // --- a card --------------------------------------------------------------------
 
 /**
@@ -420,7 +620,10 @@ export function sessionCardLines(rect, card, ink) {
   const title = titleRoom >= 4 ? ` ${ellipsed(card.title ?? '', titleRoom - 1)} ` : ' ';
   const label = `${left}${badge}${title}`;
   const fill = Math.max(0, inner - 1 - visibleWidth(label) - visibleWidth(status) - 1);
-  const shownStatus = visibleWidth(label) + visibleWidth(status) + 2 <= inner ? paint(status) : '';
+  // A status that changed is drawn reversed for a few ticks, then settles.
+  const beat = card.changedAt !== undefined && beating(card.changedAt, card.tick ?? 0);
+  const shownStatus = visibleWidth(label) + visibleWidth(status) + 2 <= inner
+    ? (beat ? ink.reverse(paint(status)) : paint(status)) : '';
   const top = paint(tl + h) + (card.focused ? ink.bold(label) : label)
     + paint(h.repeat(shownStatus ? fill : Math.max(0, inner - 1 - visibleWidth(label)))) + shownStatus
     + paint((shownStatus ? h : '') + tr);
@@ -432,15 +635,24 @@ export function sessionCardLines(rect, card, ink) {
   const room = Math.max(0, height - 2 - footer);
   const words = (card.lines ?? []).filter((line) => line !== null && line !== undefined).slice(0, room);
   const spare = room - words.length;
+  // The robots move whether the rain is on or off: they are not the matrix.
+  const since = Number.isFinite(card.since) ? card.since : null;
   const rain = spare <= 0 ? []
-    // A planned card has its robot whatever `/matrix` says; off, it stands still.
     : card.status.key === 'planned'
-      ? robotLines(inner, spare, { tick: card.tick, still: card.rain === false }, ink)
+      ? (since === null ? robotLines(inner, spare, { tick: card.tick }, ink)
+        : planWalkInLines(inner, spare, { since }, ink))
       : card.status.key === 'merging'
-        ? mergingRobotLines(inner, spare, { tick: card.tick, still: card.rain === false, base: card.base }, ink)
-      : card.rain === false
-        ? new Array(spare).fill('')
-        : rainLines(inner, spare, { seed: card.seed, tick: card.tick, mood: card.status.key }, ink);
+        ? mergingRobotLines(inner, spare, { tick: card.tick, base: card.base }, ink)
+        : card.status.key === 'done'
+          ? devDoneRobotLines(inner, spare, { since: since ?? 1e6 }, ink)
+          : card.status.key === 'idle'
+            ? nothingBuiltRobotLines(inner, spare, { since: since ?? 1e6, ref: card.ref }, ink)
+            : card.status.key === 'landed'
+              ? landingRobotLines(inner, spare, { since: since ?? 1e6, base: card.base }, ink)
+              // Failed, running, waiting, queued, stopped: no robot. The rain only when asked for.
+              : card.rain !== true || card.status.key === 'failed'
+                ? new Array(spare).fill('')
+                : rainLines(inner, spare, { seed: card.seed, tick: card.tick, mood: card.status.key }, ink);
   const lines = [top, ...words.map(said), ...rain.map(row)];
   if (footer) lines.push(said(ink.muted(card.footer)));
   lines.push(paint(bl + h.repeat(inner) + br));

package/runner/split.mjs

@@ -1,15 +1,19 @@
 // Advanced mode — the attached terminal split into one window per session,
 // emacs-style, with the client's own prompt at the bottom.
 //
-// **R81 decided against a pane manager, and this does not reopen that.** The
-// reason there was that a full-screen repaint EATS THE SCROLLBACK: the wheel,
-// search and copy stop working and the transcript above the fold is gone. So
-// the default is still `scrollback.mjs`, untouched. This is a mode somebody
-// ASKS for with `/advanced-mode`, and it is drawn on the terminal's ALTERNATE
+// **R81 chose the scrollback as the default, and R624 changes the default.**
+// R81's reason was that a full-screen repaint EATS THE SCROLLBACK: the wheel,
+// search and copy stop working and the transcript above the fold is gone. With
+// several sessions and a roadmap on one machine that reason no longer wins, so
+// `cawdev` opens HERE wherever the terminal can draw it (`advancedBlocker`: a
+// TTY, not TERM=dumb, 80×24 at least); `cawdev --simple` and `/simple` are the
+// scrollback terminal (`scrollback.mjs`, untouched), one command away, and the
+// choice is remembered in prefs.mjs. It is drawn on the terminal's ALTERNATE
 // screen — the buffer vim and emacs use — which leaves the normal screen and
 // its scrollback exactly as they were. Leaving the mode puts them back, and
 // what was said on the watched session meanwhile is laid into the scrollback
-// then, so nothing is lost by having looked at it this way.
+// then (`/export` does it on demand), so nothing is lost by having looked at it
+// this way.
 //
 // Everything that decides a picture is a pure function — the layout, one
 // window, the whole frame — so it can be rendered at four sizes and READ,
@@ -133,7 +137,10 @@ export function windowLines(rect, {
   const label = title ? ` ${clip(title, Math.max(0, inner - 3))} ` : '';
   const top = paint(tl + h) + label + paint(h.repeat(Math.max(0, inner - 1 - visibleWidth(label))) + tr);
 
-  const footerRows = footer ? 1 : 0;
+  // A footer is a row, or several: keys that do not fit one wrap onto the next
+  // rather than being cut off.
+  const footers = (Array.isArray(footer) ? footer : [footer]).filter(Boolean);
+  const footerRows = footers.length;
   const subtitleRows = subtitle ? 1 : 0;
   const rows = Math.max(0, height - 2 - footerRows - subtitleRows);
   const tail = tailOf(body, inner, rows);
@@ -146,8 +153,8 @@ export function windowLines(rect, {
   for (let i = 0; i < rows; i++) {
     lines.push(paint(v) + padVisible(clip(tail[i] ?? '', inner), inner) + RESET + paint(v));
   }
-  if (footer) {
-    lines.push(paint(v) + padVisible(clip(footer, inner), inner) + RESET + paint(v));
+  for (const row of footers) {
+    lines.push(paint(v) + padVisible(clip(row, inner), inner) + RESET + paint(v));
   }
   lines.push(paint(bl + h.repeat(inner) + br));
   return lines.slice(0, height);
@@ -486,7 +493,7 @@ export function actionsFor(meta) {
   } else if (isAutoCheckout(view?.workspace) && view?.state !== 'RUNNING' && !view?.live) {
     parts.push('/drop');
   }
-  parts.push('/close');
+  parts.push('w closes');
   return parts.join(' · ');
 }
 
@@ -1201,3 +1208,21 @@ export function cardLines(card, ink, url = null) {
   }
   return lines;
 }
+
+/** Advanced mode's smallest terminal. */
+export const ADVANCED_MIN_COLUMNS = 80;
+export const ADVANCED_MIN_ROWS = 24;
+
+/**
+ * Why a terminal cannot draw advanced mode, in a few words — or null when it
+ * can: a TTY, not `TERM=dumb`, at least 80×24. Pure, so the default is a
+ * test and not a guess.
+ */
+export function advancedBlocker({ tty, term, columns, rows }) {
+  if (!tty) return 'no terminal to draw on (a pipe) · /advanced-mode needs a TTY';
+  if (term === 'dumb') return 'TERM=dumb cannot draw it';
+  if ((columns ?? 0) < ADVANCED_MIN_COLUMNS || (rows ?? 0) < ADVANCED_MIN_ROWS) {
+    return `the terminal is ${columns ?? '?'}×${rows ?? '?'}, advanced mode needs ${ADVANCED_MIN_COLUMNS}×${ADVANCED_MIN_ROWS}`;
+  }
+  return null;
+}