cawdev-cli 1.0.5-beta → 1.0.6-beta

package/lib/agents.mjs

@@ -25,3 +25,41 @@ export function agentOfCommand(command) {
 export function agentLabel(command) {
   return LABELS[agentOfCommand(command)];
 }
+
+/**
+ * Why an agent that needs the whole machine was refused, and what to do about
+ * it — in steps, for THIS machine. Codex and Antigravity have no per-command
+ * allow-list, so a session that writes can only run with everything allowed;
+ * the refusal used to say "turn on allow everything" and nothing about where,
+ * or that the machine must first agree to take rules from the console.
+ *
+ * Pure, so the wording is read in a test rather than found in a failed run.
+ *
+ * @param agent `codex` or `agy`
+ * @param machine `{ name, acceptsConsoleRules, configPath, consoleUrl }`
+ * @param run `{ entryRef, profile }` — what to start again, and how
+ * @param readsWithout whether a read-only session of this agent needs nothing
+ */
+export function needsEverything(agent, machine = {}, run = {}, { readsWithout = true } = {}) {
+  const who = LABELS[agent] ?? agent;
+  const short = agent === 'agy' ? 'agy' : agent;
+  const again = run.entryRef ? `/new ${run.profile === 'PLAN' ? 'plan' : 'dev'} ${run.entryRef}` : '/new …';
+  const lines = [
+    `${who} cannot ${readsWithout ? 'write code' : 'run'} on this machine yet: it has no per-command `
+      + 'permissions, so a session that commits and pushes must be allowed to run anything — and '
+      + 'this machine has not allowed everything.',
+    '',
+    'To allow it:',
+    machine.acceptsConsoleRules
+      ? '  1. ✓ This machine already accepts permission rules from the console.'
+      : '  1. On this machine: in the cawdev terminal press c → "Accept permission rules from the '
+        + `console"${machine.configPath ? ` (or "acceptsRulesFromConsole": true in ${machine.configPath})` : ''}.`,
+    `  2. On cawdev: ${machine.consoleUrl ? `${machine.consoleUrl.replace(/\/+$/, '')}/settings/runners` : 'Settings → Runners'}`
+      + ` → ${machine.name ?? 'this machine'} → tick "Allow everything".`,
+    `  3. Start it again: ${again} --${short}`,
+    '',
+    'Allowing everything lets every unattended session on this machine run any command in its checkouts.',
+    `Or, without it: ${again} --claude${readsWithout && agent === 'codex' && run.entryRef ? ` — or keep ${who} for plans (/new plan ${run.entryRef} --codex)` : ''}.`,
+  ];
+  return lines.join('\n');
+}

package/lib/background-shells.mjs

@@ -0,0 +1,108 @@
+/**
+ * The shell commands a Claude Code session started in the BACKGROUND and never
+ * saw the end of — read off its stream-json events.
+ *
+ * A lifecycle stage is one turn (R112): the daemon closes the session the
+ * moment the turn ends. A stage that ran `npm test` with `run_in_background`
+ * and ended its turn to wait for it loses the run — the result never comes
+ * back, nothing is recorded, and the walk marched on to MEMORY and FINISHED
+ * with the work unproven and uncommitted (R15, saasng). So the walk asks this,
+ * at the stage's end, whether anything it started is unfinished or unread;
+ * `walkLifecycle` then fails the stage instead of calling it done, which is
+ * what lets `/continue` pick the run back up at that stage.
+ *
+ * Pure: events in, a list out. Three tool shapes, by name:
+ * - `Bash` with `run_in_background: true` starts one; its result names the id
+ *   ("… running in background with ID: <id>");
+ * - `BashOutput` (or `TaskOutput`) reads one by `bash_id`/`shell_id`/`task_id`;
+ *   the command is over only when a read says a status other than running;
+ * - `KillShell`/`KillBash`/`TaskStop` ends one.
+ * A command whose id cannot be read off its result stays unfinished: failing
+ * loudly and re-running a stage costs a turn, calling unproven work proven
+ * costs somebody's afternoon.
+ *
+ * @author Claude Opus 5.5 (Claude Code)
+ * @author Moez Ben MBarka
+ */
+
+const READS = new Set(['BashOutput', 'TaskOutput']);
+const KILLS = new Set(['KillShell', 'KillBash', 'TaskStop']);
+
+/** The text of a tool_result's content, whichever of its two shapes it came in. */
+function textOf(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => (typeof part?.text === 'string' ? part.text : '')).join('\n');
+  }
+  return '';
+}
+
+function shellIdOf(input) {
+  const id = input?.bash_id ?? input?.shell_id ?? input?.task_id ?? input?.id;
+  return typeof id === 'string' && id ? id : null;
+}
+
+export class BackgroundShells {
+  constructor() {
+    /** tool_use id of each background `Bash` → { command, shellId, done }. */
+    this.started = new Map();
+    /** tool_use id of each read → the shell id it read. */
+    this.reads = new Map();
+  }
+
+  /** One stream-json event. Anything that is not about a shell is ignored. */
+  observe(event) {
+    const parts = event?.message?.content;
+    if (!Array.isArray(parts)) return;
+    if (event.type === 'assistant') {
+      for (const part of parts) {
+        if (part?.type !== 'tool_use') continue;
+        if (part.name === 'Bash' && part.input?.run_in_background === true) {
+          this.started.set(part.id, {
+            command: String(part.input.command ?? '').trim(),
+            shellId: null,
+            done: false,
+          });
+        } else if (READS.has(part.name)) {
+          const id = shellIdOf(part.input);
+          if (id) this.reads.set(part.id, id);
+        } else if (KILLS.has(part.name)) {
+          this.finish(shellIdOf(part.input));
+        }
+      }
+      return;
+    }
+    if (event.type === 'user') {
+      for (const part of parts) {
+        if (part?.type !== 'tool_result') continue;
+        const text = textOf(part.content);
+        const launched = this.started.get(part.tool_use_id);
+        if (launched && !launched.shellId) {
+          const id = /\bID:?\s*([A-Za-z0-9_-]+)/.exec(text);
+          if (id) launched.shellId = id[1];
+          continue;
+        }
+        const read = this.reads.get(part.tool_use_id);
+        if (read) {
+          // Over only when the read says so; a read of a command still going
+          // is the command still going.
+          if (!/<status>\s*running\s*<\/status>|\bstatus:\s*running\b/i.test(text)) {
+            this.finish(read);
+          }
+        }
+      }
+    }
+  }
+
+  finish(shellId) {
+    if (!shellId) return;
+    for (const each of this.started.values()) {
+      if (each.shellId === shellId) each.done = true;
+    }
+  }
+
+  /** The commands started in the background whose end this session never saw. */
+  unfinished() {
+    return [...this.started.values()].filter((each) => !each.done).map((each) => each.command);
+  }
+}

package/lib/codex.mjs

@@ -120,6 +120,11 @@ export function codexArgs({
     if (server.disabledTools?.length) {
       args.push('-c', `${key}.disabled_tools=${tomlValue(server.disabledTools)}`);
     }
+    // How long one call may take before Codex gives up on it — 60 s unless
+    // set, which is shorter than a person answering a question.
+    if (server.toolTimeoutSec) {
+      args.push('-c', `${key}.tool_timeout_sec=${tomlValue(server.toolTimeoutSec)}`);
+    }
     args.push('-c', `${key}.default_tools_approval_mode="approve"`);
   }
   if (resumeId) {

package/lib/roadmap-format.mjs

@@ -255,6 +255,23 @@ export function parseRoadmap(text) {
         entry.afterRefs = tokens.map(({ ref }) => ref);
         continue;
       }
+      const tags = /^Tags:\s*(.+)$/.exec(line.trim());
+      if (tags) {
+        // R315. Already normalised by the server (lowercase, no `#`) by the
+        // time it reaches the file, so a plain split is the whole rule.
+        entry.tags = tags[1].split(/[,\s]+/).map((t) => t.trim()).filter(Boolean);
+        continue;
+      }
+      // R315. Computed, never stored, and never sent by import.mjs — the same
+      // arrangement as `Development:` above. Kept as the exact text so a file
+      // parsed and re-rendered without asking the API again is still a fixed
+      // point; `renderEntry` recomputes the same text from a live `origin`
+      // object when there is one.
+      const origin = /^Origin:\s*(.+)$/.exec(line.trim());
+      if (origin) {
+        entry.origin = origin[1].trim();
+        continue;
+      }
       const sprint = /^Sprint:\s*S(\d+)\s*(.*)$/.exec(line.trim());
       if (sprint) {
         // R257: `Sprint: S1 Notifications` — the sprint's number and its name
@@ -360,6 +377,33 @@ export function renderRoadmap(entries, { preamble, sectionOrder = [] }) {
   return parts.join('\n').replace(/\n+$/, '') + '\n';
 }
 
+/**
+ * The word `Origin:` writes — R315. `entry.origin` is a plain string once it
+ * has round-tripped through the file (see the parser above); freshly off the
+ * API it is `{kind, label, url}`, and this is the one place that turns the
+ * second into the first, so the two paths render identically.
+ */
+function originWord(origin) {
+  if (typeof origin === 'string') {
+    return origin;
+  }
+  if (!origin || origin.kind === 'NONE') {
+    return null;
+  }
+  switch (origin.kind) {
+    case 'SONARQUBE':
+      return 'SonarQube';
+    case 'FEEDBACK':
+      return 'Feedback';
+    case 'APPLICATION':
+      return origin.label ? `An application (${origin.label})` : 'An application';
+    case 'SESSION':
+      return origin.label ? `A session (${origin.label})` : 'A session';
+    default:
+      return null;
+  }
+}
+
 function renderEntry(entry) {
   const lines = [`### ${entryRef(entry)} — ${entry.title}`, ''];
 
@@ -425,6 +469,14 @@ function renderEntry(entry) {
       .map(({ ref }) => ref);
     lines.push(`After: ${written.join(', ')}`);
   }
+  if (entry.tags?.length) {
+    // R315. Sorted, so the export does not churn on the set's own order.
+    lines.push(`Tags: ${[...entry.tags].sort().join(', ')}`);
+  }
+  const origin = originWord(entry.origin);
+  if (origin) {
+    lines.push(`Origin: ${origin}`);
+  }
   if (entry.sprint) {
     // R257. A line on the card and never a heading: the section is where the
     // file groups, and a sprint is a set a person opened across sections. The

package/mcp/server.mjs

@@ -665,6 +665,13 @@ const TOOLS = [
             'Cards this one starts coding after — it waits in the queue until every one of ' +
             'them is MERGED or SHIPPED. Refs, as `related`. Same project, must exist, never itself.',
         },
+        tags: {
+          type: 'array',
+          items: { type: 'string' },
+          description:
+            'Free words — lowercase, letters/digits/./_/-, up to 32 characters, at least one ' +
+            'letter, at most 12. The leading # is optional and stripped.',
+        },
       },
       required: ['title'],
     },
@@ -674,7 +681,7 @@ const TOOLS = [
         method: 'POST',
         body: pick(args, [
           'title', 'body', 'status', 'branch', 'merge', 'version', 'reason', 'section', 'related',
-          'after', 'sprint',
+          'after', 'sprint', 'tags',
         ]),
       });
       return `Created ${refOf(entry)} in ${slug}.\n\n${formatEntry(entry, {})}`;
@@ -734,6 +741,13 @@ const TOOLS = [
           items: { type: ['string', 'integer'] },
           description: 'Refs — R12, i15; a bare number is a roadmap card (R221).',
         },
+        tags: {
+          type: 'array',
+          items: { type: 'string' },
+          description:
+            'Free words — lowercase, letters/digits/./_/-, up to 32 characters, at least one ' +
+            'letter, at most 12. The leading # is optional and stripped.',
+        },
       },
       required: ['title', 'severity'],
     },
@@ -741,7 +755,7 @@ const TOOLS = [
       const slug = await resolveProject(config, args.project);
       const issue = await api(config, `/api/projects/${slug}/issues`, {
         method: 'POST',
-        body: pick(args, ['title', 'body', 'severity', 'status', 'related']),
+        body: pick(args, ['title', 'body', 'severity', 'status', 'related', 'tags']),
       });
       return `Filed ${refOf(issue)} in ${slug}.\n\n${formatEntry(issue, {})}`;
     },
@@ -779,7 +793,7 @@ const TOOLS = [
   {
     name: 'roadmap_update',
     description:
-      'Edit an entry\'s title, body, section, sprint, related refs or the cards it starts ' +
+      'Edit an entry\'s title, body, section, sprint, tags, related refs or the cards it starts ' +
       'after. Use roadmap_set_status to move it.',
     inputSchema: {
       type: 'object',
@@ -813,6 +827,12 @@ const TOOLS = [
             'them is MERGED or SHIPPED. Refs, as `related`. Same project, must exist, never ' +
             'itself. [] clears it.',
         },
+        tags: {
+          type: 'array',
+          items: { type: 'string' },
+          description:
+            'Free words — same rule as roadmap_create. Leave out to leave them alone; [] clears them.',
+        },
       },
       required: ['number'],
     },
@@ -821,7 +841,7 @@ const TOOLS = [
       const entry = await api(config, `/api/projects/${slug}/roadmap/${args.number}`, {
         method: 'PATCH',
         // pick keeps a present 0, which is how a card leaves its sprint.
-        body: pick(args, ['title', 'body', 'section', 'related', 'after', 'sprint']),
+        body: pick(args, ['title', 'body', 'section', 'related', 'after', 'sprint', 'tags']),
       });
       return `Updated ${refOf(entry)}.\n\n${formatEntry(entry, {})}`;
     },
@@ -2065,6 +2085,23 @@ function refOf(entry) {
   return entry.ref ?? ((entry.kind === 'ISSUE' ? 'i' : 'R') + entry.number);
 }
 
+/**
+ * The word `formatEntry` prints for a card's origin — R315. Never stored,
+ * always the object shape `{kind, label, url}` off the API — unlike
+ * `roadmap-format.mjs`'s own copy, which also has to read one back out of a
+ * file.
+ */
+function originWord(origin) {
+  if (!origin || origin.kind === 'NONE') return null;
+  switch (origin.kind) {
+    case 'SONARQUBE': return 'SonarQube';
+    case 'FEEDBACK': return 'Feedback';
+    case 'APPLICATION': return origin.label ? `an application (${origin.label})` : 'an application';
+    case 'SESSION': return origin.label ? `a session (${origin.label})` : 'a session';
+    default: return null;
+  }
+}
+
 function formatEntry(entry, { brief, comments, plan }) {
   const lines = [`${refOf(entry)} — ${entry.title}`, `  status: ${entry.statusDisplay}`];
   if (entry.branch) lines.push(`  branch: ${entry.branch}`);
@@ -2072,6 +2109,9 @@ function formatEntry(entry, { brief, comments, plan }) {
   if (entry.version) lines.push(`  version: ${entry.version}`);
   if (entry.declinedReason) lines.push(`  declined because: ${entry.declinedReason}`);
   if (entry.section) lines.push(`  section: ${entry.section}`);
+  // R315. Sorted for the same reason the export is: a reader's shape must not
+  // depend on the set's own insertion order.
+  if (entry.tags?.length) lines.push(`  tags: ${[...entry.tags].sort().map((t) => `#${t}`).join(' ')}`);
   // R257. Always printed when the card has one, so a reader's shape does not
   // depend on which tool printed the card; a closed sprint says so.
   if (entry.sprint) {
@@ -2108,6 +2148,12 @@ function formatEntry(entry, { brief, comments, plan }) {
     lines.push(`  written by: a ${entry.createdBy.profile} session, `
       + `under ${entry.createdBy.startedByEmail}`);
   }
+  // R315. Never null on the wire — NONE is a person at the console — so only
+  // ever printed when it says something. Beside `written by` rather than
+  // instead of it: origin says the DOOR, and the session line above already
+  // says who and what kind, when the door was a session.
+  const origin = originWord(entry.origin);
+  if (origin) lines.push(`  origin: ${origin}`);
   if (!brief && entry.body) lines.push('', entry.body);
   // R124, between the body and the discussion — the order they are read in:
   // what we want, how we mean to get it, and the argument about both.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cawdev-cli",
-  "version": "1.0.5-beta",
+  "version": "1.0.6-beta",
   "description": "cawdev's terminal client and runner daemon — zero dependencies, on purpose",
   "type": "module",
   "bin": {

package/runner/README.md

@@ -101,8 +101,8 @@ with the window — there `q` stops it, and asks first when sessions are live.
 machine is configured, most changes are smaller than that. **Inside the
 terminal, press `c`** (or type `/config`): a picker over what this machine does
 — add a project, add a workspace, each agent with its current state ("Disable
-claude", "Enable codex"), the console-rules switch, and the config itself with the
-token cut short. Every row is one of the shell commands below, driven through
+claude", "Enable codex"), the console-rules switch, **Stop serving** each
+project, and the config itself with the token cut short. Every row is one of the shell commands below, driven through
 the terminal's own line editor and picker; `esc` anywhere in a step changes
 nothing. The screen edits the file the daemon says it booted from (the hello
 carries `configPath` since R288), so an older daemon is told to restart rather
@@ -126,6 +126,7 @@ is for scripts and for a machine with no daemon to attach to:
 cawdev config                          a menu, the same Select widget as everywhere else
 cawdev config add-project              serve one more project you can write to
 cawdev config add-workspace            another checkout for a project already served
+cawdev config remove-project <slug>    stop serving a project; its checkouts stay on disk
 cawdev config agent enable|disable <claude|agy|codex>
 cawdev config rules on|off             accept permission rules from the console — R126
 cawdev config show                     this machine's config, token redacted
@@ -230,7 +231,8 @@ removes.
 `/logout` forgets it along with the session.
 
 **A paste stays one line.** Paste four hundred lines and the input shows
-`[pasted, 342 lines]`; all of it is sent. A paste that scrolled the transcript
+`[pasted, 342 lines]`; all of it is sent — into a prompt or into a command alike
+(`/new plan <paste>`, `/card <paste>`), its line breaks kept (`commandWords`). A paste that scrolled the transcript
 away would bury the thing this program exists to keep.
 
 Under `NO_COLOR` it is the same terminal without the colour: the picker still
@@ -359,8 +361,17 @@ project this machine serves included ("nothing planned" is an answer) — one
 small box each, titled with the card and its status — `R3 (Planned)` — the cards of
 every project this machine serves that are ready to be developed, read again
 every thirty seconds. **`d`** lists them and develops the one you pick, on this
-machine and on the card's own branch; `/new dev` with nothing after it does the
-same anywhere, and `/new dev R3` goes straight to one.
+machine and on the card's own branch — except on a finished plan's window, where
+it is that plan's `/develop` (below) with no list; `/new dev` with nothing after it does the
+same anywhere, and `/new dev R3` goes straight to one. A full-width rule
+under the strip separates the board from the session windows; it comes out of
+the strip's own rows, never the windows'.
+
+**`/refresh`** reads the cards again now rather than on the next tick, and
+says what it found per project — `saasng: 5 considering · 2 planned · 1 in
+development` — and which project could not be read, and why. A project that
+cannot be read keeps its last cards and no other's: one unreadable slug used
+to leave every column of every project at 0, silently.
 
 **Four windows at most.** Past four, the rest are named on one line above the
 prompt — number, kind, state, card, in the state's colour — and `tab` (or the
@@ -371,8 +382,15 @@ recently looked at first.
 A window stays up when its session ends, and its last line says what can be
 done next:
 
-- **`/develop`** on a finished plan starts the development of its card, on
-  this machine (the branch is the card's own).
+- **`d`** or **`/develop`** on a finished plan — the window says `d develops R2
+  here, in place of this plan` — starts the development of its card, on
+  this machine (the branch is the card's own). `/develop R30` names another
+  card, `@slug` its project, and `--codex`/`--claude`/`--agy` the agent —
+  otherwise the agent that PLANNED the card when its finished plan has a
+  window here, else `/agent`'s choice, exactly as `/new dev R30` does, because
+  it IS that command. Once the development has started the plan's window
+  closes, and the development's window takes its focus when this machine
+  takes the run; a start the platform refused leaves the plan's window up.
 - **`/pr`** on a finished session that wrote a branch opens its pull request
   (`POST runs/{id}/pull-request` — through the card's work item, or from the
   run itself for a session started from a sentence): this machine pushes the
@@ -395,7 +413,18 @@ done next:
   project's runs, kept when `carriesOnHere` — yours, `canCarryOn`, and its
   checkout on this machine or none), listed in the scrollback, and given a
   window that opens on why it stopped.
-- **`/open`** opens the pull request in your browser.
+- **Finished, having built nothing** — a dev session that ended FINISHED
+  with no commit (IMPLEMENT stopped on a plan it would not follow, say) —
+  reads `finished · nothing built`, in amber rather than green, offers no
+  `/pr` but the re-plan instead, and its window shows its summary, where it
+  said why (`builtNothing`; the terminal reads the run's commits once it
+  ends, and claims nothing until it has).
+- **`/open`** opens the pull request in your browser. It reads the run again
+  first — the runner records the link after the run is FINISHED, so the copy
+  taken at that moment has none — and falls back to the card's work item.
+  On a finished PLAN, which opens no pull request, it opens the card on cawdev
+  instead — `roadmap/R2?show=plan` (`issues/…` for an issue) — with the plan
+  of record unfolded and scrolled to: that plan is what the session produced.
 - **`/drop`** deletes the checkout the session was cloned into, when it was one
   made on demand (below): asked first, naming the path, and refused while a
   run is in it or holds it, with uncommitted files, or with a commit origin
@@ -424,6 +453,21 @@ sentence; `--anyway` starts it regardless, the same decision the console's
 panel asks for. All four commands need you signed in (`/login`), and they work
 outside advanced mode too, on the session you are watching.
 
+**The prompt says which window it acts on.** In advanced mode the line at the
+bottom leads with the focused window's number — `[2] cawdev ▸ /pr`, `[2]
+enter prompts “…”` — and a command's answer keeps the number of the window it
+was about (`[2] A session on … is running`), so a note left on screen after
+the focus moved still says whose it was.
+
+**A project deleted in the console is not offered.** The config on this
+machine still names it, and nothing on the platform can change that file, so
+the terminal asks: a served project whose roadmap read answers 404 — deleted,
+or your access went — is left out of the picker, the strip, `/new` and `/card`,
+and one line says so, once, after the mode is on screen. `c` → **Stop serving
+ngsign** (`cawdev config remove-project ngsign`) takes it out of the config;
+the checkouts stay where they are, and the daemon stops polling for it at its
+next restart, because `projects` is read at boot.
+
 **Which projects it shows is yours to pick.** `/advanced-mode` on a machine
 serving several projects opens a picker with every one ticked — space (or a
 digit) ticks and unticks, `a` all or none, enter confirms — and only the
@@ -432,16 +476,73 @@ projects ticked are drawn: their windows, their roadmap on top, and the ones
 nothing; `/projects` asks again from inside the mode; `/reload` keeps the
 pick. A prompt never talks to a session of a project that is not shown.
 
+**↑ is history, as in a shell.** On a line nothing has been typed on yet —
+empty, or the bare `/` a command line opens with — ↑ and ↓ walk what was
+typed before (kept across launches, `history.mjs`); a command line walks only
+the commands. Once something is typed, the arrows move in the list of
+commands instead, and enter sends a recalled line as it is. Outside advanced
+mode ↑ with no line open recalls the last entry onto the line it belongs to;
+in advanced mode the wheel arrives as arrows, so there it is `/` or enter,
+then ↑.
+
+**`/view`** opens the focused session's page on cawdev — transcript, stages,
+card — in the browser, on the console this terminal signed in to.
+
+**`/view R29`** prints a card here instead: its status, section, tags, branch,
+work item and pull request, who is coding or reviewing it, what it is related
+to, its page on the web, and the first thirty lines of its body (`cardLines`,
+pure). `/view <words>` finds it by its title among the cards of the projects on
+screen and offers a list when several match; `@slug` names the project;
+**`/view card`** is the focused session's own card.
+
+**Which agent `/new` asks for.** `--claude`, `--codex` or `--agy` on a `/new`
+names that session's agent (`/new dev R12 --codex`); `/agent codex` makes it
+the terminal's choice for every `/new` after it, kept across launches
+(`prefs.mjs`, `~/.cawdev/terminal.json`) and shown in advanced mode's prompt
+title; `/agent default` hands the choice back to the project. A flag beats
+`/agent`, and with neither nothing is named — the project's default decides,
+as it always has. A name no runner spawns is refused, by `/agent` and by the
+platform alike, rather than spawned as Claude Code; `/agent codex` on a
+machine that does not list codex says so (`c` → Enable codex). The window's
+`Codex · GPT-5-codex` line says which one actually ran.
+
+**A stage asks rather than stops.** A decision that is the person's — a scope
+the card leaves open, a plan the code has moved away from — is asked with
+`ask_user`, and the stage carries on with the answer; PLAN asks before it
+writes, so a plan never hands IMPLEMENT an open question, and IMPLEMENT asks
+when its plan is wrong or incomplete instead of stopping (`ASK_DONT_STOP`).
+Codex is given the time to: cawdev's MCP server gets `tool_timeout_sec` 660 on
+its side, longer than `ask_user`'s ten-minute wait — Codex's own default of
+60 s cut every question off before anybody could answer it.
+
+**Codex and Antigravity write only on a machine that allows everything.**
+Neither has per-command permissions — Codex's sandbox is read-only, blocks the
+network (no push) or is off — so a session of theirs that writes is refused,
+unspawned, until the machine accepts console rules AND "Allow everything" is
+ticked on it. The refusal says so in steps, for this machine
+(`needsEverything`, lib/agents.mjs): which of the two is done, the Runners page
+on this console, the command to start it again — and it is written on the
+run's transcript as well as its summary, so the window shows it; a failed
+window prints its run's summary (`sayWhyItFailed`) rather than just "failed".
+
+**`/card <the idea in words>`** writes a card in **Considering** and starts
+nothing — no session, no branch, nothing spent: the roadmap's first column
+is where an idea waits to be decided on, and writing one down does not need
+a model. Titled by its words (`cardTitleFor`), the whole text in its body;
+the project chosen exactly as `/new` chooses it (`@project`, else advanced
+mode narrowed to one, else asked).
+
 **Across the top, the roadmap** (`roadmapStrip`): every project this machine
-serves as a small board — Considering, Planned, In development, Merged side
-by side, one line per card, `●` on a card with a session running now;
-Shipped and Declined, which only grow, are counts beside the project's name,
-as on the console's board. As tall as the fullest column, never more than a
+serves as a small board — Considering, Planned and In development side by
+side, one line per card, `●` on a card with a session running now; Merged,
+Shipped and Declined — work that is over, and only grows — are counts beside
+the project's name (`1 merged · 2 shipped`), as the console's board folds its
+own last columns. As tall as the fullest column, never more than a
 third of the screen, and gone before the windows are on a short terminal.
 When the room runs out it is SAID: a column ends in `+N more`, empty columns
-go first when the width does, then whole columns (Merged, then Considering,
-then Planned — In development stays longest), named in the header as
-`merged 3 hidden`, then projects, counted as `+N projects`. Read every 30 s.
+go first when the width does, then whole columns (Considering, then Planned —
+In development stays longest), named in the header as `considering 3
+hidden`, then projects, counted as `+N projects`. Read every 30 s.
 
 **A window says which agent and which model** — `Claude · Opus 5.5`,
 `Codex · GPT-5-codex` — bold and underlined at the head of its second line
@@ -451,16 +552,25 @@ announces on `init`, and per STAGE on a walked run, since each stage is its
 own process. An ended one's is the platform's. No model named reads
 `default model` — the CLI's own choice — rather than a guess.
 
-**A dev window says where it is working**: its second line is the project and
-the absolute path of the checkout (`subtitleFor`) — on a machine with
-`saasng` and its `-auto-N` clones, the one directory to open. Cut from the
-left when narrow, so the end of the path survives.
+**A window's project has a line of its own**, the second, under the title
+(`subtitleFor`) — at the end of the title a long card name pushed it out of
+sight. **A dev window adds where it is working**: the project and the absolute
+path of the checkout — on a machine with `saasng` and its `-auto-N` clones, the
+one directory to open. Cut from the left when narrow, so the end of the path
+survives.
 
 **The prompt shows what is open, not what was.** A question is the prompt's
 banner alone, whole and wrapped between words, and it goes the moment it is
 answered — here or in the console. A permission request's lines are tagged
 with it (`sayAbout`) and leave when it is decided.
 
+**A question says which window it came from.** With four sessions on screen,
+"waiting for an answer" is not enough to know whose. A question or a
+permission request names its session (`sessionTag`) — `2 · dev · R3 Client
+mail… — saasng`: the window's number, its kind, its card and its project — in
+the line announcing it, in the title of the picker that answers it, and above
+the banner. The card is cut to 32 columns so the question itself still fits.
+
 ### Checkouts made on demand: `autoWorkspaces`
 
 `"autoWorkspaces": 3` in the machine's config lets the daemon CLONE up to three
@@ -853,6 +963,19 @@ files at all. R47 removes the need for this by giving each run a workspace.
    writes to git: no merging, no branch deletion, no pushing. (A project's own
    rules can ask for all three — see below — but that is a queued action with a
    name on it, not something the survey does in passing.)
+7b. **A stage is not done while its commands are still running.** A stage is
+   one turn, closed the moment the turn ends, so a test suite started with
+   `run_in_background` and never waited for is a result lost. The daemon
+   follows the session's background shells (`lib/background-shells.mjs`:
+   `Bash` with `run_in_background`, `BashOutput`, `KillShell`); a stage whose
+   turn ends with one still running, or finished and never read, is reported
+   FAILED with the commands named, and the run fails with it — keeping its
+   checkout and its session (R80), so **`/continue` picks it up**. Where it
+   resumes is the platform's (R263: the claim's lifecycle starts at the first
+   stage not DONE, with what the DONE ones said); what the daemon adds is WHY
+   the stage stopped — the re-run is handed that and told to run its commands
+   in the foreground. IMPLEMENT and TEST are also told up front to
+   wait for every command, and TEST to commit — no stage after it writes code.
 8. **Reports the lifecycle back** and, if the session dies without saying
    anything, ends the run rather than leaving it `RUNNING` forever.