@ctrl-spc/cs 0.7.0 → 0.7.2

package/dist/panel3/say.js

@@ -1,5 +1,5 @@
 /**
- * ═══ AGENT PANEL v3: `cs3 say`, the only way anything reaches the record. ═══
+ * ═══ AGENT PANEL v3: `cs say`, the only way anything reaches the record. ═══
  *
  * THIS FILE BELONGS TO AGENT PANEL v3. Nothing outside `src/panel3/` may
  * import it.
@@ -14,7 +14,7 @@
  * So this command's whole job is to put the card and the turn on the record and
  * return. It does not spawn, does not take, does not wait for anything to be
  * ready, and there is nothing here for a daemon to be up for. Nothing answers
- * the turn yet, which is why `cs3 show` says out loud that nothing is acting on
+ * the turn yet, which is why `cs show` says out loud that nothing is acting on
  * the card: that is the record being honest, not this command being unfinished.
  *
  * ---------------------------------------------------------------------------
@@ -46,13 +46,13 @@
 // and takes the leading comment with it, so a file whose first statement is
 // `import type` loses its v3 header in the published `dist/`.
 import { at, out, returned, signedInClient } from './client.js';
-const USAGE = 'usage: cs3 say [--card <id>] [--project <id or name>] "<text>"';
+const USAGE = 'usage: cs say [--card <id>] [--project <id or name>] "<text>"';
 /** Long enough to recognise a request on a board, short enough to be a name. */
 const TITLE_LIMIT = 80;
 // ---------------------------------------------------------------------------
 /**
  * The arguments after `say`. A bare word that is not a flag is the message, and
- * a SECOND one is refused rather than joined: `cs3 say hello there` is a message
+ * a SECOND one is refused rather than joined: `cs say hello there` is a message
  * the shell already split, and quietly gluing it back together would be this
  * command guessing at what the user typed. Quoting is the fix and the error says
  * so.
@@ -67,7 +67,7 @@ function parseArgs(args) {
             i += 1;
             const value = args[i];
             // A FLAG IS NOT A CARD ID. Swallowing the next token whatever it is sends
-            // `cs3 say --card --help "x"` to Postgres and surfaces "invalid input
+            // `cs say --card --help "x"` to Postgres and surfaces "invalid input
             // syntax for type uuid", which is a real error and the wrong one: the
             // truth is that no card was named.
             if (value === undefined || value.startsWith('--')) {
@@ -141,8 +141,8 @@ async function existingCard(client, cardId) {
     if (error)
         throw new Error(`could not read card ${cardId}: ${error.message}`);
     if (!data) {
-        throw new Error(`no card with id ${cardId}. Run \`cs3 say "<text>"\` with no --card to start a new one, `
-            + 'or `cs3 show` to list the cards there are.');
+        throw new Error(`no card with id ${cardId}. Run \`cs say "<text>"\` with no --card to start a new one, `
+            + 'or `cs show` to list the cards there are.');
     }
     return data;
 }
@@ -160,7 +160,7 @@ async function existingCard(client, cardId) {
  * what they typed, and having the product classify a message at send time is the
  * move ux.md spends a section forbidding: "the moment the product classifies, it
  * has to be right, and being wrong silently discards something the user said."
- * So it stays null, `cs3 show` says "no project yet", and that is the truth.
+ * So it stays null, `cs show` says "no project yet", and that is the truth.
  *
  * IT IS A LABEL, NOT A WALL. ux.md: "Project is a filter the coordinator applies,
  * never a wall it lives inside." Nothing downstream narrows a read to this
@@ -250,7 +250,7 @@ export async function say(args) {
         const reason = error instanceof Error ? error.message : String(error);
         if (isNew) {
             throw new Error(`${reason}\ncard ${card.id} was created and carries no turn. `
-                + `Retry with: cs3 say --card ${card.id} "<text>"`);
+                + `Retry with: cs say --card ${card.id} "<text>"`);
         }
         throw error;
     }
@@ -258,5 +258,5 @@ export async function say(args) {
     out(`title  ${card.title}`);
     out(`turn   ${turn.id}   ${at(turn.created_at)}   ${turn.addressed_at ? `addressed ${at(turn.addressed_at)}` : 'NOT ADDRESSED'}`);
     out();
-    out(`  cs3 show ${card.id}`);
+    out(`  cs show ${card.id}`);
 }

package/dist/panel3/session.js

@@ -0,0 +1,128 @@
+import { chmodSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { configDir } from '../config.js';
+export const OWNER_SESSION_GRACE_MS = 30_000;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export const validSessionUuid = (value) => typeof value === 'string' && UUID.test(value);
+export function ownerSessionsRoot() {
+    return join(configDir(), 'panel3-sessions');
+}
+export function ownerSessionPath(ownerId) {
+    if (!validSessionUuid(ownerId))
+        throw new Error('an owner session requires a valid run id');
+    return join(ownerSessionsRoot(), `${ownerId}.json`);
+}
+function validRecord(value, ownerId) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const row = value;
+    return row.ownerId === ownerId
+        && (row.harness === 'claude' || row.harness === 'codex')
+        && validSessionUuid(row.nativeSessionId)
+        && validSessionUuid(row.processToken)
+        && (row.state === 'pending' || row.state === 'established')
+        && typeof row.updatedAt === 'string'
+        && Number.isFinite(new Date(row.updatedAt).getTime());
+}
+/** Invalid local data is never handed to a harness as a resume selector. */
+export function readOwnerSession(ownerId) {
+    let path;
+    try {
+        path = ownerSessionPath(ownerId);
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (validRecord(parsed, ownerId))
+            return parsed;
+    }
+    catch {
+        // Missing and malformed are both absence to the caller. Malformed is removed below.
+        try {
+            path = ownerSessionPath(ownerId);
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        rmSync(path, { force: true });
+    }
+    catch { /* reconciliation retries */ }
+    return null;
+}
+/** One file per owner prevents two daemons updating different owners from
+ * losing each other's mappings. Same-directory rename makes each record whole
+ * or absent across a crash. */
+export function writeOwnerSession(record) {
+    const stored = { ...record, updatedAt: record.updatedAt ?? new Date().toISOString() };
+    if (!validRecord(stored, stored.ownerId))
+        throw new Error('invalid owner session record');
+    const root = ownerSessionsRoot();
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    chmodSync(root, 0o700);
+    const path = ownerSessionPath(record.ownerId);
+    const temporary = join(root, `.${record.ownerId}.${randomUUID()}.tmp`);
+    try {
+        writeFileSync(temporary, `${JSON.stringify(stored)}\n`, { mode: 0o600 });
+        renameSync(temporary, path);
+    }
+    finally {
+        try {
+            rmSync(temporary, { force: true });
+        }
+        catch { /* a later reconciliation can remove it */ }
+    }
+}
+export function establishOwnerSession(ownerId, processToken) {
+    const record = readOwnerSession(ownerId);
+    if (!record || record.state !== 'pending' || record.processToken !== processToken)
+        return false;
+    writeOwnerSession({ ...record, state: 'established', updatedAt: new Date().toISOString() });
+    return true;
+}
+export function removeOwnerSession(ownerId) {
+    try {
+        rmSync(ownerSessionPath(ownerId), { force: true });
+    }
+    catch { /* reconciliation retries */ }
+}
+export function removeOwnerSessionIfToken(ownerId, processToken) {
+    const record = readOwnerSession(ownerId);
+    if (!record || record.processToken !== processToken)
+        return false;
+    removeOwnerSession(ownerId);
+    return true;
+}
+/** Names, not contents. Malformed names and temp remnants are removed here and
+ * never become database selectors. */
+export function listOwnerSessionIds(now = Date.now()) {
+    let entries;
+    try {
+        entries = readdirSync(ownerSessionsRoot());
+    }
+    catch {
+        return [];
+    }
+    const ids = [];
+    for (const entry of entries) {
+        const match = /^([0-9a-f-]+)\.json$/i.exec(entry);
+        if (match && validSessionUuid(match[1])) {
+            ids.push(match[1]);
+            continue;
+        }
+        const temporary = /^\.([0-9a-f-]+)\.([0-9a-f-]+)\.tmp$/i.exec(entry);
+        if (temporary && validSessionUuid(temporary[1]) && validSessionUuid(temporary[2])) {
+            try {
+                if (now - statSync(join(ownerSessionsRoot(), entry)).mtimeMs < OWNER_SESSION_GRACE_MS)
+                    continue;
+            }
+            catch {
+                continue;
+            }
+        }
+        try {
+            rmSync(join(ownerSessionsRoot(), entry), { recursive: true, force: true });
+        }
+        catch { /* retry later */ }
+    }
+    return ids;
+}

package/dist/panel3/show.js

@@ -1,5 +1,5 @@
 /**
- * ═══ AGENT PANEL v3: `cs3 show`, the whole record in a terminal. ═══
+ * ═══ AGENT PANEL v3: `cs show`, the whole record in a terminal. ═══
  *
  * THIS FILE BELONGS TO AGENT PANEL v3. Nothing outside `src/panel3/` may
  * import it.
@@ -16,7 +16,7 @@
  * ═══ AN EMPTY RECORD AND A FAILED READ MUST NEVER LOOK ALIKE. ═══
  *
  * A read that comes back empty prints "No cards.". A read that FAILS throws, so
- * `cs3` prints the reason on stderr and exits non-zero. `returned()` in
+ * `cs` prints the reason on stderr and exits non-zero. `returned()` in
  * `client.ts` is the one place that distinction is made, for every v3 command,
  * and it also rejects the shape that would otherwise slip through: no error and
  * no data, which is not "nothing is there" but "the client returned something
@@ -37,6 +37,8 @@
 import { at, out, returned, signedInClient } from './client.js';
 import { coordination, elsewhereMismatch, listeningFleet, } from './presence.js';
 import { designatedCoordinator } from './coordinator.js';
+import { DEFAULT_BRANCH_PATTERN, worktreeFolder } from './checkout.js';
+import { existsSync } from 'node:fs';
 import { listCodebaseLocations, listCodebases } from '../codebases.js';
 /** The columns of `panel3_asks` that carry content, plus the reference that says
  *  whether they are the ones to read. */
@@ -61,7 +63,8 @@ export async function withAskContent(client, asks) {
     if (ids.length === 0)
         return asks;
     const decisions = await read(client.from('decisions')
-        .select('id, question, answer, category, context, answer_mode, options, selected_options, answer_note')
+        .select('id, question, answer, category, context, answer_mode, options, selected_options, '
+        + 'answer_note, related_artifact_id, related_artifact_revision')
         .in('id', ids), 'decisions');
     /* THE CONTENT ONLY. The decision's own `id` is dropped here rather than
        spread and overwritten: the ask row's id is what every caller answers,
@@ -79,8 +82,8 @@ export async function withAskContent(client, asks) {
 const read = (query, what) => returned(query, 'read', what);
 const CARD_COLUMNS = 'id, project_id, title, state, created_at, archived_at';
 const TURN_COLUMNS = 'id, card_id, role, body, created_at, addressed_at, run_id';
-const RUN_COLUMNS = 'id, card_id, codebase_id, parent_run_id, level, state, brief, report, failed_because, activity, machine_id, '
-    + 'pid, started_at, resumed_at, read_back_at, ended_at';
+const RUN_COLUMNS = 'id, card_id, codebase_id, branch, parent_run_id, level, state, brief, report, failed_because, '
+    + 'activity, machine_id, pid, started_at, resumed_at, read_back_at, ended_at';
 const ASK_COLUMNS = `id, card_id, run_id, pending_run_id, answered_at, delivered_at, created_at, ${ASK_CONTENT_COLUMNS}`;
 const OUTPUT_COLUMNS = 'id, card_id, run_id, kind, ref_id, label, created_at';
 const ATTACHMENT_COLUMNS = 'id, card_id, kind, ref_id, label, created_at';
@@ -179,7 +182,7 @@ export async function loadOutputNames(client, outputs) {
  * ═══ WHAT WAS ATTACHED TO ONE CARD. ═══
  *
  * One card at a time, unlike `loadChildren`'s batch of every card on the list
- * view: `cs3 show` prints attachments only in the single-card view (the plan's
+ * view: `cs show` prints attachments only in the single-card view (the plan's
  * own line: the list view already says one thing per card, and this is
  * per-item detail), and level 1's prompt and a dispatched brief are both about
  * one card's work, never many at once. A batched loader with exactly one
@@ -189,10 +192,149 @@ export async function loadAttachments(client, cardId) {
     return read(client.from('panel3_attachments').select(ATTACHMENT_COLUMNS).eq('card_id', cardId)
         .order('created_at'), 'panel3_attachments');
 }
+export async function standingRulesFor(client, runId) {
+    const rows = await read(client
+        .from('panel3_runs')
+        .select('codebase_id, card:panel3_cards!panel3_runs_card_id_fkey(project_id)')
+        .eq('id', runId), `the standing rules run ${runId} is under`);
+    const run = rows[0];
+    const projectId = run?.card?.project_id ?? null;
+    if (!projectId)
+        return [];
+    const scoped = client
+        .from('agent_instructions')
+        .select('title, content, codebase_id')
+        .eq('project_id', projectId);
+    return read((run.codebase_id === null
+        ? scoped.is('codebase_id', null)
+        : scoped.or(`codebase_id.is.null,codebase_id.eq.${run.codebase_id}`))
+        /* ═══ MOST SPECIFIC FIRST, WHICH IS THE ORDER ux.md GIVES. ═══ "A
+           codebase's documents beat the project's for work in that codebase", so
+           the codebase's are rendered above the project's. `nulls last` on a
+           descending-specificity sort is what puts the non-null rows first; within
+           each scope it is oldest-first, matching the list the person sees. */
+        .order('codebase_id', { nullsFirst: false })
+        .order('created_at'), `the standing rules on project ${projectId}`);
+}
+const NOTHING_STORED = {
+    base_branch: null, landing: null, branch_pattern: null, base_protected: null,
+};
+export async function storedGitRules(client, codebaseId) {
+    const rows = await read(client.from('codebase_git_rules')
+        .select('base_branch, landing, branch_pattern, base_protected')
+        .eq('codebase_id', codebaseId), `the git rules on codebase ${codebaseId}`);
+    return rows[0] ?? NOTHING_STORED;
+}
+/**
+ * ═══ THE DETECTED DEFAULT, FROM TWO INPUTS, AND IT IS NEVER WRITTEN DOWN. ═══
+ *
+ * More than one member of the organization means a pull request; otherwise
+ * straight onto the main branch; and a PROTECTED base branch means a pull
+ * request whatever the organization's size, because on a protected branch the
+ * merge either fails or bypasses the review, and the second is worse.
+ *
+ * ═══ UNKNOWN PROTECTION FALLS BACK TO THE MEMBER COUNT AND SAYS SO. ═══ `null`
+ * is not `false`. Reading it as false would be the one wrong answer available
+ * here, because false is the answer that skips a review.
+ *
+ * Nothing here writes a setting. Detection produces an answer for this run and a
+ * sentence for the screen, and `landing` stays null until a person chooses.
+ */
+export function landingFor(stored, members) {
+    if (stored.landing !== null)
+        return { landing: stored.landing, detectedBecause: null };
+    if (stored.base_protected === true) {
+        return {
+            landing: 'pr',
+            detectedBecause: 'the main branch is protected on the remote, so a merge here would either '
+                + 'fail or bypass the review',
+        };
+    }
+    return members > 1
+        ? {
+            landing: 'pr',
+            detectedBecause: `this organization has ${members} members`
+                + (stored.base_protected === null
+                    ? ', and nobody could check whether the main branch is protected'
+                    : ''),
+        }
+        : {
+            landing: 'main',
+            detectedBecause: 'this organization has one member'
+                + (stored.base_protected === null
+                    ? ', and nobody could check whether the main branch is protected'
+                    : ', and the main branch is not protected'),
+        };
+}
+/**
+ * How many people a change to these rules reaches, which is what the detected
+ * ending turns on.
+ *
+ * ═══ IT TAKES THE PROJECT, IT DOES NOT LOOK ONE UP. ═══ The project is on the
+ * run row already at every call site, and finding it from the codebase would
+ * mean naming `cliv2_codebases` from inside `panel3/`, which conventions.md's
+ * rule 4 forbids and `panel3-isolation.contract.test.mjs` fails on. `projects`
+ * and `memberships` are product tables, which v3 reads under the person's own
+ * RLS exactly as the web app does.
+ */
+async function orgMembers(client, projectId) {
+    const project = await read(client.from('projects').select('org_id').eq('id', projectId), `which organization project ${projectId} belongs to`);
+    const orgId = project[0]?.org_id;
+    /* ONE, NOT ZERO, when the project cannot be resolved: the count only ever
+       decides between "on your own" and "on a team", and a zero would read as
+       neither while behaving as the first. */
+    if (!orgId)
+        return 1;
+    return (await read(client.from('memberships').select('user_id').eq('org_id', orgId), `who is in organization ${orgId}`)).length;
+}
+export async function gitRulesFor(client, codebaseId, projectId) {
+    const stored = await storedGitRules(client, codebaseId);
+    /* THE MEMBER COUNT IS ONLY ASKED FOR WHEN IT DECIDES SOMETHING. A codebase
+       whose team chose an ending needs no count, and most do not. */
+    const members = stored.landing === null ? await orgMembers(client, projectId) : 1;
+    return {
+        ...stored,
+        ...landingFor(stored, members),
+        branchPattern: stored.branch_pattern ?? DEFAULT_BRANCH_PATTERN,
+    };
+}
+/**
+ * WHAT WORK IN THIS CODEBASE STARTS FROM, recorded on the CODEBASE and not on
+ * the card that prompted the question (story 3 scenario 4), so the same question
+ * is never asked twice.
+ *
+ * Upsert on `codebase_id`, which is unique: the row may not exist yet, and a
+ * codebase nobody has configured is a codebase with no row rather than a row of
+ * nulls.
+ */
+export async function setMainBranch(client, codebaseId, branch) {
+    await returned(client.from('codebase_git_rules')
+        .upsert({ codebase_id: codebaseId, base_branch: branch }, { onConflict: 'codebase_id' })
+        .select('codebase_id'), 'record which branch work starts from', `codebase ${codebaseId}`);
+}
+/**
+ * AN OBSERVATION, WRITTEN WHERE THE ANSWER WAS FOUND. Refreshed opportunistically
+ * by the machine that holds the checkout, and never turned into a setting:
+ * `landing` stays null until a person chooses, so detected and chosen stay
+ * distinguishable.
+ *
+ * A failure is SAID, not fatal. This is a fact about the remote, not about the
+ * work, and refusing to run a card because a `gh` call could not be recorded
+ * would be the observation deciding the outcome.
+ */
+export async function recordBaseProtection(client, codebaseId, isProtected) {
+    await returned(client.from('codebase_git_rules')
+        .upsert({
+        codebase_id: codebaseId,
+        base_protected: isProtected,
+        base_protected_at: new Date().toISOString(),
+    }, { onConflict: 'codebase_id' })
+        .select('codebase_id'), 'record whether the main branch is protected', `codebase ${codebaseId}`);
+}
 /**
  * ═══ ONE LINE, EVERYWHERE AN ATTACHMENT IS NAMED. ═══
  *
- * `cs3 show`'s ATTACHMENTS section, level 1's prompt and a dispatched brief all
+ * `cs show`'s ATTACHMENTS section, level 1's prompt and a dispatched brief all
  * name the same fact about the same row, and ux.md's own warning about the
  * outbound rules applies here too: two copies of "how an attachment reads"
  * would drift, silently, in whichever caller nobody re-read. So there is one
@@ -201,7 +343,7 @@ export async function loadAttachments(client, cardId) {
  */
 export const attachmentLine = (a) => `${a.kind}  ${a.label}   id ${a.ref_id}`;
 /**
- * ═══ THE WHOLE ATTACHMENTS SECTION, EXACTLY AS `cs3 show` PRINTS IT, OR
+ * ═══ THE WHOLE ATTACHMENTS SECTION, EXACTLY AS `cs show` PRINTS IT, OR
  *     NOTHING AT ALL. ═══
  *
  * Every other section on a card prints its own header and a "none" line at
@@ -214,7 +356,7 @@ export const attachmentLine = (a) => `${a.kind}  ${a.label}   id ${a.ref_id}`;
  * PURE AND EXPORTED for the same reason `nothingWillActOn` is: the "prints
  * nothing when there is nothing" rule is a fact about this function's return
  * value, and a test asserting it should not need a live client or a running
- * `cs3 show` to see it.
+ * `cs show` to see it.
  */
 export function attachmentsSection(attachments) {
     if (attachments.length === 0)
@@ -222,7 +364,19 @@ export function attachmentsSection(attachments) {
     return [`ATTACHMENTS  ${attachments.length}`, ...attachments.map((a) => `  ${attachmentLine(a)}`)];
 }
 async function codebaseSection(client, card, attachments, runs) {
-    const selected = attachments.filter((attachment) => attachment.kind === 'codebase');
+    /* ═══ WHAT THE CARD IS ATTACHED TO, AND WHAT ITS RUNS ARE ACTUALLY IN. ═══
+       They are not the same set: a codebase the coordinator chose is on the run
+       row and on no attachment, and keying this section off attachments alone
+       printed nothing at all for the ordinary path — including the branch and the
+       folder, which are the two things `cs show` exists to say here. */
+    const attached = attachments.filter((attachment) => attachment.kind === 'codebase');
+    const selected = [...new Set([
+            ...attached.map((attachment) => attachment.ref_id),
+            ...runs.map((run) => run.codebase_id).filter((id) => id !== null),
+        ])].map((id) => ({
+        ref_id: id,
+        label: attached.find((attachment) => attachment.ref_id === id)?.label ?? id,
+    }));
     if (selected.length === 0)
         return [];
     const codebases = card.project_id ? await listCodebases(client, card.project_id) : [];
@@ -251,10 +405,29 @@ async function codebaseSection(client, card, attachments, runs) {
                 const located = locations.some((location) => (location.machineId === machineId && location.gitRemoteUrl === codebase.gitRemoteUrl));
                 return `${located ? 'located on' : 'NOT LOCATED on'} ${machineName}`;
             });
-            return `  ${name}  ${availability.join('  ·  ')}`;
+            return `  ${name}  ${availability.join('  ·  ')}${branchOf(runs, codebase.id)}`;
         }),
     ];
 }
+/**
+ * ═══ THE BRANCH, AND — HERE AND ONLY HERE — THE FOLDER. ═══
+ *
+ * worktrees-8: no absolute path may reach the cloud or a hosted browser, so the
+ * card and the run details name the branch and stop. `cs show` runs on the
+ * person's own machine, which is the one surface where the path is already
+ * theirs, so this is where a power user reads it.
+ *
+ * The folder is printed only when it is really here: the copy is machine-local,
+ * and naming one on a machine that does not hold it would be an invitation to
+ * `cd` into nothing.
+ */
+function branchOf(runs, codebaseId) {
+    const branch = runs.find((run) => run.codebase_id === codebaseId && run.branch)?.branch;
+    if (!branch)
+        return '';
+    const folder = worktreeFolder(codebaseId, branch);
+    return `\n    branch ${branch}${existsSync(folder) ? `  in ${folder}` : ''}`;
+}
 // ---------------------------------------------------------------------------
 // WHAT THE RECORD MEANS.
 const isLive = (run) => run.state === 'running' && !run.ended_at;
@@ -287,7 +460,7 @@ const isOutstanding = (ask) => !ask.answered_at || !ask.delivered_at;
  *
  * WHAT IT CHANGES HERE IS ONE SENTENCE, AND THE SENTENCE MATTERS: a stalled
  * question normally has a move, and this is the one case where it has none.
- * Printing `cs3 answer` at somebody whose answer would start nothing sends them
+ * Printing `cs answer` at somebody whose answer would start nothing sends them
  * to type a command that cannot do what it says.
  */
 const askWasStopped = (ask, runs) => {
@@ -381,13 +554,13 @@ function notesAboutQuestions(asks, runs) {
     const notes = [];
     for (const ask of asks.filter((a) => isStalled(a, runs))) {
         /* ═══ UNLESS ANSWERING IT WOULD DO NOTHING. ═══ A question asked by work the
-           user stopped is never delivered again, so `cs3 answer` settles the row and
+           user stopped is never delivered again, so `cs answer` settles the row and
            starts nobody. Naming the command anyway would be this screen sending
            somebody to type something that cannot do what it says, which is the same
            failure as the command itself claiming an effect it did not have. */
         if (askWasStopped(ask, runs)) {
             notes.push(`question ${ask.id} was asked by work you stopped: answering it starts nothing, and `
-                + `nothing is waiting for it. Send a message instead: cs3 say --card ${ask.card_id} `
+                + `nothing is waiting for it. Send a message instead: cs say --card ${ask.card_id} `
                 + '"<text>".');
             continue;
         }
@@ -397,7 +570,7 @@ function notesAboutQuestions(asks, runs) {
            to. Saying only that nothing will act on it would leave them reading a
            dead end that is not one. */
         notes.push(`question ${ask.id} went to an agent that has ended without answering it or passing it on: `
-            + `nothing will act on it until you do, with cs3 answer ${ask.id} "<text>".`);
+            + `nothing will act on it until you do, with cs answer ${ask.id} "<text>".`);
     }
     return notes;
 }
@@ -507,7 +680,7 @@ designation, fleet) {
     if (status !== 'here' && card.state === 'working') {
         return [
             status === 'nobody'
-                ? 'no machine is running `cs3 run`, so nothing can pick this up: it is waiting for a '
+                ? 'no machine is running `cs start`, so nothing can pick this up: it is waiting for a '
                     + 'machine, not being worked on. Start the CLI on a machine and it is taken from where '
                     + 'it is.'
                 /* ═══ `'elsewhere'`, WHICH USED TO READ AS `'nobody'` AND CLAIMED NO
@@ -581,7 +754,7 @@ designation, fleet) {
 }
 // ---------------------------------------------------------------------------
 // RENDERING. Plain text, aligned, and every id printed in full so it can be
-// pasted straight back into `cs3 show`. `out` and `at` come from `client.ts`,
+// pasted straight back into `cs show`. `out` and `at` come from `client.ts`,
 // so two commands cannot print the same instant two different ways.
 const count = (n, noun) => `${n} ${noun}${n === 1 ? '' : 's'}`;
 /** A body of text under a heading, indented, with its blank lines kept. */
@@ -646,7 +819,7 @@ export function machinesSection(designation, fleet) {
     const lines = [
         `coordinator  ${designation ? `${designation.machineId}  ${designation.agent}` : 'none designated, any machine may coordinate'}`,
         fleet.length === 0
-            ? 'listening    none, so nothing can be picked up until a machine runs `cs3 run`'
+            ? 'listening    none, so nothing can be picked up until a machine runs `cs start`'
             : `listening    ${count(fleet.length, 'machine')}`,
     ];
     for (const m of fleet) {
@@ -710,7 +883,7 @@ async function showAllCards(client) {
         }
     }
     out();
-    out('  cs3 show <card-id> for one card in full.');
+    out('  cs show <card-id> for one card in full.');
 }
 async function showCard(client, card) {
     const [children, names, designation, fleet, attachments] = await Promise.all([
@@ -832,7 +1005,7 @@ async function showCard(client, card) {
     renderNotes(nothingWillActOn(card, turns, runs, asks, status, designation, fleet));
     if (runs.length > 0) {
         out();
-        out('  cs3 show <run-id> for a run\'s brief and report.');
+        out('  cs show <run-id> for a run\'s brief and report.');
     }
 }
 /**
@@ -883,8 +1056,9 @@ function renderRunTree(runs, readingBack) {
         const pad = '  '.repeat(depth + 1);
         const liveness = isLive(run) ? 'LIVE' : run.state;
         out(`${pad}L${run.level}  ${liveness}  ${run.id}`);
-        if (run.codebase_id)
-            out(`${pad}    codebase ${run.codebase_id}`);
+        if (run.codebase_id) {
+            out(`${pad}    codebase ${run.codebase_id}${run.branch ? `  branch ${run.branch}` : ''}`);
+        }
         out(`${pad}    machine ${run.machine_id}${run.pid ? `  pid ${run.pid}` : ''}`);
         out(`${pad}    started ${at(run.started_at)}`
             + (run.ended_at ? `  ended ${at(run.ended_at)}` : '  not ended'));
@@ -977,7 +1151,7 @@ async function showRun(client, run) {
 }
 // ---------------------------------------------------------------------------
 /**
- * `cs3 show` with no id lists every card. With an id it shows that card in
+ * `cs show` with no id lists every card. With an id it shows that card in
  * full, or that run with its brief and report — one argument, resolved against
  * the record, because a `--run` flag would make the caller say which kind of id
  * they are holding when the record already knows.