@volter/supercode-orchestrator 0.5.226 → 0.5.228

package/board/store.mjs

@@ -23,7 +23,7 @@ import { openZtrackBoard } from './ztrack.mjs';
 import { byOwner, LIST_CONNECTION, TASK_SUMMARY_INDEX, TASK_SUMMARY_INDEX_SQL } from './listing.mjs';
 import { isFilesBoard, openFilesBoard } from './files.mjs';
 import { signalBoardWrite } from './wake.mjs';
-import { PUBLICATION_COLUMNS, PUBLICATION_SCHEMA, pruneDue, prunePublications, publicationTriggers, recordCardPublications } from './published.mjs';
+import { PUBLICATION_COLUMNS, PUBLICATION_SCHEMA, incrementalStore, pruneDue, prunePublications, publicationTriggers, reclaimDue, reclaimSlice, recordCardPublications, trimDue, trimPublications } from './published.mjs';
 
 import { fillReadableIds } from './readable-id.mjs';
 
@@ -191,14 +191,19 @@ export function boardKey(root, slug = DEFAULT_BOARD, { creating = false, key: re
 }
 /** A card as a person names it: its board's key and its number (`VO-856`). */
 export const cardRef = (key, number) => (number ? `${key}-${number}` : null);
-// Sessions and worktree folders retain the card's immutable keyed number (`vo-856`).
-// Branches also carry its readable id; card agents use role-readable-id.
+// A card's readable id names its branch, its worktree folder (workspace.mjs worktreeFolder) and its fresh sessions;
+// card agents use role-readable-id. Its keyed number stays the immutable reference beside it.
 /** A card's handle (`vo-856`), or null for a card with no number. */
 export const cardHandle = (key, number) => (number ? `${String(key).toLowerCase()}-${number}` : null);
 /** The handle of card `id` on `board` (`vo-856`), or null before the card is filed. */
 export const cardHandleOf = (board, id) => id == null ? null : cardHandle(boardKey(board.root, board.slug), board.db.prepare(`SELECT number FROM ${CARD_NUMBERS} WHERE task_id = ?`).get(id)?.number);
-/** A branch keeps the unique number and the card's readable id. */
-export const cardBranch = (handle, readableId) => readableId ? `${handle}-${readableId}` : handle;
+/** Card `id`'s branch, named by its readable id (`voice-calls`, under a project's `<slug>/`), held by no other card. */
+export function cardBranch(db, id, readableId, prefix = '') {
+  const branch = `${prefix}${readableId}`;
+  const holder = db.prepare('SELECT id FROM tasks WHERE branch_name=? AND id<>? LIMIT 1').get(branch, id);
+  if (holder) throw new Error(`branch ${branch} belongs to card ${holder.id}; name this card with another readable id`);
+  return branch;
+}
 export const readableIdOf = (board, id) => board.db.prepare('SELECT readable_id FROM tasks WHERE id=?').get(id)?.readable_id ?? null;
 
 /** The home's boards that exist: `default` when it does, and every named one. */
@@ -370,6 +375,34 @@ function layOutNumbers(db) {
   } catch (error) { db.exec('ROLLBACK TO supercode_card_numbering; RELEASE supercode_card_numbering'); throw error; }
 }
 
+/** Only cards are numbered (VO-3578 row 22): a store from before that rule keeps the numbers its tasks were given, and
+ *  they go TASK_NUMBER_BATCH at a time, one batch in each board transaction (tx), so the republication each dropped
+ *  number marks (published.mjs) is bounded with it: the live store's 3,320 at once held one transaction 16.5 s
+ *  (VO-3578 take68). The sequence stays where it is, so no number a task held is handed out again. Once a board has
+ *  none, this process stops looking. */
+const TASK_NUMBER_BATCH = 100;
+const unnumbered = new Set();
+function dropTaskNumbers(db, board) {
+  const key = `${board.root}\0${board.key}`;
+  if (unnumbered.has(key)) return;
+  const rows = db.prepare(`SELECT n.task_id FROM ${CARD_NUMBERS} n JOIN supercode_cards c ON c.task_id = n.task_id WHERE c.subtask_of IS NOT NULL LIMIT ?`).all(TASK_NUMBER_BATCH);
+  if (!rows.length) { unnumbered.add(key); return; }
+  const drop = db.prepare(`DELETE FROM ${CARD_NUMBERS} WHERE task_id = ?`);
+  for (const row of rows) drop.run(row.task_id);
+}
+
+/** Only cards are numbered (VO-3578 row 22): a task's row (supercode_cards.subtask_of) is numbered by the insert trigger
+ *  like any row, so a load gives each task's number back unless its source named it (`named`, task ids). The sequence
+ *  returns to the highest number held, never below `floor` (what the source had already handed out). */
+export function unnumberTasks(db, named = new Set(), floor = 0) {
+  const taken = db.prepare(`SELECT n.task_id FROM ${CARD_NUMBERS} n JOIN supercode_cards c ON c.task_id = n.task_id WHERE c.subtask_of IS NOT NULL`).all()
+    .filter((row) => !named.has(row.task_id));
+  if (!taken.length) return;
+  const drop = db.prepare(`DELETE FROM ${CARD_NUMBERS} WHERE task_id = ?`);
+  for (const row of taken) drop.run(row.task_id);
+  db.prepare(`UPDATE sqlite_sequence SET seq = MAX(?, (SELECT COALESCE(MAX(number), 0) FROM ${CARD_NUMBERS})) WHERE name = ?`).run(Number(floor) || 0, CARD_NUMBERS);
+}
+
 /** Raise the numbers' high-water mark to the highest number held, and to `floor`: AUTOINCREMENT hands out only numbers
  *  above it. For a store whose numbers were given or copied explicitly. */
 export function raiseCardNumbers(db, floor = 0) {
@@ -542,7 +575,9 @@ function heldHandle(entry, slug) {
   const statement = (st) => new Proxy(st, { get: (target, key) => key === 'run' ? (...args) => { guard(); return target.run(...args); } : bound(target, key) });
   const db = new Proxy(entry.board.db, { get: (target, key) => key === LIST_CONNECTION ? target : key === 'prepare' ? (sql) => statement(target.prepare(sql)) : key === 'exec' ? (sql) => { guard(); return target.exec(sql); } : bound(target, key) });
   let closed = false;
-  return { ...entry.board, db, tx: (fn) => { guard(); return entry.board.tx(fn); },
+  // a rebuild runs on the backing's own connection, outside its write wrapper (ztrack.mjs vacuum); a plain store's is its db
+  const vacuum = (sql) => { guard(); return typeof entry.board.vacuum === 'function' ? entry.board.vacuum(sql) : entry.board.db.exec(sql); };
+  return { ...entry.board, db, vacuum, tx: (fn) => { guard(); return entry.board.tx(fn); },
     close() { if (closed) return; closed = true; entry.uses -= 1; if (entry.retired && !entry.uses) try { entry.board.close(); } catch { /* closed */ } } };
 }
 
@@ -620,7 +655,7 @@ export const tx = (board, fn) => {
   const caller = /at (?:async )?([\w.$<>]+) /.exec(String(new Error().stack).split('\n')[2] ?? '')?.[1] ?? 'unknown';
   const started = performance.now();
   try {
-    const result = board.tx(db => {const result=fn(db);fillReadableIds(db);const began=performance.now();try{recordCardPublications(db,actorOf(),board.root,board.key);}finally{noteStep('board tx publications',performance.now()-began);}return result;});
+    const result = board.tx(db => {const result=fn(db);fillReadableIds(db);dropTaskNumbers(db, board);const began=performance.now();try{recordCardPublications(db,actorOf(),board.root,board.key);}finally{noteStep('board tx publications',performance.now()-began);}return result;});
     signalBoardWrite(board.root, actorOf());
     return result;
   } finally { noteStep(`board tx from ${caller}`, performance.now() - started); }
@@ -642,6 +677,13 @@ export function publishMarked(root) {
       const marked = step('marks', () => board.db.prepare('SELECT 1 FROM supercode_publication_dirty LIMIT 1').get()) || step('unimported', () => board.unimported?.());
       if (marked) published += step('publish', () => board.tx((db) => recordCardPublications(db, actorOf(), board.root, board.key)));
       if (step('prune due', () => pruneDue(board.db))) step('prune', () => board.tx((db) => prunePublications(db)));
+      // Maintenance that fails is said and left to the next wake: it never fails the owner's round. Older changes
+      // stored complete are trimmed a slice per wake (published.mjs storedSnapshot); a store `workflow compact`
+      // rebuilt gives free pages back a slice at a time.
+      try {
+        if (step('trim due', () => trimDue(board.db))) step('trim', () => board.tx((db) => trimPublications(db)));
+        else if (step('reclaim due', () => incrementalStore(board.db) && reclaimDue(board.db))) step('reclaim', () => board.tx((db) => reclaimSlice(db)));
+      } catch (error) { if (contention(error)) throw error; writeSync(2, `board ${slug}: publication maintenance failed and waits for the next wake: ${String(error?.message ?? error).slice(0, 300)}\n`); }
     } finally { board?.close(); }
   }
   return published;

package/board/tools.mjs

@@ -132,7 +132,7 @@ export async function boardTool(root, name, args = {}, env = {}) {
       }
       case 'kanban_request_review': {
         const stale = ownRun(); if (stale) return error(stale);
-        await engine.requestReview(board, tid, { summary: args.summary ? redact(String(args.summary)) : null, metadata: args.metadata ? redact(args.metadata) : null, commit: args.commit ?? null, branch: args.branch ?? null, pr: args.pr ?? null, pr_head: args.pr_head ?? args.commit ?? null, reviewer: args.reviewer ?? null, expectedRunId: own === tid && runId ? runId : null });
+        await engine.requestReview(board, tid, { summary: args.summary ? redact(String(args.summary)) : null, metadata: args.metadata ? redact(args.metadata) : null, commit: args.commit ?? null, branch: args.branch ?? null, pr: args.pr ?? null, pr_head: args.pr_head ?? args.commit ?? null, plan: args.plan === true, reviewer: args.reviewer ?? null, expectedRunId: own === tid && runId ? runId : null });
         return ok({ task_id: tid, status: 'review' });
       }
       case 'kanban_request_changes': {

package/board/workflow.mjs

@@ -1,4 +1,4 @@
-import { allocateReadableId } from './readable-id.mjs';
+import { allocateReadableId, cardReadableId } from './readable-id.mjs';
 // The board's workflow, interpreted (docs/architecture/orchestrator.md §2.9). The IR's `Orchestration.workflow`
 // (crates/interchange/src/orchestration/workflow.rs; Hermes's dispatcher, hermes.workflow.yaml, when a home declares
 // none) says every status a card can be in, what runs there, which events move a card and who may send them, what
@@ -6,7 +6,7 @@ import { allocateReadableId } from './readable-id.mjs';
 // the engine's primitives (the rows Hermes's tables hold); the I/O an action asks for (stopping a worker, closing a
 // pane, sending a session a message, cleaning a workspace) is answered as effects the caller runs after commit.
 import { current } from './call.mjs';
-import { detachedCard, detachedSession } from './custody.mjs';
+import { detachedCard, detachedSession, personOf } from './custody.mjs';
 import { notRuntime } from './owner-files.mjs';
 import { machineCall } from './doors.mjs';
 import { execFile } from 'node:child_process';
@@ -14,12 +14,12 @@ import { promisify } from 'node:util';
 import { existsSync, readdirSync, realpathSync, watch, readFileSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { randomBytes } from 'node:crypto';
-import { actorOf, appendRunObservation, boardKey, cardHandleOf, event as record, json, now } from './store.mjs';
-import { releaseAllSideSessions } from './side-sessions.mjs';
+import { actorOf, appendRunObservation, boardKey, cardBranch, cardHandleOf, event as record, json, now } from './store.mjs';
+import { releaseAllSideSessions, sideSessions } from './side-sessions.mjs';
 import { evaluate, holds, render, needsSources } from './expr.mjs';
 import { completionEvidence, declaredWorkBranches, namedWorkBranch, reviewCandidate } from './ci.mjs';
-import { cardCommitsOn, isLocalWorkspace, isWorkspacePath } from './workspace.mjs';
-import { cardNumber, identifyNotice, numbered } from './notices.mjs';
+import { branchClaim, cardCommitsOn, isLocalWorkspace, isWorkspacePath, unrecordedMaking } from './workspace.mjs';
+import { cardName, cardNumber, identifyNotice, numbered } from './notices.mjs';
 import { latestEvent } from './queries.mjs';
 
 const loaded = new Map();
@@ -309,7 +309,7 @@ function commitSource(db, task) {
  * (`commit_unread` says why): an unread checkout is not a card with no commits, and nothing may count it as one. */
 export function sessionProgress(db, task) {
   const event = one(db, `SELECT MAX(e.id) AS id FROM task_events e WHERE
-    (e.task_id=? AND e.kind IN ('specified','review_requested','review_pass','changes_requested','audited')) OR
+    (e.task_id=? AND e.kind IN ('specified','review_requested','review_pass','pr_review_pass','changes_requested','audited')) OR
     (e.task_id IN (SELECT task_id FROM supercode_cards WHERE subtask_of=?) AND e.kind IN ('completed','cancelled'))`, task.id, task.id);
   const { path } = commitSource(db, task);
   const read = path ? commitTimes.get(`${path}:${task.id}`) ?? { known: false, error: 'its checkout has not been read yet' } : { known: true, value: null };
@@ -445,28 +445,51 @@ export function cardSectionHeading(line) {
   const label = /^\s*([A-Za-z][A-Za-z0-9 _-]*):\s*$/.exec(line);
   return label ? label[1].trim().toLowerCase() : null;
 }
-/** Whether `body` is `was` with only outcomes ticked: each changed line is under the Acceptance heading, was `- [ ] X`
- *  and is now `- [x] X` or `- [x] X: <pointer>`, or was `- [x] X` and is now `- [x] X: <pointer>` (the pointer a tick
- *  needs, added after it); no other line added, removed or changed. */
-function onlyTicks(was, body) {
-  if (typeof body !== 'string') return false;
-  const before = String(was ?? '').split('\n');
-  const after = body.split('\n');
-  if (before.length !== after.length) return false;
-  // an outcome is a line of the card's Acceptance section (its heading at any level), not a task or any other checkbox
+const CHECKBOX = /^\s*[-*] \[[ xX]\]/;
+/** A card body read as Markdown reads it: a checkbox item is one block with its continuation lines (the indented lines
+ *  after it, with any blank lines between them; engine.mjs bodyTasks reads a task's lines the same way), its `text` the
+ *  item joined onto one line; every other line is a block of its own. Each block keeps the section it sits under. */
+function bodyBlocks(body) {
+  const lines = String(body ?? '').split('\n');
+  const blocks = [];
   let section = null;
-  return before.every((line, i) => {
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    const item = blocks.at(-1)?.item ? blocks.at(-1) : null;
+    let next = i;
+    while (item && next < lines.length && !lines[next].trim()) next += 1;
+    if (item && next < lines.length && /^\s+\S/.test(lines[next]) && !CHECKBOX.test(lines[next])) {
+      item.lines.push(...lines.slice(i, next + 1));
+      item.text += ` ${lines[next].trim()}`;
+      i = next;
+      continue;
+    }
     const heading = cardSectionHeading(line);
     if (heading !== null) section = heading;
-    if (line === after[i]) return true;
-    if (section !== 'acceptance') return false;
-    const pointed = (ticked) => after[i].startsWith(`${ticked}: `) && after[i].trim().length > ticked.trim().length + 1;
-    // Outcome prose may contain colons. Preserve the entire old line and permit only an appended pointer.
-    if (TICKED_OUTCOME.test(line)) return pointed(line);
-    const open = OPEN_OUTCOME.exec(line);
+    blocks.push({ section, item: CHECKBOX.test(line), text: line, lines: [line] });
+  }
+  return blocks;
+}
+/** Whether `body` is `was` with only outcomes ticked: each changed outcome (a checkbox item under the Acceptance heading,
+ *  read whole with its continuation lines) was `- [ ] X` and is now `- [x] X` or `- [x] X: <pointer>`, or was `- [x] X`
+ *  and is now `- [x] X: <pointer>` (the pointer a tick needs, added after it); no other line added, removed or changed. */
+function onlyTicks(was, body) {
+  if (typeof body !== 'string') return false;
+  const before = bodyBlocks(was);
+  const after = bodyBlocks(body);
+  if (before.length !== after.length) return false;
+  // an outcome is an item of the card's Acceptance section (its heading at any level), not a task or any other checkbox
+  return before.every((block, i) => {
+    const now = after[i];
+    if (block.lines.join('\n') === now.lines.join('\n')) return true;
+    if (block.section !== 'acceptance' || !block.item || !now.item) return false;
+    const pointed = (ticked) => now.text.startsWith(`${ticked}: `) && now.text.trim().length > ticked.trim().length + 1;
+    // Outcome prose may contain colons. Preserve the entire old item and permit only an appended pointer.
+    if (TICKED_OUTCOME.test(block.text)) return pointed(block.text);
+    const open = OPEN_OUTCOME.exec(block.text);
     if (!open) return false;
     const ticked = `${open[1]}[x] ${open[2]}`;
-    return after[i] === ticked || pointed(ticked);
+    return now.text === ticked || pointed(ticked);
   });
 }
 
@@ -538,6 +561,9 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {}, lazy
     blocked_by: blocks,
     paused: json(state.paused, null),
     detached: json(state.detached, null),
+    // the person the card is assigned to (custody.mjs personOf), or null: a person's card runs no session and closes on
+    // that person's completion
+    person: personOf(task.assignee),
     archived: Boolean(state.archived),
     every: state.every ?? null,
     next_run_at: state.next_run_at ?? null,
@@ -546,16 +572,8 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {}, lazy
     board: board.slug,
     get parents() { return parents(); },
     get children() { return children(); },
-    acceptance_complete: () => {
-      const lines = String(task.body ?? '').split('\n');
-      let acceptance = false;
-      return lines.every((line) => {
-        const heading = cardSectionHeading(line);
-        if (heading !== null) acceptance = heading === 'acceptance';
-        if (!acceptance || !/^\s*[-*] \[[ xX]\]/.test(line)) return true;
-        return /^\s*[-*] \[[xX]\] .+: \S.+$/.test(line);
-      });
-    },
+    // every outcome ticked with a pointer, each outcome read whole: a pointer on a wrapped item's continuation line counts
+    acceptance_complete: () => bodyBlocks(task.body).every((b) => b.section !== 'acceptance' || !b.item || /^\s*[-*] \[[xX]\] .+: \S.+$/.test(b.text)),
     get counters() { return { failures: Number(task.consecutive_failures || 0), block_recurrences: Number(task.block_recurrences || 0), goal_turns: Number(session().goal_turns || 0) }; },
     goal_mode: Boolean(task.goal_mode),
     get implementer() { return asked().implementer ?? task.assignee; },
@@ -571,7 +589,9 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {}, lazy
     get last_reviewer() { return changes().reviewer ?? null; },
     get arc() { return task.subtask_of ? one(db, `SELECT t.id, ${related}, t.title, t.body, t.assignee FROM tasks t LEFT JOIN supercode_cards c ON c.task_id = t.id WHERE t.id = ?`, task.subtask_of) ?? null : null; },
     // the cards filed as its subtasks (`create --subtask-of`), in the order they were filed
-    get subtasks() { return all(db, `SELECT t.id, ${related}, t.title, t.assignee FROM tasks t JOIN supercode_cards c ON c.task_id = t.id WHERE c.subtask_of = ? ORDER BY t.created_at`, task.id); },
+    // `paused`: a paused subtask's pause (who and why), or null; a paused subtask holds no review of its arc
+    get subtasks() { return all(db, `SELECT t.id, ${related}, t.title, t.assignee, c.paused FROM tasks t JOIN supercode_cards c ON c.task_id = t.id WHERE c.subtask_of = ? ORDER BY t.created_at`, task.id)
+      .map((t) => ({ ...t, paused: json(t.paused, null) })); },
     get queue_reason() { return json(one(db, "SELECT payload FROM task_events WHERE task_id = ? AND kind = 'respawn_guarded' AND created_at >= ? ORDER BY id DESC LIMIT 1",
       task.id, Number(one(db, 'SELECT since FROM supercode_cards WHERE task_id = ?', task.id)?.since ?? 0))?.payload, {})?.reason ?? null; },
     // the message whose answer the standing block waits for (`block --waiting-on`), and that answer's id once it has landed
@@ -662,18 +682,17 @@ function noticeRun(db, task) {
     : all(db, 'SELECT id, metadata FROM task_runs WHERE task_id = ? ORDER BY id DESC', task.id).find((r) => json(r.metadata, {})?.supercode?.session_id) ?? null;
 }
 
-function queueTransitionNotice(db, board, entry, task, from, name, payload, beforeRun, effects, noticeSession = null) {
+function queueTransitionNotice(db, board, entry, task, from, name, payload, beforeRun, effects, adopting = false) {
+  // A verified adoption starts a new run before binding its session; that session is told its role's brief by the
+  // adoption itself (dispatch.mjs roleBrief), never a second notice of the transition.
+  if (adopting) return;
   const after = cardOf(db, task.id), to = statusOf(db, after);
-  // A verified adoption starts a new run before binding its session. Its notice
-  // belongs to that new run and verified identity, never the last ended session
-  // that noticeRun found before the transition.
-  const targetRun = noticeSession && after.current_run_id
-    ? one(db, 'SELECT id, metadata FROM task_runs WHERE id = ?', after.current_run_id) : beforeRun;
+  const targetRun = beforeRun;
   const state = (t, status) => JSON.stringify([status, t.current_run_id, t.paused, t.archived, t.blocked_by]);
   const beforeState = json(beforeRun?.metadata, {})?.supercode?.state;
   const afterState = beforeRun && json(one(db, 'SELECT metadata FROM task_runs WHERE id=?', beforeRun.id)?.metadata, {})?.supercode?.state;
   if (!targetRun || (state(task, from) === state(after, to) && beforeState === afterState) || effects.some((e) => e.kind === 'session_notice' && e.runId === targetRun.id)) return;
-  const session = noticeSession ?? json(targetRun.metadata, {})?.supercode;
+  const session = json(targetRun.metadata, {})?.supercode;
   if (detachedSession(db, session)) return;
   const address = session?.address ?? (session?.session_id && session.machine ? `sc:${session.machine}:${session.harness ?? 'claude-code'}:${session.session_id}` : null);
   if (!address && !session?.launch_key && !session?.pane) return;
@@ -683,10 +702,8 @@ function queueTransitionNotice(db, board, entry, task, from, name, payload, befo
   if (address && address === actorOf()) return;
   if (session?.close_confirmed_at) return;
   const scope = scopeOf(db, board, after, { params: entry.params, event: { ...payload, verb: name, from, to }, extra: { run: { id: targetRun.id } } });
-  const defaultNotice = noticeSession
-    ? '{{card.id}}: verified adoption started run {{run.id}} ({{event.from}} → {{event.to}}). Follow the board’s current state before continuing.'
-    : '{{card.id}}: {{event.verb}} changed run {{run.id}} ({{event.from}} → {{event.to}}). Stop work under the previous run; follow the board’s current state. {{event.reason ?? ""}}';
-  const body = numbered(boardKey(board.root, board.slug), cardNumber(db, task.id), render(entry.workflow.notify?.worker?.run_changed ?? defaultNotice, scope));
+  const defaultNotice = '{{card.id}}: {{event.verb}} changed run {{run.id}} ({{event.from}} → {{event.to}}). Stop work under the previous run; follow the board’s current state. {{event.reason ?? ""}}';
+  const body = numbered(boardKey(board.root, board.slug), cardNumber(db, task.id), render(entry.workflow.notify?.worker?.run_changed ?? defaultNotice, scope), cardName(db, task.id));
   const source = one(db, 'SELECT MAX(id) AS id FROM task_events WHERE task_id = ?', task.id)?.id;
   const text = identifyNotice({ id: source, kind: name, run_id: targetRun.id, created_at: now() }, body);
   const effect = { kind: 'session_notice', id: task.id, runId: targetRun.id, address, text, sourceEvent: source, verb: name, messageKey: `board-run-notice-${randomBytes(16).toString('hex')}` };
@@ -752,7 +769,12 @@ export function validateEvent(db, board, entry, id, name, { roles = [], payload
   const from = localOnly ? statusOf(db, task) : declaredStatus(db, board, entry, task);
   if (localOnly && !workflow.statuses[from]) return null; // only fire adopts an imported status
   const candidates = transitionsFor(workflow, from, name);
-  if (!candidates.length) throw new Error(`${id} is ${from}; ${name.replace(/_/g, '-')} does not apply there`);
+  // a refusal names the right form: each transition's description, its card placeholders filled with this card
+  const said = (t) => t.description ? String(t.description).replaceAll('<arc>', id).replaceAll('<card>', id) : null;
+  if (!candidates.length) {
+    const elsewhere = (workflow.verbs?.[name] ?? []).filter((t) => t.from?.length && t.description);
+    throw new Error(`${id} is ${from}; ${name.replace(/_/g, '-')} does not apply there.${elsewhere.map((t) => ` From ${t.from.join(' or ')}: ${said(t)}`).join('')}`);
+  }
   // `sender`: the roles the event was sent with (a validator can ask who is asking)
   const scope = scopeOf(db, board, task, { params, event: payload, lazy: localOnly, deferSources: localOnly, extra: { lanes: lanesIn(entry), ...extra, sender: roles, verb: name } });
   const allowed = candidates.filter((t) => !t.by?.length || t.by.some((r) => roles.includes(r)));
@@ -760,7 +782,7 @@ export function validateEvent(db, board, entry, id, name, { roles = [], payload
     const state = name === 'complete' ? 'done' : name === 'cancel' ? 'cancelled' : null;
     const request = state && candidates.some(transition => transition.by?.includes('creator'))
       ? ` Ask the manager with workflow request-state ${id} --state ${state} --reason <why> --evidence <verdict-and-pointers>.` : '';
-    throw new Error(`${id} is ${from}; ${name.replace(/_/g, '-')} there is for ${[...new Set(candidates.flatMap((t) => t.by ?? []))].join(' or ')}. ${candidates.map((t) => t.description).filter(Boolean).join(' ')}${request}`);
+    throw new Error(`${id} is ${from}; ${name.replace(/_/g, '-')} there is for ${[...new Set(candidates.flatMap((t) => t.by ?? []))].join(' or ')}. ${candidates.map(said).filter(Boolean).join(' ')}${request}`);
   }
   // A source-dependent branch is undecidable before observation; preflight must not choose its fallback.
   const needsSource = expr => needsSources(expr, workflow.derived);
@@ -770,7 +792,7 @@ export function validateEvent(db, board, entry, id, name, { roles = [], payload
   // none of the sender's rules holds, but another role's does (one verb with a rule per case, as `set` has one per
   // field): it is that role's to send
   const theirs = taken ? [] : candidates.filter((t) => !allowed.includes(t) && holds(t.guard ?? null, scope));
-  if (theirs.length) throw new Error(`${id} is ${from}; ${name.replace(/_/g, '-')} there is for ${[...new Set(theirs.flatMap((t) => t.by ?? []))].join(' or ')}. ${theirs.map((t) => t.description).filter(Boolean).join(' ')}`);
+  if (theirs.length) throw new Error(`${id} is ${from}; ${name.replace(/_/g, '-')} there is for ${[...new Set(theirs.flatMap((t) => t.by ?? []))].join(' or ')}. ${theirs.map(said).filter(Boolean).join(' ')}${allowed.length ? ` Yours: ${allowed.map(said).filter(Boolean).join(' ')}` : ''}`);
   if (!taken) {
     const state = scope.card;
     const reasons = [state.paused && `paused: ${state.paused.reason ?? 'manager pause'}`,
@@ -787,12 +809,18 @@ export function validateEvent(db, board, entry, id, name, { roles = [], payload
   return { task, from, taken, scope, beforeRun: localOnly ? null : noticeRun(db, task) };
 }
 
-export function fire(db, board, entry, id, name, { roles = [], payload = {}, extra = {}, noticeSession = null } = {}) {
+export function fire(db, board, entry, id, name, { roles = [], payload = {}, extra = {}, adopting = false } = {}) {
   const checked = validateEvent(db, board, entry, id, name, { roles, payload, extra });
   if (!checked) return fireRun(db, board, entry, id, name, { roles, payload, extra });
-  const { task, from, taken, scope, beforeRun } = checked;
+  const { task, from, scope, beforeRun } = checked;
+  let { taken } = checked;
   const { params } = entry;
   const effects = [];
+  // Changing a card's text never moves it out of a review or an ended status, whatever a workflow's specify declares:
+  // a reviewed card sent back to work would launch a coder run on it. Its words still land and are recorded. The one
+  // move specify makes is a workflow's intake (Hermes's triage → todo), which leaves neither.
+  if (name === 'specify' && taken.target && (entry.workflow.statuses[from]?.run_role === 'reviewer' || ['done', 'archived'].includes(storedAs(entry.workflow, from))))
+    taken = { ...taken, target: undefined };
   const to = take(db, board, entry, task, from, taken, scope, effects);
   settle(db, board, entry, id, effects);
   projectStatus(db, board, entry, id);
@@ -800,11 +828,11 @@ export function fire(db, board, entry, id, name, { roles = [], payload = {}, ext
   // never turns it into an incident that waits for a second act
   const ended = task.current_run_id && one(db, 'SELECT ended_at FROM task_runs WHERE id = ?', task.current_run_id)?.ended_at != null ? task.current_run_id : null;
   if ((scope.card.dispatch_hold || ended) && roles.some(role => ['manager','creator'].includes(role)) &&
-      (['resume','reclaim','replace_session','reopen','reopen_review'].includes(name) || (name === 'set' && ['assignee','machine','model'].includes(payload.field))))
+      (['resume','reclaim','replace_session','reopen','reopen_review','return_review'].includes(name) || (name === 'set' && ['assignee','machine','model'].includes(payload.field))))
     record(db,id,'dispatch_released',{reason:`explicit ${name}`,incident:scope.card.last_events.run_incident?.payload?.run ?? null,...(ended ? { ended_run: ended } : {}),
       ...(ended && name === 'set' && payload.field === 'assignee' && (payload.value ?? null) !== (task.assignee ?? null)
         ? { reassigned_from: task.assignee ?? null, reassigned_to: payload.value ?? null, abandon_waiting_input: true } : {})});
-  queueTransitionNotice(db, board, entry, task, from, name, payload, beforeRun, effects, noticeSession);
+  queueTransitionNotice(db, board, entry, task, from, name, payload, beforeRun, effects, adopting);
   return { from, to: statusOf(db, cardOf(db, id)), moved: to !== from, effects };
 }
 
@@ -967,6 +995,10 @@ const FORMAT = {
   // the reviewer is the lane that reviewed (the card's assignee while in review), unless the verdict names one
   changes_requested: ({ e, before, after }) => ({ reason: e.reason ?? null, reviewer: e.reviewer ?? before.assignee ?? null, implementer: after.assignee }),
   review_reopened: ({ after, to }) => ({ status: to, implementer: after.assignee }),
+  // the manager's return of a review with no verdict: the request it returned and its run, so the next review's selection
+  // reads which heads it named (ci.mjs returnedReview)
+  review_returned: ({ e, before, after, to }) => ({ reason: e.reason ?? null, status: to, review_request: before.last_events.review_requested?.id ?? null,
+    review_run: before.current_run_id ?? null, implementer: after.assignee }),
   review_voided: ({ e, before }) => ({ reason: e.reason, review_request: before.last_events.review_requested?.id ?? null,
     review_run: before.latest_review?.id ?? null, verdict: Math.max(before.last_events.review_pass?.id ?? 0, before.last_events.changes_requested?.id ?? 0) || null }),
   // what arrived (an unblock says it), and where the card resumes
@@ -1083,6 +1115,10 @@ const ACTIONS = {
       if ((value ?? null) === task.machine) return;
       if (task.workspace_kind !== 'scratch' && (!task.workspace_anchor || isWorkspacePath(task.workspace_anchor))) throw new Error('declare the repository and branch with workflow specify --workspace before moving a legacy path card');
       ACTIONS.forget_session(ctx, '*');
+      // a worktree the card made with only its path recorded (workspace.mjs unrecordedMaking) is recorded as made before
+      // the move clears the path, so the branch it made stays its own on the new machine
+      const made = unrecordedMaking(ctx.db, ctx.id);
+      if (made) record(ctx.db, ctx.id, 'worktree_made', made, null);
       run(ctx.db, 'UPDATE tasks SET workspace_path=NULL WHERE id=?', ctx.id);
       cardField(ctx, 'workspace_root', null);
       cardField(ctx, 'machine', value ?? null);
@@ -1130,10 +1166,13 @@ const ACTIONS = {
                WHERE id = ? AND ended_at IS NULL`, outcome, outcome, summary, error ?? ctx.scope.event?.error ?? null, t, runId);
       ctx.runId = runId;
       ctx.lastOutcome = outcome;
-      runSession(ctx, session => ({ ...session, retain_after_run: !close_session }));
+      // the card's own coder bound as its reviewer leaves the reviewer slot unclosed (handBackCoder), here or earlier in
+      // this move (its close_session); the run being ended is the one it was handed back from
+      const handed = handBackCoder(ctx.db, ctx.id, runId) || handedBackFrom(json(one(ctx.db, 'SELECT metadata FROM task_runs WHERE id = ?', runId)?.metadata, {})?.supercode, runId);
+      if (!handed) runSession(ctx, session => ({ ...session, retain_after_run: !close_session }));
       // A declared completion may end the attempt while retaining its role session. In particular, its own caller
       // must be able to finish and return before the board starts the independent review.
-      if (close_session) {
+      if (close_session && !handed) {
         requestSessionClose(ctx.db, ctx.id, { runId });
         ctx.effects.push({ kind: 'run_ended', id: ctx.id, runId, outcome });
       }
@@ -1198,19 +1237,31 @@ const ACTIONS = {
     if (said?.workspace) {
       const task = cardOf(ctx.db, ctx.id), ws = said.workspace;
       if (task.current_run_id) throw new Error('end the current run before changing its workspace');
-      ACTIONS.forget_session(ctx, '*');
-      const prior = one(ctx.db, 'SELECT workspace_anchor FROM supercode_cards WHERE task_id=?', ctx.id);
       const moves = Object.hasOwn(ws, 'machine');
+      // A retarget lets go of the card's sessions, but never of the arc's own coder while it is open (openCoder): its
+      // next run, a review's return included, is delivered into that session, never a fresh one started beside it
+      // (VO-3755 t_c2d5d21b: a retarget forgot adopted coder c46c2896 at 06:51:01Z on 2026-10-27, and the run after its
+      // review's changes_requested, 2736, launched ee91b4d8 beside it). A move to another machine lets it go.
+      forgetSessions(ctx, '*', null, moves ? null : openCoder(ctx.db, ctx.id));
+      const prior = one(ctx.db, 'SELECT workspace_anchor FROM supercode_cards WHERE task_id=?', ctx.id);
       record(ctx.db, ctx.id, 'workspace_changed', { from: { kind: task.workspace_kind, repository: prior?.workspace_anchor, branch: task.branch_name, ...(moves ? { machine: task.machine } : {}) }, to: { kind: ws.kind, repository: ws.repository, branch: ws.branch, ...(moves ? { machine: ws.machine } : {}) } }, null);
       run(ctx.db, 'UPDATE tasks SET workspace_kind=?,workspace_path=?,branch_name=? WHERE id=?', ws.kind, ws.path ?? null, ws.branch ?? null, ctx.id);
       cardField(ctx, 'workspace_anchor', ws.repository ?? null);
       cardField(ctx, 'workspace_root', null);
       if (moves) cardField(ctx, 'machine', ws.machine ?? null);
+      // a branch the board named for the card is claimed until its worktree is made (workspace.mjs branchClaim)
+      if (ws.named && ws.branch) record(ctx.db, ctx.id, 'branch_named', { branch: ws.branch, repository: ws.repository ?? null }, null);
     }
     if (said?.readable_id != null) {
       const task = cardOf(ctx.db, ctx.id);
-      const readable = allocateReadableId(ctx.db, task.title, said.readable_id, ctx.id);
+      const readable = task.subtask_of ? allocateReadableId(ctx.db, task.title, said.readable_id, ctx.id) : cardReadableId(ctx.db, said.readable_id, ctx.id);
       run(ctx.db, 'UPDATE tasks SET readable_id=? WHERE id=?', readable, ctx.id);
+      // a branch the board named for the card follows its name until its worktree is made (workspace.mjs branchClaim)
+      if (readable !== task.readable_id && !task.subtask_of && task.branch_name?.split('/').at(-1) === task.readable_id && branchClaim(ctx.db, ctx.id, task.branch_name)) {
+        const branch = cardBranch(ctx.db, ctx.id, readable, task.branch_name.slice(0, task.branch_name.lastIndexOf('/') + 1));
+        run(ctx.db, 'UPDATE tasks SET branch_name=? WHERE id=?', branch, ctx.id);
+        record(ctx.db, ctx.id, 'branch_named', { branch, repository: one(ctx.db, 'SELECT workspace_anchor FROM supercode_cards WHERE task_id=?', ctx.id)?.workspace_anchor ?? null }, null);
+      }
       if (readable !== task.readable_id) {
         // Keep the obligation with the edit: a stopped dispatcher or interrupted caller must not lose the rename.
         // Delivery reads the current name, so an older edit can never restore an obsolete name.
@@ -1264,15 +1315,7 @@ const ACTIONS = {
     const name = String(typeof slot === 'object' && slot ? slot.slot ?? 'worker' : slot ?? 'worker');
     const harness = typeof slot === 'object' && slot ? ctx.entry.profiles[slot.assignee]?.worker?.harness : null;
     if (typeof slot === 'object' && slot && !harness) return;
-    for (const row of all(ctx.db, 'SELECT id, metadata FROM task_runs WHERE task_id = ? AND metadata IS NOT NULL ORDER BY id DESC', ctx.id)) {
-      const whole = json(row.metadata, {}) ?? {};
-      const session = whole.supercode;
-      if ((!session?.session_id && !session?.pane && !session?.launch_key) || (name !== '*' && (session.slot ?? 'worker') !== name) || (harness && (session.harness ?? 'claude-code') === harness)) continue;
-      requestSessionClose(ctx.db, ctx.id, { runId: row.id });
-      const latest = json(one(ctx.db, 'SELECT metadata FROM task_runs WHERE id=?', row.id)?.metadata, {}) ?? {};
-      latest.supercode = { ...latest.supercode, forgotten: now(), resumable: false };
-      run(ctx.db, "UPDATE task_runs SET metadata=?, ended_at=COALESCE(ended_at,?), status=CASE WHEN ended_at IS NULL THEN 'superseded' ELSE status END, outcome=CASE WHEN ended_at IS NULL THEN 'superseded' ELSE outcome END, claim_lock=NULL,claim_expires=NULL,worker_pid=NULL WHERE id=?", JSON.stringify(latest), now(), row.id);
-    }
+    forgetSessions(ctx, name, harness);
   },
   // an event sent to other cards (`to`: an expression naming their ids, e.g. a card's open subtasks), as `as` sends it;
   // a card it does not apply to now is passed over
@@ -1302,15 +1345,19 @@ const ACTIONS = {
     ctx.effects.push({ kind: 'board_message', id: ctx.id });
   },
   send_to_actor(ctx, text) {
+    // A board message that wakes the run's session (an idle reminder) carries the run's pending brief when its caller
+    // read one (dispatch.mjs pendingBrief): the text saved here is the text delivered, whatever the workflow's words.
+    const brief = typeof ctx.scope.pending_brief === 'string' && ctx.scope.pending_brief ? ctx.scope.pending_brief : null;
+    if (brief && !String(text ?? '').includes(brief)) text = `${String(text ?? '')} ${brief}`;
     const effect = { kind: 'send_to_actor', id: ctx.id, runId: ctx.runId, text, messageKey: `board-actor-${randomBytes(16).toString('hex')}` };
     const inserted = run(ctx.db, 'INSERT INTO supercode_effects (effect) VALUES (?)', JSON.stringify(effect));
-    effect.text = identifyNotice({ id: `notice-${inserted.lastInsertRowid}`, kind: 'actor_notice', run_id: ctx.runId, created_at: now() }, numbered(boardKey(ctx.board.root, ctx.board.slug), cardNumber(ctx.db, ctx.id), text));
+    effect.text = identifyNotice({ id: `notice-${inserted.lastInsertRowid}`, kind: 'actor_notice', run_id: ctx.runId, created_at: now() }, numbered(boardKey(ctx.board.root, ctx.board.slug), cardNumber(ctx.db, ctx.id), text, cardName(ctx.db, ctx.id)));
     run(ctx.db, 'UPDATE supercode_effects SET effect=? WHERE id=?', JSON.stringify(effect), Number(inserted.lastInsertRowid));
     ctx.effects.push({ ...effect, durableId: Number(inserted.lastInsertRowid) });
   },
 };
 
-/** Binding a newer run transfers ownership; stale run references cannot veto its later stop. */
+/** A newer attempt on a card retires its stale references. Adoption can share a session across cards. */
 export function retireSupersededRuns(db, id, runId, session) {
   if (!session?.session_id && !session?.pane) return;
   for (const old of all(db, `SELECT id,task_id,ended_at,metadata FROM task_runs WHERE id IN (
@@ -1321,6 +1368,10 @@ export function retireSupersededRuns(db, id, runId, session) {
     runId, session.machine ?? null, session.session_id ?? null, runId, session.machine ?? null, session.pane ?? null)) {
     const whole = json(old.metadata, {}) ?? {}, s = whole.supercode;
     if (!s || detachedSession(db, s) || s.machine !== session.machine || !((session.session_id && s.session_id === session.session_id) || (session.pane && s.pane === session.pane))) continue;
+    // Attaching records work on another card, not a transfer of its native session or agent identity.
+    // Keep both cards' runs and close receipts independent; an attachment cannot retire its starter's run,
+    // and the starter's later lifecycle must not retire an attached card's run either.
+    if (old.task_id !== id && (session.mode === 'adopt' || s.mode === 'adopt')) continue;
     if (old.task_id !== id && one(db, 'SELECT 1 FROM tasks WHERE current_run_id = ?', old.id)) throw new Error(`session is still owned by active run ${old.id} of ${old.task_id}`);
     const transferred = (s.pane && s.pane === session.pane) || (!s.pane && !session.pane && s.session_id === session.session_id);
     if (old.ended_at) {
@@ -1351,6 +1402,8 @@ export function requestSessionClose(db, id, { runId = null, slot = null, through
     const session = whole.supercode;
     if (detachedSession(db, session)) continue;
     if ((!session?.pane && !session?.launch_key && !(session?.surface === 'native' && session.session_id)) || session.close_transferred_to || session.close_confirmed_at || (slot != null && (session.slot ?? 'worker') !== slot)) continue;
+    // A reviewer binding of the card's own coder is never the review's to close (handBackCoder)
+    if ((session.slot ?? 'worker') === 'reviewer' && handBackCoder(db, id, row.id)) continue;
     if (session.close_requested && !session.closed_at) continue;
     whole.supercode = { ...session, close_requested: session.close_requested ?? now() };
     delete whole.supercode.closed_at; // older versions recorded success without checking the receipt
@@ -1358,6 +1411,78 @@ export function requestSessionClose(db, id, { runId = null, slot = null, through
   }
 }
 
+/**
+ * Let go of card `ctx.id`'s sessions in slot `name` ('*': every slot), those of another harness than `harness` when it is
+ * given: each is asked to close and is never continued; the slot's next run starts a new session. `keep` names a worker
+ * session that stays the arc's (openCoder): it is neither closed nor forgotten, so its next run is delivered into it.
+ */
+function forgetSessions(ctx, name, harness, keep = null) {
+  for (const row of all(ctx.db, 'SELECT id, metadata FROM task_runs WHERE task_id = ? AND metadata IS NOT NULL ORDER BY id DESC', ctx.id)) {
+    const whole = json(row.metadata, {}) ?? {};
+    const session = whole.supercode;
+    if ((!session?.session_id && !session?.pane && !session?.launch_key) || (name !== '*' && (session.slot ?? 'worker') !== name) || (harness && (session.harness ?? 'claude-code') === harness)) continue;
+    if (keep && session.session_id === keep && (session.slot ?? 'worker') === 'worker') continue;
+    requestSessionClose(ctx.db, ctx.id, { runId: row.id });
+    const latest = json(one(ctx.db, 'SELECT metadata FROM task_runs WHERE id=?', row.id)?.metadata, {}) ?? {};
+    // a reviewer binding the close handed back to its coder's slot is the coder's, and is not forgotten with the review
+    if (handedBackFrom(latest.supercode, row.id) && name !== '*' && name !== 'worker') continue;
+    latest.supercode = { ...latest.supercode, forgotten: now(), resumable: false };
+    run(ctx.db, "UPDATE task_runs SET metadata=?, ended_at=COALESCE(ended_at,?), status=CASE WHEN ended_at IS NULL THEN 'superseded' ELSE status END, outcome=CASE WHEN ended_at IS NULL THEN 'superseded' ELSE outcome END, claim_lock=NULL,claim_expires=NULL,worker_pid=NULL WHERE id=?", JSON.stringify(latest), now(), row.id);
+  }
+}
+
+/**
+ * The session id of card `id`'s worker slot's latest session when it is still open: an adopted session the board released
+ * (left running at its run's end) or one retained for its next run, never closed or let go. It is the arc's coder, and
+ * every next implementer run continues it (dispatch.mjs continuationOf); null when the slot's session is closed or gone.
+ */
+function openCoder(db, id) {
+  for (const row of all(db, 'SELECT metadata FROM task_runs WHERE task_id = ? AND metadata IS NOT NULL ORDER BY id DESC', id)) {
+    const s = json(row.metadata, {})?.supercode;
+    if (!s?.session_id || (s.slot ?? 'worker') !== 'worker') continue;
+    return !s.forgotten && !detachedSession(db, s) && (s.released || (s.retain_after_run && !s.close_requested)) ? s.session_id : null;
+  }
+  return null;
+}
+
+/**
+ * Run `runId`'s reviewer binding, when it is card `id`'s own coder (a worker or side session adopted onto its review by
+ * mistake, t_2a2ef475 run 2732), leaves the reviewer slot as its review ends, and is never closed by that end:
+ * - the worker slot's latest session (the coder's own, kept open through review by ADR 0019) is handed back to the
+ *   worker slot, retained as a finish retains it, so the next implementer run continues it (transferRetainedSession);
+ * - any other session (a side session beside that coder) is released, as the board releases any session it did not
+ *   launch: left running, its close settled, in no slot, so it neither outranks the coder's session in the worker slot
+ *   nor holds a later review.
+ * Answers whether it did. After it, the binding is an ordinary one of its new slot, closed like any other.
+ */
+function handBackCoder(db, id, runId) {
+  const whole = json(one(db, 'SELECT metadata FROM task_runs WHERE id = ?', runId)?.metadata, {}) ?? {};
+  const session = whole.supercode;
+  if (!session?.session_id || session.role !== 'reviewer' || (session.slot ?? 'worker') !== 'reviewer' || !ownCoder(db, id, session.session_id)) return false;
+  const coder = one(db, `SELECT json_extract(metadata, '$.supercode.session_id') AS session_id FROM task_runs WHERE task_id = ? AND id != ?
+    AND COALESCE(json_extract(metadata, '$.supercode.slot'), 'worker') = 'worker' AND json_extract(metadata, '$.supercode.session_id') IS NOT NULL
+    ORDER BY id DESC LIMIT 1`, id, runId)?.session_id;
+  const at = now();
+  if (coder === session.session_id) whole.supercode = { ...session, slot: 'worker', retain_after_run: true, close_requested: null, handed_back_from: 'reviewer', handed_back_run: runId };
+  else {
+    whole.supercode = { ...session, slot: 'side', retain_after_run: false, close_requested: session.close_requested ?? at, closed_at: at, close_confirmed_at: at, close_error: null, released: true, handed_back_from: 'reviewer', handed_back_run: runId };
+    record(db, id, 'session_released', { session_id: session.session_id, pane: session.pane ?? null, machine: session.machine ?? null, reason: 'the card\'s own coder, bound as its reviewer: left running, out of the reviewer slot' }, runId);
+  }
+  run(db, 'UPDATE task_runs SET metadata = ? WHERE id = ?', JSON.stringify(whole), runId);
+  return true;
+}
+
+/** Whether binding `session` is the one handBackCoder handed back from run `runId`'s review. The marker names its run, so a
+ *  copy of the binding on another run (a continuation) is never taken for it, whatever the copy carried. */
+const handedBackFrom = (session, runId) => session?.handed_back_from === 'reviewer' && Number(session.handed_back_run) === Number(runId);
+
+/** Whether native session `sessionId` is card `id`'s own coder: a worker-slot session of any of its runs, or a side session. */
+export function ownCoder(db, id, sessionId) {
+  if (sideSessions(db, id).some((s) => s.session === sessionId)) return true;
+  return Boolean(one(db, `SELECT 1 FROM task_runs WHERE task_id = ? AND COALESCE(json_extract(metadata, '$.supercode.slot'), 'worker') = 'worker'
+    AND json_extract(metadata, '$.supercode.session_id') = ? LIMIT 1`, id, sessionId));
+}
+
 function runSession(ctx, change) {
   const runId = ctx.runId ?? one(ctx.db, 'SELECT current_run_id FROM tasks WHERE id = ?', ctx.id)?.current_run_id;
   if (!runId) return;
@@ -1475,7 +1600,9 @@ function settleRelations(db, board, entry, id, effects) {
       const current = json(one(db, 'SELECT blocked_by FROM supercode_cards WHERE task_id = ?', id)?.blocked_by, []);
       run(db, 'UPDATE supercode_cards SET blocked_by = ? WHERE task_id = ?', JSON.stringify(current.map((b) => b.id === block.id ? { ...b, answered: answer } : b)), id);
     }
-    if (name) effects.push(...fire(db, board, entry, id, name, { roles: ['platform'], payload: { on: block.id, reason: answer ? `reply ${answer}` : `${block.id} ${status}` } }).effects);
+    // an answer's reaction names who answered as its actor (`by`): nobody is told of what their own reply caused
+    const replier = answer ? mailboxAnswers.get(block.id)?.by ?? null : null;
+    if (name) effects.push(...fire(db, board, entry, id, name, { roles: ['platform'], payload: { on: block.id, reason: answer ? `reply ${answer}` : `${block.id} ${status}`, ...(replier ? { by: replier } : {}) } }).effects);
     // a block that has aged is told once, not every age interval for as long as it lasts
     else if (policy.aged && policy.age_seconds != null && !block.aged_at) {
       const seconds = Number(evaluate(String(policy.age_seconds), { params: entry.params }));