cawdev-cli 1.0.9-beta → 1.0.11-beta

package/lib/background-shells.mjs

@@ -17,6 +17,15 @@
  * - `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.
+ * And a delegation started in the background: `Agent` (or `Task`) with
+ * `run_in_background: true`, or whose result says "Async agent launched" —
+ * its id is the result's `agentId: <id>`. It is over when a `<task-notification>`
+ * naming that id arrives with a status other than running, when a
+ * `TaskOutput` read says so, or when `TaskStop` ends it. R6 on saasng is why:
+ * IMPLEMENT handed the whole card to two background agents, said "both agents
+ * are still working in the background" and ended its turn; the walk marched on
+ * and the run FINISHED with nothing built.
+ *
  * 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.
@@ -26,6 +35,7 @@
  */
 
 const READS = new Set(['BashOutput', 'TaskOutput']);
+const DELEGATES = new Set(['Agent', 'Task']);
 const KILLS = new Set(['KillShell', 'KillBash', 'TaskStop']);
 
 /** The text of a tool_result's content, whichever of its two shapes it came in. */
@@ -44,15 +54,19 @@ function shellIdOf(input) {
 
 export class BackgroundShells {
   constructor() {
-    /** tool_use id of each background `Bash` → { command, shellId, done }. */
+    /** tool_use id of each background `Bash` or `Agent` → { command, shellId, done }. */
     this.started = new Map();
+    /** tool_use id of each `Agent` call not yet known to be in the background → its label and input. */
+    this.delegations = 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;
+    const content = event?.message?.content;
+    if (event?.type === 'user') this.notified(textOf(content));
+    const parts = content;
     if (!Array.isArray(parts)) return;
     if (event.type === 'assistant') {
       for (const part of parts) {
@@ -63,6 +77,9 @@ export class BackgroundShells {
             shellId: null,
             done: false,
           });
+        } else if (DELEGATES.has(part.name)) {
+          const label = `Agent: ${String(part.input?.description ?? part.input?.subagent_type ?? 'a delegation').trim()}`;
+          this.delegations.set(part.id, { label, background: part.input?.run_in_background === true });
         } else if (READS.has(part.name)) {
           const id = shellIdOf(part.input);
           if (id) this.reads.set(part.id, id);
@@ -76,6 +93,17 @@ export class BackgroundShells {
       for (const part of parts) {
         if (part?.type !== 'tool_result') continue;
         const text = textOf(part.content);
+        const delegation = this.delegations.get(part.tool_use_id);
+        if (delegation) {
+          this.delegations.delete(part.tool_use_id);
+          // A foreground delegation's result IS its end; only one that came
+          // back as "launched" is still out there.
+          if (delegation.background || /async agent launched/i.test(text)) {
+            const id = /\bagentId:?\s*([A-Za-z0-9_-]+)/i.exec(text);
+            this.started.set(part.tool_use_id, { command: delegation.label, shellId: id ? id[1] : null, done: false });
+          }
+          continue;
+        }
         const launched = this.started.get(part.tool_use_id);
         if (launched && !launched.shellId) {
           const id = /\bID:?\s*([A-Za-z0-9_-]+)/.exec(text);
@@ -94,6 +122,20 @@ export class BackgroundShells {
     }
   }
 
+  /**
+   * The CLI tells a session that a background task ended with a
+   * `<task-notification>` in a user turn — `<task-id>` and `<status>`. Any
+   * status but running is over: a failed or killed agent is not one to wait for.
+   */
+  notified(text) {
+    if (!text || !text.includes('<task-notification>')) return;
+    for (const block of text.split('<task-notification>').slice(1)) {
+      const id = /<task-id>\s*([^<\s]+)\s*<\/task-id>/.exec(block);
+      const status = /<status>\s*([^<\s]+)\s*<\/status>/.exec(block);
+      if (id && status && status[1].toLowerCase() !== 'running') this.finish(id[1]);
+    }
+  }
+
   finish(shellId) {
     if (!shellId) return;
     for (const each of this.started.values()) {
@@ -101,7 +143,7 @@ export class BackgroundShells {
     }
   }
 
-  /** The commands started in the background whose end this session never saw. */
+  /** The commands and delegations 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/roadmap-format.mjs

@@ -56,11 +56,13 @@ export function statusToDisplay(status) {
  * The file has always grouped these two this way, and deriving them means a
  * declined entry cannot end up filed under a phase it is no longer part of.
  *
- * Two, and REVIEW is deliberately not a third: work waiting to be read is still
+ * Three since R371 — BACKLOG joined — and REVIEW is deliberately not a fourth: work waiting to be read is still
  * part of the phase it belongs to, and moving it to a section of its own would
  * take it out of its phase for a few days and put it back afterwards.
  */
 export const STATUS_SECTIONS = {
+  // R371: waiting to be brought in, before what is being considered.
+  BACKLOG: 'Backlog — waiting to be brought in',
   CONSIDERING: 'Considering — wanted, not settled',
   DECLINED: 'Declined — decided against, with the reason',
 };
@@ -77,6 +79,8 @@ export const STATUS_SECTIONS = {
 export const ISSUE_SECTIONS = {
   NEW: 'New — filed, not yet triaged',
   CONFIRMED: 'Confirmed — real, waiting for somebody',
+  // R371: an issue waiting to be brought in — after what needs somebody now.
+  BACKLOG: 'Backlog — waiting to be brought in',
   IN_DEVELOPMENT: 'In development — somebody is fixing it',
   MERGED: 'Resolved — the fix landed',
   SHIPPED: 'Released — the fix shipped',
@@ -249,6 +253,12 @@ export function parseRoadmap(text) {
         entry.targetVersion = target[1].trim();
         continue;
       }
+      // R378. The versions an issue was found in, comma separated.
+      const affects = /^Affects:\s*(.+)$/.exec(line.trim());
+      if (affects) {
+        entry.affectedVersions = affects[1].split(',').map((v) => v.trim()).filter(Boolean);
+        continue;
+      }
       const estimate = /^Estimate:\s*(.+)$/.exec(line.trim());
       if (estimate) {
         const n = Number(estimate[1].trim());
@@ -530,6 +540,10 @@ function renderEntry(entry) {
   if (entry.targetVersion && !entry.version) {
     lines.push(`Target: ${entry.targetVersion}`);
   }
+  // R378. Where an issue was found; history, so it stays once the issue ships.
+  if (entry.affectedVersions?.length) {
+    lines.push(`Affects: ${entry.affectedVersions.join(', ')}`);
+  }
 
   // Each status writes only what it currently claims. A MERGED entry keeps its
   // branch in the database as history, but the file must not print it: the

package/lib/runner-config.mjs

@@ -76,7 +76,7 @@ function canonical(value) {
   if (value === undefined) return 'undefined';
   return JSON.stringify(value, (_, inner) => (
     inner && typeof inner === 'object' && !Array.isArray(inner)
-      ? Object.fromEntries(Object.keys(inner).sort().map((key) => [key, inner[key]]))
+      ? Object.fromEntries(Object.keys(inner).sort((a, b) => a.localeCompare(b)).map((key) => [key, inner[key]]))
       : inner
   ));
 }

package/mcp/README.md

@@ -81,6 +81,15 @@ commit, or a sha — `SHIPPED` needs a version that is a real git tag, and
 request it would otherwise carry belongs to the run, and a project that reviews
 without opening pull requests has none to give it.
 
+**A card you file may land in the `BACKLOG`** (R371). Where a new card goes
+when you name no status is the project's rule, per door, and the default for a
+card or issue an agent files is the backlog: waiting until a person or a sprint
+brings it in, in no sprint and on no board column. Its origin names your
+session and the card your run was on. A plan session's card lands where the console's
+do (R380). Name a status (`CONSIDERING`, `NEW`) when
+you mean the pipeline. Giving a backlog card a sprint moves it to the first
+status of its kind; moving a card to `BACKLOG` takes it out of its sprint.
+
 **Any status may move to any other.** There is no transition diagram — an entry
 really can go from `CONSIDERING` straight to `SHIPPED` if that is what happened.
 The rules are about what a status *carries*, not the path it took.
@@ -163,11 +172,12 @@ what you are allowed to do.
 | `roadmap_list` | Entries, optionally by status. `brief` omits bodies — use it to survey. |
 | `roadmap_get` | One entry in full: its body, **the plan agreed for it**, and the discussion on it. |
 | `roadmap_create` | Create an entry; the platform allocates its permanent number. |
-| `roadmap_update` | Title, body, section, related ids, the cards it starts coding after (`after` — R181), when it is due and how big it is (`due` — R351: an ISO date, `""` clears; `estimate`: a positive number, `0` clears), the version it is meant for (`targetVersion` — R358, `""` clears; since R362 it must be one the project defined under Project settings → Versions, and any other name is refused), and who it is assigned to (`assignee` — R331: a username, `""` clears; `roadmap_list`/`issue_list` take `assignee` too, and `me` means the token's owner). |
+| `roadmap_update` | Title, body, section, related ids, the cards it starts coding after (`after` — R181), when it is due and how big it is (`due` — R351: an ISO date, `""` clears; `estimate`: a positive number, `0` clears), the version it is meant for (`targetVersion` — R358, `""` clears; since R362 it must be one the project defined under Project settings → Versions, and any other name is refused), the versions an issue was found in (`affectedVersions` — R378, issues only: names the project defined or shipped in, `[]` clears), and who it is assigned to (`assignee` — R331: a username, `""` clears; `roadmap_list`/`issue_list` take `assignee` too, and `me` means the token's owner). |
 | `roadmap_comment` | Say something *beside* an entry rather than inside it. |
+| `done_when_tick` | Tick (or untick) one numbered item of the card's Done-when checklist as built, with one line of evidence (R368). `task_current` lists the items. Defaults to the run's own card and refuses another; the reviewer's column is a person's and no token can set it. |
 | `roadmap_set_status` | Move an entry, carrying whatever the status requires. |
 | `roadmap_decline` | Decline with a reason. The only exit. |
-| `backlog_file` | File **feedback**, not a card — something a person should decide about. A WRITER accepts it as a card or an issue, or refuses it (R199). |
+| `backlog_file` | File **feedback**, not a card — something a person should decide about. A WRITER accepts it as a card or an issue, or refuses it (R199). Tagged `agent` as a source, plus any `tags` you pass — `customer` when you relay what a user said (R372). |
 | `changelog_list` | The changelog, grouped by release, newest first. |
 | `changelog_get` | One entry. |
 | `changelog_add` | Add an entry; no version means `Unreleased`. |

package/mcp/server.mjs

@@ -412,6 +412,7 @@ const TOOLS = [
         status: {
           type: 'string',
           enum: [
+            'BACKLOG',
             'CONSIDERING',
             'PLANNED',
             'NEW',
@@ -621,13 +622,71 @@ const TOOLS = [
     },
   },
 
+  {
+    name: 'done_when_tick',
+    description:
+      "Tick (or untick) one item of the card's Done-when checklist as built. Items are " +
+      "numbered from 1 as task_current lists them. Call it when you have BUILT the item and " +
+      'CHECKED it, with one line of evidence — a test name, a command, a file:line. Do not ' +
+      'tick what you did not check: the reviewer ticks their own column separately and sees ' +
+      'yours. Defaults to the card this run is working on, and a run cannot tick another.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ...PROJECT_ARGUMENT,
+        number: {
+          type: ['string', 'integer'],
+          description:
+            'The card by ref — R91, i91. Optional inside a run: defaults to the run\'s own card.',
+        },
+        item: { type: 'integer', minimum: 1, description: "The item's number, from 1." },
+        done: { type: 'boolean', description: 'false takes the tick back. Default true.' },
+        note: {
+          type: 'string',
+          description: 'One line of evidence: a test name, a command, a file:line.',
+        },
+      },
+      required: ['item'],
+    },
+    handler: async (config, args) => {
+      let slug;
+      let ref = args.number;
+      if (ref === undefined || ref === null || ref === '') {
+        const { runId, project } = await requireRun(config);
+        const run = await api(config, `/api/projects/${project}/runs/${runId}`);
+        ref = run.entryRef ?? run.entryNumber;
+        slug = project;
+      } else {
+        slug = await resolveProject(config, args.project);
+      }
+      if (ref === undefined || ref === null || ref === '') {
+        throw new CawdevError('This run has no card, so there is no Done-when list to tick.');
+      }
+      if (!Number.isInteger(args.item) || args.item < 1) {
+        throw new CawdevError('item must be a whole number from 1, as task_current lists them.');
+      }
+      const done = args.done !== false;
+      const row = await api(config, `/api/projects/${slug}/roadmap/${encodeURIComponent(String(ref))}/done-when/${args.item}/built`, {
+        method: 'PUT',
+        body: { done, note: args.note },
+      });
+      return (
+        `${done ? 'Ticked' : 'Unticked'} item ${row.position} of ${ref} in ${slug} as built: ` +
+        row.text
+      );
+    },
+  },
+
   {
     name: 'roadmap_create',
     description:
       'Create a roadmap entry. The platform allocates its permanent number — written R91 on ' +
       'a roadmap card and i91 on an issue, one sequence across both — and the ' +
-      'platform decides where a card starts — CONSIDERING — unless you say otherwise; ' +
-      'a status that requires something must be given it.',
+      'project decides where a card you file starts — the BACKLOG by default for a card an ' +
+      'agent files, waiting until a person or a sprint brings it in — unless you say ' +
+      'otherwise; a status that requires something must be given it. A card in the BACKLOG ' +
+      'holds no sprint: giving it one moves it to CONSIDERING. A plan session\'s card lands ' +
+      'where the console\'s do (R380).',
     inputSchema: {
       type: 'object',
       properties: {
@@ -640,6 +699,7 @@ const TOOLS = [
         status: {
           type: 'string',
           enum: [
+            'BACKLOG',
             'CONSIDERING',
             'PLANNED',
             'IN_DEVELOPMENT',
@@ -733,7 +793,7 @@ const TOOLS = [
     description:
       'What is broken in a project, and how badly — R85. The same numbering as the roadmap, ' +
       'written with an i: card 91 filed as an issue is i91, and there is no R91 as well. ' +
-      'Statuses are NEW, CONFIRMED, IN_DEVELOPMENT, MERGED (drawn as ' +
+      'Statuses are BACKLOG, NEW, CONFIRMED, IN_DEVELOPMENT, MERGED (drawn as ' +
       'Resolved) and DECLINED (Won\'t fix).',
     inputSchema: {
       type: 'object',
@@ -741,7 +801,7 @@ const TOOLS = [
         ...PROJECT_ARGUMENT,
         status: {
           type: 'string',
-          enum: ['NEW', 'CONFIRMED', 'IN_DEVELOPMENT', 'MERGED', 'SHIPPED', 'DECLINED'],
+          enum: ['BACKLOG', 'NEW', 'CONFIRMED', 'IN_DEVELOPMENT', 'MERGED', 'SHIPPED', 'DECLINED'],
         },
         assignee: {
           type: 'string',
@@ -768,8 +828,10 @@ const TOOLS = [
   {
     name: 'issue_file',
     description:
-      'File an issue: something that is broken, with how badly. Lands at NEW — filed and not ' +
-      'yet triaged — unless you say CONFIRMED, which claims you have already checked it. The ' +
+      'File an issue: something that is broken, with how badly. Lands where the project says ' +
+      'for an issue an agent files — the BACKLOG by default, waiting to be brought in, or NEW ' +
+      '(filed and not yet triaged) — unless you say NEW, or CONFIRMED, which claims you have ' +
+      'already checked it. The ' +
       'severity is required: it is how the board is ordered. Use `related` to name the card it ' +
       'was found on, by ref (R84). Issues count on their own sequence — R221 — and are ' +
       'written with an i: i91 is the ninety-first issue, and R91 is another card.',
@@ -780,7 +842,7 @@ const TOOLS = [
         title: { type: 'string' },
         body: { type: 'string', description: 'Markdown. What happens, and what should instead.' },
         severity: { type: 'string', enum: ['CRITICAL', 'MEDIUM', 'MINOR'] },
-        status: { type: 'string', enum: ['NEW', 'CONFIRMED'] },
+        status: { type: 'string', enum: ['BACKLOG', 'NEW', 'CONFIRMED'] },
         related: {
           type: 'array',
           items: { type: ['string', 'integer'] },
@@ -805,6 +867,12 @@ const TOOLS = [
           description:
             'How much it matters; it does not reorder the board. Leave out for MEDIUM.',
         },
+        affectedVersions: {
+          type: 'array',
+          items: { type: 'string' },
+          description:
+            'Versions the project defined or shipped in where this issue was found — R378. Any other name is refused.',
+        },
       },
       required: ['title', 'severity'],
     },
@@ -812,7 +880,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', 'tags', 'assignee', 'priority']),
+        body: pick(args, ['title', 'body', 'severity', 'status', 'related', 'tags', 'assignee', 'priority', 'affectedVersions']),
       });
       return `Filed ${refOf(issue)} in ${slug}.\n\n${formatEntry(issue, {})}`;
     },
@@ -833,14 +901,25 @@ const TOOLS = [
         kind: { type: 'string', enum: ['ISSUE', 'FEATURE'] },
         title: { type: 'string' },
         body: { type: 'string', description: 'Markdown. What you noticed, and what should happen instead.' },
+        tags: {
+          type: 'array',
+          items: { type: 'string' },
+          description:
+            'Who it came from, beyond you — e.g. "customer" when you are passing on what a user ' +
+            'said. "agent" is always added: you filed it. Same word rule as card tags.',
+        },
       },
       required: ['kind', 'title', 'body'],
     },
     handler: async (config, args) => {
       const slug = await resolveProject(config, args.project);
+      // R372: feedback says who it came from, and an agent filing it is one
+      // of the sources. Added here, at the agent's own door, not by the API:
+      // an application's token files through the same endpoint and is not an agent.
+      const tags = [...new Set([...(Array.isArray(args.tags) ? args.tags : []), 'agent'])];
       const item = await api(config, `/api/projects/${slug}/backlog`, {
         method: 'POST',
-        body: pick(args, ['kind', 'title', 'body']),
+        body: { ...pick(args, ['kind', 'title', 'body']), tags },
       });
       return `Filed in ${slug}'s backlog as pending: "${item.title}". Somebody will accept it ` +
         'as a card or an issue, or refuse it.';
@@ -921,6 +1000,13 @@ const TOOLS = [
             'The card this one sits under (an epic), e.g. "R300". "" takes the card out of its ' +
             'parent; leave out to leave it alone. Same rules as roadmap_create.',
         },
+        affectedVersions: {
+          type: 'array',
+          items: { type: 'string' },
+          description:
+            'Issues only (R378): the versions the project defined or shipped in where it was found. ' +
+            'Leave out to leave them alone; [] clears them. A roadmap card refuses a non-empty list.',
+        },
       },
       required: ['number'],
     },
@@ -931,7 +1017,7 @@ const TOOLS = [
         // pick keeps a present 0, which is how a card leaves its sprint.
         body: pick(args, [
           'title', 'body', 'section', 'related', 'after', 'sprint', 'tags', 'assignee', 'priority',
-          'due', 'estimate', 'targetVersion', 'parent',
+          'due', 'estimate', 'targetVersion', 'parent', 'affectedVersions',
         ]),
       });
       return `Updated ${refOf(entry)}.\n\n${formatEntry(entry, {})}`;
@@ -959,6 +1045,7 @@ const TOOLS = [
         status: {
           type: 'string',
           enum: [
+            'BACKLOG',
             'CONSIDERING',
             'PLANNED',
             'NEW',
@@ -1170,6 +1257,12 @@ const TOOLS = [
         config,
         `/api/projects/${project}/roadmap/${cardRef}/plans`,
       ).catch(() => []);
+      // R368. The plan's Done-when list, numbered, with the ticks so far. Its
+      // own try, like the plan above: a platform without it answers 404.
+      const criteria = await api(
+        config,
+        `/api/projects/${project}/roadmap/${cardRef}/done-when`,
+      ).catch(() => []);
 
       const lines = [];
 
@@ -1212,6 +1305,9 @@ const TOOLS = [
         }
       }
       lines.push(formatEntry(entry, { comments, plan: plans?.[0] ?? null }));
+      if (criteria?.length) {
+        lines.push('', formatDoneWhen(criteria));
+      }
 
       // What happened the other times. A session is told the entry and the
       // branch but not that two previous runs on this card failed, which is
@@ -2259,6 +2355,8 @@ function formatEntry(entry, { brief, comments, plan }) {
   if (entry.estimate) lines.push(`  estimate: ${entry.estimate}`);
   // R358. Printed until the card ships; `version` says where it did.
   if (entry.targetVersion && !entry.version) lines.push(`  target: ${entry.targetVersion}`);
+  // R378. History, not plan: still printed once the issue has shipped.
+  if (entry.affectedVersions?.length) lines.push(`  affects: ${entry.affectedVersions.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) {
@@ -2340,6 +2438,22 @@ function formatPlan(plan) {
   return [`--- the plan (${written}) ---`, plan.body].join('\n');
 }
 
+/**
+ * R368. The Done-when list as an agent reads it: numbered as done_when_tick
+ * takes them, with each tick and its evidence. A reviewer's confirmation is
+ * shown too — it is the other column, and the agent should see it.
+ */
+export function formatDoneWhen(criteria) {
+  const lines = ['--- done when (tick each with done_when_tick once you have checked it) ---'];
+  for (const item of criteria) {
+    const mark = item.built ? '[built]' : '[ ]';
+    const note = item.built && item.builtNote ? ` — ${item.builtNote}` : '';
+    const confirmed = item.confirmed ? ' (confirmed by reviewer)' : '';
+    lines.push(`${String(item.position).padStart(2)}. ${mark} ${item.text}${note}${confirmed}`);
+  }
+  return lines.join('\n');
+}
+
 /**
  * One earlier attempt at this card — R38.
  *

package/package.json

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

package/runner/README.md

@@ -469,7 +469,7 @@ this machine serves — unless the command names it with `@project`, or
 advanced mode is narrowed to ONE project (`/projects`), which is a choice
 already made rather than a guess. Never guessed from the focused window, nor
 from a machine serving just one, since a session on the wrong project is a
-card planned or a branch cut in the wrong repository. `/new dev` alone and `d` list the planned cards of every project,
+card planned or a branch cut in the wrong repository. `/new dev` alone and `d` list the planned cards and the confirmed issues of every project,
 each with its own, so they ask nothing more. A usage window over this machine's threshold is refused in a
 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
@@ -510,6 +510,22 @@ then ↑.
 **`/view`** opens the focused session's page on cawdev — transcript, stages,
 card — in the browser, on the console this terminal signed in to.
 
+**On a session waiting for you** — a question, or a permission such as a stage
+gate whose summary is the whole plan — the prompt only has room for the start
+of it, and says so: `/view reads it all · /open answers it on cawdev`.
+**`/view`** then opens the READER: one window over the whole screen with the
+session's output and, under a rule, the request in full (the question and its
+options; the permission's summary, its input and its keys). It opens on the
+request; `↑`/`↓` (and the wheel), `PgUp`/`PgDn`, `g`/`G` scroll it, `esc`
+closes it, and any other key closes it and does what it always does — `a`
+answers, `y`/`s`/`n` decide. Outside advanced mode `/view` prints the request
+whole into the scrollback. When the question has options its list opens by
+itself and hides the banner; the list's own key line says `/view reads it all`,
+and `/` there leaves the list for the command line (`a` brings it back).
+**`/open`** opens the session's run page on cawdev,
+where the question panel and the decision are. `readerFrame` in split.mjs is
+the window, pure.
+
 **`/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`,
@@ -559,7 +575,12 @@ 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
+own last columns. The Backlog is a count there too, first (`3 backlog`): since
+R371 it is where a new issue lands, and it would be the first column to go. **Issues are on it too** (R85's other board, read from
+`/issues` beside `/roadmap`): a NEW issue sits in Considering and a CONFIRMED
+one in Planned — their counterparts — first in the column and most severe first,
+so a `+N more` never hides a critical defect, with the ref (`i12`) in the colour
+of its severity. 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 (Considering, then Planned —
@@ -607,6 +628,21 @@ the whole of removing it. A clone and not a `git worktree`, on purpose: the
 daemon's reset checks the default branch out, which git refuses in a second
 worktree. Changed without a restart, like `agentCommands`.
 
+### Where a session with no branch reads: `<first>-read`
+
+A plan, a verify or an ask cuts no branch and takes no checkout, so it used to
+run in the project's first checkout **as that checkout happened to be** — on
+whatever branch the last run left there. A cancelled CTO Interview left
+`cto-interview` checked out, hundreds of commits behind, and every plan after
+it read that code. Such a session now reads `<first>-read`, beside the first
+checkout: a **detached `git worktree`** of it, brought to `origin/<default
+branch>` at the start of a session whenever no other session is reading there.
+The checkout itself is never moved, because a coding run may be working in it.
+One per project rather than one per run, because the CLI keeps a resumable
+conversation by its folder. Detached, so the default branch is never checked
+out twice. If it cannot be made — no remote, not a repository — the session
+reads the first checkout as before, and the log says why.
+
 ### `/reload`
 
 Quitting and starting again, in one word — for when the client's code changed