@volter/supercode-orchestrator 0.4.145 → 0.4.147

package/board/ci.mjs

@@ -21,8 +21,24 @@ export function completionEvidence(board, id) {
 }
 
 export function observeCompletionEvidence(board, id, entry, payload = {}) {
-  const state = { required: true, ready: false, reason: null };
+  const state = inspectCompletionEvidence(board, id, entry, payload);
   observations.set(key(board, id), state);
+  return state;
+}
+
+export function withCompletionEvidence(board, id, state, fn) {
+  const identity = key(board, id);
+  const previous = observations.get(identity);
+  observations.set(identity, state);
+  try { return fn(); }
+  finally {
+    if (previous) observations.set(identity, previous);
+    else observations.delete(identity);
+  }
+}
+
+export function inspectCompletionEvidence(board, id, entry, payload = {}) {
+  const state = { required: true, ready: false, reason: null };
   if (!entry.params.completion_ci) { Object.assign(state, { required: false, ready: true }); return state; }
   try {
     const task = board.db.prepare('SELECT t.*,c.subtask_of,c.workspace_anchor FROM tasks t LEFT JOIN supercode_cards c ON c.task_id=t.id WHERE t.id=?').get(id);

package/board/cli.mjs

@@ -15,7 +15,7 @@ import { openZtrackBoard } from './ztrack.mjs';
 import * as engine from './engine.mjs';
 import { adoptSession, boardAddress, boardLabel, boardSettings, callerSession, commandEnv, reconcileCallerLaunch, closeRequested, lanesOf, localMachine, observeFleet, paused, plan, startCard, supercodeBin, tick } from './dispatch.mjs';
 import { watchBoard } from './wake.mjs';
-import { completionOwnerOf, loadWorkflow, requestSessionClose, scopeOf, statusOf, useWorkflow, workflowEntry, workflowFor } from './workflow.mjs';
+import { completionOwnerOf, isLatestReviewer, loadWorkflow, requestSessionClose, scopeOf, statusOf, useWorkflow, workflowEntry, workflowFor } from './workflow.mjs';
 import { evaluate } from './expr.mjs';
 
 const HELP = `supercode workflow <verb> [--root <home>] [--board <slug>] [--json]
@@ -47,7 +47,7 @@ Hermes Kanban's verbs, with their flags:
 supercode's own:
   init --backing sqlite|files · boards create <slug> --backing sqlite|files
       Where the board is kept: sqlite is Hermes's kanban.db (the default); files is one JSON file per card.
-  create … --machine M --subtask-of ARC --notify ADDRESS|--no-notify --no-start
+  create … --machine M --subtask-of ARC --notify ADDRESS|--no-notify --no-start [--review-only]
       With a pane lane and room, a card starts at once and answers "started" with its session; else it answers why it
       waits, and its creator is told when it starts. A subtask is worked by its arc's session and never starts alone.
   move <id> <machine|none>   adopt <id> <session> [--assignee P] [--role ROLE]   close <id>   serve (= daemon)   list --machine M
@@ -58,6 +58,7 @@ supercode's own:
   create ... --adopt <session>  hold dispatch until that live session is attached
   goto <id> <status> [reason] [--<field> value]: the event the workflow says takes the card to that status, sent.
 
+  specify <id> --review-only|--no-review-only: a manager declares a standalone independent review job.
   specify/decompose with no spec start a session on the triage card to write it. A card's own session may comment on,
   heartbeat and request review of its card, specify or decompose it in triage, and work its subtasks. The home's
   workflow declares who may block, pause or finish a card; request-state mails its manager without changing state.
@@ -65,7 +66,7 @@ supercode's own:
 
 const MULTI = new Set(['parent', 'skill', 'worker', 'child', 'ids', 'rm']);
 const FLAGS = new Set(['json', 'triage', 'no-notify', 'no-start', 'all', 'force', 'help', 'mine', 'archived', 'reclaim', 'dry-run',
-  'goal', 'no-goal', 'off', 'switch', 'delete', 'no-attachments', 'include-logs', 'verbose']);
+  'goal', 'no-goal', 'review-only', 'no-review-only', 'off', 'switch', 'delete', 'no-attachments', 'include-logs', 'verbose']);
 // flags that take every following word up to the next flag (Hermes's nargs='+')
 const GREEDY = new Set(['ids', 'rm']);
 
@@ -198,7 +199,7 @@ const cardDict = (t) => ({
   created_by: t.created_by, created_at: t.created_at, started_at: t.started_at, completed_at: t.completed_at, result: t.result,
   skills: t.skills ?? [], max_retries: t.max_retries, model_override: t.model_override, provider_override: t.provider_override,
   session_id: t.session_id, workflow_template_id: t.workflow_template_id, current_step_key: t.current_step_key,
-  machine: t.machine ?? null, subtask_of: t.subtask_of ?? null,
+  machine: t.machine ?? null, subtask_of: t.subtask_of ?? null, review_only: Boolean(t.review_only),
 });
 
 /** Hermes's durations: seconds, or 30s / 5m / 2h / 1d. */
@@ -230,6 +231,7 @@ const metadataOf = (v) => {
 export async function runWorkflow(argv) {
   const args = parse(argv);
   const [verb, ...rest] = args._;
+  if (args['review-only'] && args['no-review-only']) throw new Error('Choose review-only or no-review-only, not both.');
   if (!verb || verb === 'help' || args.help) { process.stdout.write(HELP); return 0; }
   const root = homeOf(args);
   const slug = boardOf(root, args);
@@ -251,7 +253,11 @@ export async function runWorkflow(argv) {
   }
   // the board's workflow (the IR's): what each verb does, and who may send it, is its
   // every verb reads the board through its workflow (a list settles cards too), so every verb loads it
-  engine.setCaller((db, cardId) => rolesFor(db, cardId, sid, workflowFor(root).params));
+  engine.setCaller((db, cardId) => {
+    const roles = rolesFor(db, cardId, sid, workflowFor(root).params);
+    if (verb === 'comment' && isLatestReviewer(db, cardId, actorOf()) && !roles.includes('reviewer')) roles.push('reviewer');
+    return roles;
+  });
   // a verb with no session behind it (a person at the CLI, the board file's sync) is the manager's, as its roles are
   if (!sid && verb !== 'help') { try { setActor([].concat(workflowFor(root).params?.managers ?? [])[0] ?? null); } catch { /* no workflow */ } }
 
@@ -296,7 +302,7 @@ export async function runWorkflow(argv) {
         workspace, branch: args.branch, parents: args.parent, priority: args.priority, tenant: args.tenant,
         triage: args.triage, idempotencyKey: args['idempotency-key'], maxRuntime: duration(args['max-runtime']),
         maxRetries, skills: args.skill, model: args.model, provider: args.provider, createdBy: args['created-by'] ?? callerName(),
-        noStart: Boolean(args['no-start']), adopt: args.adopt ?? null,
+        noStart: Boolean(args['no-start']), adopt: args.adopt ?? null, reviewOnly: Boolean(args['review-only']),
         every: args.every ?? null, sessionId: callerSession(), subtaskOf: args['subtask-of'] ?? null, initialStatus: args['initial-status'] ?? null,
         project: args.project ?? meta.project_id ?? null, goal: args.goal ? { maxTurns: args['goal-max-turns'] ? Number(args['goal-max-turns']) : null } : args['no-goal'] ? false : null,
       }), true);
@@ -477,7 +483,7 @@ export async function runWorkflow(argv) {
       for (const t of ids()) await withBoardAsync((b) => engine.setGoal(b, t, { on: !args.off, maxTurns }));
       say(args, ids().map((t) => args.off ? `${t} is no longer a goal card` : `${t} is a goal card${maxTurns ? ` (${maxTurns} turns)` : ''}`).join('\n'), { ok: true }); return 0;
     }
-    case 'move': need(2, 'a card id and a machine (or none)'); withBoard((b) => engine.setMachine(b, id, rest[1] === 'none' ? null : rest[1])); say(args, `${id} runs on ${rest[1]}`, { ok: true }); return 0;
+    case 'move': need(2, 'a card id and a machine (or none)'); await withBoardAsync((b) => engine.setMachine(b, id, rest[1] === 'none' ? null : rest[1])); say(args, `${id} runs on ${rest[1]}`, { ok: true }); return 0;
 
     case 'claim': {
       need(1, 'a card id');
@@ -505,7 +511,7 @@ export async function runWorkflow(argv) {
       need(2, 'a card id and the text');
       let text = rest.slice(1).join(' ');
       if (args['max-len']) text = text.slice(0, Number(args['max-len']));
-      const n = await withBoardAsync((b) => engine.comment(b, id, args.author ?? callerAddress() ?? callerName(), text));
+      const n = await withBoardAsync((b) => engine.comment(b, id, isLatestReviewer(b.db, id, actorOf()) ? actorOf() : args.author ?? callerAddress() ?? callerName(), text));
       say(args, `Comment added to ${id}`, { ok: true, comment: n }); return 0;
     }
     case 'attach': {
@@ -623,8 +629,8 @@ export async function runWorkflow(argv) {
       if (!targets[0]) throw new Error(`${verb} needs a card id, or --all`);
       const results = [];
       for (const t of targets) {
-        if (verb === 'specify' && (args.title !== undefined || args.body !== undefined || args.workspace !== undefined)) {
-          const moved = await withBoardAsync((b) => engine.specify(b, t, { title: args.title ?? null, body: args.body ?? null, workspace: args.workspace ?? null, branch: args.branch ?? null, author: args.author ?? callerAddress() ?? callerName() }));
+        if (verb === 'specify' && (args.title !== undefined || args.body !== undefined || args.workspace !== undefined || args['review-only'] || args['no-review-only'])) {
+          const moved = await withBoardAsync((b) => engine.specify(b, t, { title: args.title ?? null, body: args.body ?? null, workspace: args.workspace ?? null, branch: args.branch ?? null, reviewOnly: args['review-only'] ? true : args['no-review-only'] ? false : null, author: args.author ?? callerAddress() ?? callerName() }));
           results.push({ id: t, specified: true, status: moved.to });
         } else if (verb === 'decompose' && args.child?.length) {
           const children = args.child.map((c) => { const [title, assignee] = c.split(/@(?=[^@]*$)/); return { title: title.trim(), assignee: assignee?.trim() || undefined }; });
@@ -1114,6 +1120,7 @@ function authorize(db, verb, rest, args, own) {
   if (!card) return; // the verb itself answers "no card"
   const creator = completionOwnerOf(db, card.id);
   if (creator && creator === actorOf()) return;
+  if (verb === 'comment' && isLatestReviewer(db, card.id, actorOf())) return;
   // a card's session writes its own card and its subtasks; what it may do with them is the workflow's (`by`)
   if (card.id !== own.id && card.subtask_of !== own.id) refuse(`writes only its own card and its subtasks, not ${card.id}`);
   for (const other of args.ids ?? []) if (other !== own.id && engine.getTask(db, other)?.subtask_of !== own.id) refuse(`writes only its own card and its subtasks, not ${other}`);

package/board/dispatch.mjs

@@ -1085,14 +1085,14 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
   };
   let session = null;
   let replaced = null;
-  if (prev?.surface === 'native' && !prev.pane) {
+  if (prev?.surface === 'native' && !prev.pane && !prev.close_confirmed_at) {
     const reading = nativeReading(nativeSessions(prev.machine, prev.harness), prev);
     if (reading.alive == null) throw unavailable(`cannot establish native continuation liveness for ${addressOf(prev)}`);
     fleet.native ??= new Map(); fleet.native.set(addressOf(prev), reading);
     if (reading.alive && (prev.closed_at || prev.close_requested || prev.forgotten)) throw unavailable(`native session ${addressOf(prev)} is still live; its close must finish before replacement`);
   }
   if (prev?.forgotten) {
-    if (prev.pane && panePresent(prev.machine, prev.pane)) throw new Error(`forgotten session ${prev.session_id} still has live pane ${prev.pane}; close it before replacement`);
+    if (!prev.close_confirmed_at && prev.pane && panePresent(prev.machine, prev.pane)) throw new Error(`forgotten session ${prev.session_id} still has live pane ${prev.pane}; close it before replacement`);
     replaced = { session_id: prev.session_id, why: 'the workflow let it go' };
   }
   else if (prev && (prev.harness ?? 'claude-code') !== harness) {

package/board/engine.mjs

@@ -10,7 +10,7 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { existsSync, rmSync } from 'node:fs';
 import { join, resolve } from 'node:path';
-import { checkWorkspace, assertWorkspaceOwner, declareWorkspace, isLocalWorkspace, isWorkspacePath } from './workspace.mjs';
+import { checkWorkspace, assertWorkspaceOwner, declareWorkspace, isLocalWorkspace } from './workspace.mjs';
 import { DatabaseSync } from 'node:sqlite';
 import { view, actorOf, claimer, event, json, newTaskId, now, tx } from './store.mjs';
 import { observeCompletionEvidence } from './ci.mjs';
@@ -37,7 +37,7 @@ export function getTask(db, id) {
   const row = one(db, 'SELECT * FROM tasks WHERE id = ?', id);
   if (!row) return null;
   const ours = one(db, 'SELECT * FROM supercode_cards WHERE task_id = ?', id);
-  return { ...row, workspace_anchor: ours?.workspace_anchor ?? null, blocked_by: json(ours?.blocked_by, []) ?? [], paused: json(ours?.paused, null), archived: Boolean(ours?.archived), every: ours?.every ?? null, skills: json(row.skills, []) ?? [], machine: ours?.machine ?? null, subtask_of: ours?.subtask_of ?? null };
+  return { ...row, workspace_anchor: ours?.workspace_anchor ?? null, review_only: Boolean(ours?.review_only), blocked_by: json(ours?.blocked_by, []) ?? [], paused: json(ours?.paused, null), archived: Boolean(ours?.archived), every: ours?.every ?? null, skills: json(row.skills, []) ?? [], machine: ours?.machine ?? null, subtask_of: ours?.subtask_of ?? null };
 }
 
 function must(db, id) {
@@ -153,6 +153,7 @@ function projectOf(root, idOrSlug) {
 }
 
 export function createCard(board, spec) {
+  if (spec.reviewOnly !== undefined && typeof spec.reviewOnly !== 'boolean') throw new Error('reviewOnly must be a boolean');
   const title = String(spec.title ?? '').trim();
   if (!title) throw new Error('a card has a title');
   const ws = parseWorkspace(spec.workspace ?? 'scratch');
@@ -182,6 +183,11 @@ export function createCard(board, spec) {
     const missing = parents.filter((p) => !one(db, 'SELECT 1 FROM tasks WHERE id = ?', p));
     if (missing.length) throw new Error(`unknown parent card(s): ${missing.join(', ')}`);
     const arc = spec.subtaskOf ? getTask(db, spec.subtaskOf) : null;
+    const entry = workflowFor(board.root);
+    if (spec.reviewOnly) {
+      const permitted = entry.params.review_only_by;
+      if (arc || spec.every || initial || !Array.isArray(permitted) || !callerRoles(db, arc?.id ?? '').some(role => permitted.includes(role))) throw new Error('Only a permitted manager creates a review-only arc, without recurrence, subtasks or an initial-status override.');
+    }
     if (spec.subtaskOf && !arc) throw new Error(`no card ${spec.subtaskOf} to be a subtask of`);
     if (arc?.subtask_of) throw new Error(`${arc.id} is itself a subtask of ${arc.subtask_of}; a subtask belongs to an arc`);
     let id = newTaskId();
@@ -210,14 +216,13 @@ export function createCard(board, spec) {
       spec.skills?.length ? JSON.stringify(spec.skills) : null, spec.maxRetries ?? null, spec.model ?? null, spec.provider ?? null,
       spec.reasoning ?? null, spec.sessionId ?? null, spec.project ?? null, spec.goal ? 1 : 0, spec.goal?.maxTurns ?? null);
     const machine = spec.machine ?? arc?.machine ?? null;
-    run(db, 'INSERT OR REPLACE INTO supercode_cards (task_id,machine,subtask_of,workspace_anchor,workspace_root) VALUES (?,?,?,?,?)', id, machine, arc?.id ?? null, declared.repository, checked?.mainRoot ?? null);
-    const entry = workflowFor(board.root);
+    run(db, 'INSERT OR REPLACE INTO supercode_cards (task_id,machine,subtask_of,workspace_anchor,workspace_root,review_only) VALUES (?,?,?,?,?,?)', id, machine, arc?.id ?? null, declared.repository, checked?.mainRoot ?? null, spec.reviewOnly ? 1 : 0);
     for (const p of parents) addDependency(db, entry, id, p);
     // where it starts is the workflow's `initial` (Hermes: triage, blocked, todo behind open parents, else ready)
     // the create's own words: whether it asked to be a goal card (null: the workflow decides), triage, its arc
     const status = startNew(db, board, entry, getTask(db, id), { triage: Boolean(spec.triage), initial_status: initial,
-      every: spec.every ?? null, goal: spec.goal === undefined || spec.goal === null ? null : spec.goal !== false, subtask_of: arc?.id ?? null });
-    event(db, id, 'created', { creator: actorOf(), assignee: spec.assignee || null, status, parents, tenant: spec.tenant ?? null, ...(machine ? { machine } : {}), ...(arc ? { subtask_of: arc.id } : {}) });
+      review_only: Boolean(spec.reviewOnly), every: spec.every ?? null, goal: spec.goal === undefined || spec.goal === null ? null : spec.goal !== false, subtask_of: arc?.id ?? null });
+    event(db, id, 'created', { creator: actorOf(), assignee: spec.assignee || null, status, review_only: Boolean(spec.reviewOnly), parents, tenant: spec.tenant ?? null, ...(machine ? { machine } : {}), ...(arc ? { subtask_of: arc.id } : {}) });
     if ((spec.noStart || spec.adopt) && !arc) event(db, id, 'dispatch_held', { session: spec.adopt ?? null, reason: spec.adopt ? 'awaiting adoption' : 'created with --no-start' });
     if (parents.length) inheritSubscriptions(db, id, parents);
     if (arc) {
@@ -251,16 +256,7 @@ function wouldCycle(db, parent, child) {
 
 
 /** The machine a card's session runs on. Moving it is a decision: a running card is reclaimed first. */
-export function setMachine(board, id, machine) {
-  return tx(board, (db) => {
-    const task = must(db, id);
-    if (task.current_run_id) throw new Error(`${id} has an open run on ${task.machine}; end it before moving it`);
-    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');
-    if (machine !== task.machine) run(db, 'UPDATE tasks SET workspace_path=NULL WHERE id=?', id);
-    run(db, 'INSERT INTO supercode_cards (task_id, machine) VALUES (?, ?) ON CONFLICT(task_id) DO UPDATE SET machine = excluded.machine', id, machine || null);
-    event(db, id, 'machine_set', { machine: machine || null, was: task.machine });
-  });
-}
+export const setMachine = (board, id, machine, { roles } = {}) => act(board, id, 'move', { roles, payload: { machine: machine || null } });
 
 // ------------------------------------------------------------------ lifecycle
 
@@ -472,7 +468,7 @@ export const schedule = (board, id, reason = null, { roles } = {}) => act(board,
 export const promote = (board, id, { actor = 'user', reason = null, force = false, roles } = {}) => act(board, id, 'promote', { roles, payload: { actor, reason, force } });
 export const reclaim = (board, id, reason = null, { roles } = {}) => act(board, id, 'reclaim', { roles, payload: { reason } });
 export const archive = (board, id, { roles } = {}) => act(board, id, 'archive', { roles });
-export function specify(board, id, { title = null, body = null, workspace = null, branch = null, author = 'user', roles } = {}) {
+export function specify(board, id, { title = null, body = null, workspace = null, branch = null, reviewOnly = null, author = 'user', roles } = {}) {
   let declaration = null;
   if (workspace != null) {
     const task = getTask(board.db, id), ws = parseWorkspace(workspace);
@@ -480,7 +476,8 @@ export function specify(board, id, { title = null, body = null, workspace = null
     declaration = { kind: ws.kind, ...declareWorkspace(ws.kind, ws.path, task.machine, branch) };
     if (declaration.kind === 'worktree') declaration.branch ??= `wt/${id}`;
   }
-  return act(board, id, 'specify', { roles, payload: { title, body, author, ...(declaration ? { workspace: declaration } : {}) } });
+  if (reviewOnly != null && (typeof reviewOnly !== 'boolean' || !Array.isArray(workflowFor(board.root).params.review_only_by))) throw new Error('This workflow must declare review_only_by before a boolean review-only declaration is changed.');
+  return act(board, id, 'specify', { roles, payload: { title, body, author, ...(reviewOnly != null ? { review_only: reviewOnly } : {}), ...(declaration ? { workspace: declaration } : {}) } });
 }
 export const editResult = (board, id, { result, summary = null, metadata = undefined, roles } = {}) => act(board, id, 'edit', { roles, payload: { result, summary, metadata } });
 export const heartbeat = (board, id, note = null, { roles, until = null } = {}) => act(board, id, 'heartbeat', { roles, payload: { note, until } });
@@ -600,6 +597,7 @@ export function cardContext(db, id) {
   const task = must(db, id);
   const out = [`# Card ${task.id}: ${task.title}`, ''];
   out.push(`Status: ${task.status}. Machine: ${task.machine ?? 'unset'}. Workspace: ${task.workspace_kind}${task.workspace_anchor ? ` ${task.workspace_anchor}` : task.workspace_path ? ` ${task.workspace_path}` : ''}${task.branch_name ? ` (branch ${task.branch_name})` : ''}.${task.subtask_of ? ` A subtask of ${task.subtask_of}.` : ''}`);
+  if (task.review_only) out.push('Purpose: review-only. Record the independent verdict with request-state --state done --reason <verdict> --evidence <artifact>; its creator or manager accepts this review job.');
   if (task.body) out.push('', cap(task.body, 8 * 1024));
   const parents = all(db, 'SELECT t.id, t.title, t.result FROM tasks t JOIN task_links l ON l.parent_id = t.id WHERE l.child_id = ?', id);
   if (parents.length) {

package/board/store.mjs

@@ -73,7 +73,7 @@ const OURS = `CREATE TABLE IF NOT EXISTS supercode_cards (task_id TEXT PRIMARY K
 CREATE TABLE IF NOT EXISTS supercode_effects (id INTEGER PRIMARY KEY AUTOINCREMENT, effect TEXT NOT NULL);`;
 // `stage`: the card's workflow status where kanban.db stores another (a `reviewing` card is `running` to Hermes)
 // `since`: when the card entered its workflow status; `after_fired`: which of the status's `after` moves have run since
-const OURS_COLUMNS = { workspace_anchor: 'TEXT', workspace_root: 'TEXT', subtask_of: 'TEXT', stage: 'TEXT', since: 'INTEGER', after_fired: 'TEXT', blocked_by: 'TEXT', paused: 'TEXT', archived: 'INTEGER DEFAULT 0', every: 'TEXT', next_run_at: 'INTEGER' };
+const OURS_COLUMNS = { workspace_anchor: 'TEXT', workspace_root: 'TEXT', subtask_of: 'TEXT', review_only: 'INTEGER DEFAULT 0', stage: 'TEXT', since: 'INTEGER', after_fired: 'TEXT', blocked_by: 'TEXT', paused: 'TEXT', archived: 'INTEGER DEFAULT 0', every: 'TEXT', next_run_at: 'INTEGER' };
 
 // ------------------------------------------------------------------ backings
 //

package/board/tools.mjs

@@ -7,7 +7,7 @@ import { mkdirSync, statSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import { DEFAULT_BOARD, actorOf, event, json, openBoard, setActor, tx } from './store.mjs';
 import * as engine from './engine.mjs';
-import { completionOwnerOf, loadWorkflow } from './workflow.mjs';
+import { completionOwnerOf, isLatestReviewer, loadWorkflow } from './workflow.mjs';
 
 const ok = (fields = {}) => JSON.stringify({ ok: true, ...fields });
 const error = (message) => JSON.stringify({ error: message });
@@ -44,6 +44,7 @@ export async function boardTool(root, name, args = {}, env = {}) {
     if (!own || !runId) return own ? [] : ['manager'];
     const meta = json(db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(runId)?.metadata, {})?.supercode ?? {};
     const roles = cardId === own ? [meta.role ?? 'implementer'] : [];
+    if (name === 'kanban_comment' && isLatestReviewer(db, cardId, actorOf()) && !roles.includes('reviewer')) roles.push('reviewer');
     if (actorOf() && completionOwnerOf(db, cardId) === actorOf()) roles.push('creator');
     return roles;
   });
@@ -65,7 +66,7 @@ export async function boardTool(root, name, args = {}, env = {}) {
       ? `run ${runId ?? '(missing)'} of ${own} is no longer its current run; nothing was changed` : null;
   };
   try {
-    if (name !== 'kanban_show' && name !== 'kanban_list') { const stale = ownRun(); if (stale) return error(stale); }
+    if (name !== 'kanban_show' && name !== 'kanban_list' && !(name === 'kanban_comment' && isLatestReviewer(board.db, tid, actorOf()))) { const stale = ownRun(); if (stale) return error(stale); }
     switch (name) {
       case 'kanban_show': {
         const card = tx(board, (db) => { const c = engine.showCard(db, tid); c.context = engine.cardContext(db, tid); return c; });
@@ -73,7 +74,7 @@ export async function boardTool(root, name, args = {}, env = {}) {
         return JSON.stringify({
           task: { id: t.id, title: t.title, body: t.body, assignee: t.assignee, status: t.status, tenant: t.tenant, priority: t.priority, workspace_kind: t.workspace_kind,
             workspace_path: t.workspace_path, created_by: t.created_by, created_at: t.created_at, started_at: t.started_at, completed_at: t.completed_at, result: t.result,
-            current_run_id: t.current_run_id, model_override: t.model_override, provider_override: t.provider_override },
+            current_run_id: t.current_run_id, model_override: t.model_override, provider_override: t.provider_override, review_only: Boolean(t.review_only) },
           parents: card.parents.map((p) => p.id), children: card.children,
           comments: card.comments, events: card.events.slice(-50), runs: card.runs.map((r) => ({ id: r.id, profile: r.profile, status: r.status, outcome: r.outcome, summary: r.summary, error: r.error, metadata: r.metadata, started_at: r.started_at, ended_at: r.ended_at })),
           worker_context: card.context,
@@ -135,7 +136,7 @@ export async function boardTool(root, name, args = {}, env = {}) {
       }
       case 'kanban_comment': {
         if (!String(args.body ?? '').trim()) return error('body is required');
-        const n = await engine.comment(board, tid, author, redact(String(args.body)));
+        const n = await engine.comment(board, tid, isLatestReviewer(board.db, tid, actorOf()) ? actorOf() : author, redact(String(args.body)));
         return ok({ task_id: tid, comment_id: n });
       }
       case 'kanban_attach': case 'kanban_attach_url': {
@@ -169,7 +170,7 @@ export async function boardTool(root, name, args = {}, env = {}) {
           title: args.title, body: args.body ? redact(String(args.body)) : null, assignee: args.assignee ?? null, parents: [args.parents ?? []].flat(), tenant: args.tenant ?? null,
           priority: args.priority ?? 0, workspace, project: args.project ?? null, triage: Boolean(args.triage), idempotencyKey: args.idempotency_key ?? null,
           maxRuntime: args.max_runtime_seconds ?? null, initialStatus: args.initial_status ?? null, skills: args.skills ?? null, model: args.model ?? null, provider: args.provider ?? null,
-          goal: args.goal_mode ? { maxTurns: args.goal_max_turns ?? null } : null, createdBy: author,
+          goal: args.goal_mode ? { maxTurns: args.goal_max_turns ?? null } : null, createdBy: author, reviewOnly: args.review_only ?? false,
         });
         return ok({ task_id: made.id, existing: made.existing, status: tx(board, (db) => engine.getTask(db, made.id)).status });
       }

package/board/workflow.mjs

@@ -12,6 +12,7 @@ import { randomBytes } from 'node:crypto';
 import { actorOf, appendRunObservation, event as record, json, now } from './store.mjs';
 import { evaluate, holds, render } from './expr.mjs';
 import { completionEvidence } from './ci.mjs';
+import { isWorkspacePath } from './workspace.mjs';
 
 const loaded = new Map();
 
@@ -70,6 +71,18 @@ export function completionOwnerOf(db, id) {
   return creatorOf(db, id);
 }
 
+export function latestReview(db, id) {
+  const row = one(db, "SELECT id,started_at,metadata FROM task_runs WHERE task_id=? AND json_extract(metadata,'$.supercode.role')='reviewer' ORDER BY id DESC LIMIT 1", id);
+  if (!row) return null;
+  const session = json(row.metadata, {})?.supercode ?? {};
+  const address = session.address ?? (session.machine && session.harness && session.session_id ? `sc:${session.machine}:${session.harness}:${session.session_id}` : null);
+  return { id: row.id, started_at: row.started_at, address };
+}
+
+export function isLatestReviewer(db, id, address) {
+  return Boolean(address && latestReview(db, id)?.address === address);
+}
+
 /** What kanban.db stores for `status`. */
 export function storedAs(workflow, status) {
   return workflow.statuses[status]?.stored_as ?? status;
@@ -236,6 +249,8 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {} } = {}
     ...task,
     creator_address: creatorOf(db, task.id),
     completion_owner_address: completionOwnerOf(db, task.id),
+    review_only: Boolean(state.review_only),
+    latest_review: latestReview(db, task.id) ?? {},
     ci: completionEvidence(board, task.id),
     dispatch_hold: one(db, "SELECT kind FROM task_events WHERE task_id=? AND kind IN ('dispatch_held','dispatch_released','session_adopted') ORDER BY id DESC LIMIT 1", task.id)?.kind === 'dispatch_held',
     status,
@@ -560,6 +575,7 @@ const FORMAT = {
   commented: ({ e }) => ({ author: String(e.author ?? 'user').trim(), len: String(e.body ?? '').length }),
   archived: () => null,
   status: ({ e, before, to }) => ({ status: to, reason: e.reason ?? 'reopened', previous_status: before.stored_as }),
+  machine_set: ({ e, before }) => ({ machine: e.machine ?? null, was: before.machine }),
 };
 const RETRY_KINDS = new Set(['crashed', 'timed_out', 'stale', 'rate_limited', 'session_lost', 'reclaimed', 'reconciled', 'spawn_failed']);
 
@@ -653,6 +669,14 @@ const ACTIONS = {
     } else record(ctx.db, on ?? ctx.id, kind, payload && Object.keys(payload).length ? payload : null, on ? null : ctx.runId);
   },
   assign(ctx, { field, value }) {
+    if (field === 'machine') {
+      const task = one(ctx.db, 'SELECT t.current_run_id,t.workspace_kind,c.workspace_anchor,c.machine FROM tasks t JOIN supercode_cards c ON c.task_id=t.id WHERE t.id=?', ctx.id);
+      if (task.current_run_id) throw new Error('End the current run before moving its card.');
+      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');
+      if ((value ?? null) !== task.machine) run(ctx.db, 'UPDATE tasks SET workspace_path=NULL WHERE id=?', ctx.id);
+      cardField(ctx, 'machine', value ?? null);
+      return;
+    }
     if (!ASSIGNABLE.has(field)) throw new Error(`the workflow assigns ${field}, which is not a card field it may set`);
     run(ctx.db, `UPDATE tasks SET ${field} = ? WHERE id = ?`, typeof value === 'boolean' ? Number(value) : value ?? null, ctx.id);
   },
@@ -742,6 +766,12 @@ const ACTIONS = {
     run(ctx.db, 'DELETE FROM task_links WHERE parent_id = ? AND child_id = ?', parent, ctx.id);
   },
   specify(ctx, said) {
+    if (said?.review_only != null) {
+      const task = cardOf(ctx.db, ctx.id);
+      if (typeof said.review_only !== 'boolean' || task.current_run_id || task.subtask_of || ctx.scope.card.every) throw new Error('A review-only declaration changes only an arc with no current run or recurrence.');
+      cardField(ctx, 'review_only', said.review_only ? 1 : 0);
+      record(ctx.db, ctx.id, 'review_mode_changed', { review_only: said.review_only }, null);
+    }
     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');
@@ -779,14 +809,32 @@ const ACTIONS = {
   // the slot's last session is let go: its next run starts a new session (a card's context is otherwise kept: a
   // session that cannot be resumed stops the card, it is never replaced on the board's own account)
   forget_session(ctx, slot) {
-    const name = String(slot ?? 'worker');
+    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;
+    const released = new Set();
     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, {}) ?? {};
-      if (!whole.supercode?.session_id || (whole.supercode.slot ?? 'worker') !== name) continue;
-      whole.supercode = { ...whole.supercode, forgotten: now() };
-      run(ctx.db, 'UPDATE task_runs SET metadata = ? WHERE id = ?', JSON.stringify(whole), row.id);
-      return;
+      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, {}) ?? {};
+      if (session.session_id) released.add(session.session_id);
+      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);
     }
+    const gaveUp = one(ctx.db, "SELECT created_at,payload FROM task_events WHERE task_id=? AND kind='gave_up' ORDER BY id DESC LIMIT 1", ctx.id);
+    const failures = Number(json(gaveUp?.payload, {})?.failures ?? 0);
+    if (!failures || !released.size) return;
+    const recent = all(ctx.db, 'SELECT outcome,metadata FROM task_runs WHERE task_id=? AND ended_at<=? ORDER BY id DESC LIMIT ?', ctx.id, gaveUp.created_at, failures);
+    if (recent.length !== failures || !recent.every(row => {
+      const failure = json(row.metadata, {})?.last_events?.spawn_failed?.payload;
+      return row.outcome === 'spawn_failed' && failure?.resume_failed === true && released.has(failure.session_id);
+    })) return;
+    const blocks = json(one(ctx.db, 'SELECT blocked_by FROM supercode_cards WHERE task_id=?', ctx.id)?.blocked_by, []);
+    for (const block of blocks.filter(block => block.kind === 'message' && block.reason === 'failure limit reached' && block.since === gaveUp.created_at))
+      ACTIONS.relation(ctx, { remove: block.id, reason: 'The manager released the session responsible for these stale continuation failures.' });
+    run(ctx.db, 'UPDATE tasks SET consecutive_failures=0,last_failure_error=NULL WHERE id=?', ctx.id);
   },
   // 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
@@ -845,7 +893,7 @@ export function requestSessionClose(db, id, { runId = null, slot = null, through
     if ((runId != null && row.id !== runId) || (through != null && row.id > through)) continue;
     const whole = json(row.metadata, {}) ?? {};
     const session = whole.supercode;
-    if ((!session?.pane && !session?.launch_key) || session.close_transferred_to || session.close_confirmed_at || (slot != null && (session.slot ?? 'worker') !== slot)) 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;
     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

package/board/ztrack.mjs

@@ -8,6 +8,7 @@ import { RuntimeRows } from './rows.mjs';
 import { DatabaseSync } from 'node:sqlite';
 import { actorOf, event, json, now, setActor } from './store.mjs';
 import { fire, projectStatus, statusOf, workflowFor } from './workflow.mjs';
+import { inspectCompletionEvidence, withCompletionEvidence } from './ci.mjs';
 
 const require = createRequire(import.meta.url);
 const hash = (text) => createHash('sha256').update(text).digest('hex');
@@ -26,6 +27,14 @@ const sqliteContention = error => [5, 6].includes(Number(error?.errcode) & 255)
   || /^database (?:table |schema )?is locked$/i.test(error?.message ?? '');
 const exportConflict = error => error?.message === 'Hermes wrote during board export; retained its events for the next read';
 const recoveryConflict = error => error?.message === 'document changed during recovery; retry';
+// One-shot verbs open the same board several times. Share byte-keyed codec
+// work across those instances and cap retention for long-running dispatchers.
+const documentCache = new Map(), renderCache = new Map();
+function remember(cache, path, value) {
+  cache.delete(path);
+  cache.set(path, value);
+  while (cache.size > 8) cache.delete(cache.keys().next().value);
+}
 
 export function openZtrackBoard(marker, { create = false, document = null, seed = null, init, root, slug, compatPath }) {
   if (!existsSync(marker)) {
@@ -48,6 +57,9 @@ class ZtrackBoard {
     this.runtime = new DatabaseSync(this.runtimePath);
     this.readOnly(()=>{ if (!this.runtime.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='state'").get()) this.runtime.exec('CREATE TABLE IF NOT EXISTS state (key TEXT PRIMARY KEY, value TEXT NOT NULL)'); });
     this.errors = new Map(); this.preserve = new Map();
+    // Codec projections depend on document bytes, not runtime revisions. Keep one
+    // entry per document across optimistic retries; run/event churn must not
+    // repeatedly parse an unchanged board before reaching its version check.
     this.mem = null; this.active = false; this.rows = new RuntimeRows(this.runtime);
     mkdirSync(dirname(this.path), { recursive: true });
     const self = this;
@@ -116,9 +128,10 @@ class ZtrackBoard {
   }
 
   transaction(fn) {
-    if (this.cachedReader) this.invalidate();
     this.readOnly(()=>{ if(this.runtime.prepare('PRAGMA journal_mode').get().journal_mode!=='wal')this.runtime.exec('PRAGMA journal_mode=WAL'); });
     for (;;) {
+      const incoming = this.readOnly(() => this.prepareHermes());
+      if (this.cachedReader) this.invalidate();
       try { this.runtime.exec('BEGIN'); }
       catch (error) { if (!sqliteContention(error)) throw error; continue; }
       this.active = true;
@@ -130,8 +143,11 @@ class ZtrackBoard {
         // Parsing, rules and rendering run against a snapshot, without a runtime writer transaction.
         this.pendingValues = new Map(); this.computing = true;
         this.load({ observe: true });
+        if (incoming && (incoming.version !== version || incoming.open !== hash(this.text) || incoming.archived !== hash(this.archiveText))) {
+          this.invalidate(); continue;
+        }
         if (this.seed) this.seedIntoMemory();
-        else this.lift();
+        else this.lift(incoming);
         const result = fn(this.db);
         const changes = this.rows.changes(this.mem, { all: !this.rows.normalized() });
         const canonical = (row, omitted) => row && Object.fromEntries(Object.entries(row).filter(([key])=>!omitted.has(key)));
@@ -320,7 +336,7 @@ class ZtrackBoard {
     this.errors.clear(); this.preserve.clear();
     const records = []; this.documentRecords=new Map();
     for (const [text,path] of [[this.text,this.path],[this.archiveText,this.archive]]) {
-      const result = this.codec.inspectBoardDocument(text,path);
+      const result = this.inspectDocument(text,path);
       const kept = new Set(result.errors.map(e=>e.id));
       for(const error of result.errors)this.errors.set(nativeId(error.id),error.reason);
       for(const record of result.records) {
@@ -379,7 +395,7 @@ class ZtrackBoard {
         status: task.status === 'passed' ? (task.metadata?.status === 'cancelled' ? 'cancelled' : 'done') : (['done','cancelled'].includes(task.metadata?.status) ? 'todo' : task.metadata?.status ?? 'todo'),
         metadata: task.metadata?.properties ?? {}, assignee: task.metadata?.assignee ?? card.assignee,
         machine: task.metadata?.machine ?? card.machine, acceptanceCriteria: [], acceptance: task.lines ?? [],
-        relations: (task.blockedBy ?? []).map((b) => ({ type: 'blocked-by', issueId: b.ac ? `${nativeId(b.issue)}:${b.ac}` : nativeId(b.issue) })) };
+        relations: (task.blockedBy ?? []).map((b) => ({ type: 'blocked-by', issueId: b.ac && /^(?:[ma]-[0-9a-f]{6,}|t_[0-9a-f]+)$/.test(b.ac) ? b.ac : b.ac ? `${nativeId(b.issue)}:${b.ac}` : nativeId(b.issue) })) };
       if (task.waitingOn) taskCard.relations.push({ type: 'blocked-by', issueId: task.waitingOn });
       return [tid, taskCard];
     });
@@ -401,7 +417,7 @@ class ZtrackBoard {
     const value = (task, state, field) => field === 'status' ? state?.stage ?? task?.status ?? 'todo'
       : field === 'blocked_by' ? json(state?.blocked_by, []).map(b => [b.kind, b.id]).sort()
       : field === 'paused' ? json(state?.paused, null)
-      : field === 'archived' ? Boolean(state?.archived) : task?.[field] ?? null;
+      : field === 'archived' ? Boolean(state?.archived) : field === 'review_only' ? Boolean(state?.review_only) : task?.[field] ?? null;
     for (const id of new Set([...tasks.keys(), ...Object.keys(this.rows.cachedTasks)])) {
       if (this.errors.has(id)) continue;
       const oldTask = this.rows.cachedTasks[id], oldState = this.rows.cachedCards[id];
@@ -430,7 +446,7 @@ class ZtrackBoard {
     const task = { ...meta, ...this.saved.runtime?.[id], id, title: card.title, body: stored.body,
       status: card.status, assignee: card.assignee ?? null, created_at: meta.created_at ?? now(), priority: card.priority ?? 0,
       workspace_kind: workspace?.[1] ?? 'scratch', workspace_path: this.saved.runtime?.[id]?.workspace_path ?? (/^(\/|~|[A-Za-z]:[\\/])/.test(workspace?.[2] ?? '') ? workspace[2] : null), branch_name: card.branch ?? null };
-    const state = { ...this.saved.clocks?.[id], task_id: id, workspace_anchor: workspace?.[2] ?? null, stage: card.status, machine: card.machine ?? null, subtask_of: parent,
+    const state = { ...this.saved.clocks?.[id], task_id: id, workspace_anchor: workspace?.[2] ?? null, review_only: meta.review_only === true ? 1 : 0, stage: card.status, machine: card.machine ?? null, subtask_of: parent,
       blocked_by: JSON.stringify((card.relations ?? []).map((r) => ({ ...(meta.blocked_by ?? []).find((b) => b.id === nativeId(r.issueId)), id: nativeId(r.issueId), kind: /^[ma]-/.test(r.issueId) ? 'message' : 'card' }))),
       paused: card.paused ? JSON.stringify(card.paused) : null, archived: meta.archived ? 1 : 0, every: card.every ?? null };
     return { task, state };
@@ -473,6 +489,21 @@ class ZtrackBoard {
   committer() {
     return 'document-editor';
   }
+  inspectDocument(text, path) {
+    const previous = documentCache.get(path);
+    if (previous?.text === text) return previous.result;
+    const result = this.codec.inspectBoardDocument(text, path);
+    remember(documentCache, path, { text, result });
+    return result;
+  }
+  renderDocument(text, records, path, preserve) {
+    const projection = JSON.stringify([records, preserve]);
+    const previous = renderCache.get(path);
+    if (previous?.text === text && previous.projection === projection) return previous.result;
+    const result = this.codec.renderBoardDocument(text, records, path, preserve);
+    remember(renderCache, path, { text, projection, result });
+    return result;
+  }
   documents(changes=null) {
     this.publishedFingerprints = {};
     const allRows = this.mem.prepare('SELECT * FROM tasks ORDER BY created_at, id').all();
@@ -485,6 +516,7 @@ class ZtrackBoard {
       const parsed = this.preset.KanbanRootSchema.parse(this.preset.parseKanban([{ id: this.fileIds.get(row.id) ?? row.id, title: row.title, status: c.stage ?? row.status, assignee: row.assignee || undefined, body: row.body ?? '' }])).issues[0];
       const metadata = Object.fromEntries(Object.entries(row).filter(([k, v]) => !RUNTIME.has(k) && !CARD_MAIN.has(k) && v != null));
       if (c.archived) metadata.archived = true;
+      if (c.review_only) metadata.review_only = true;
       if (json(c.blocked_by, []).length) metadata.blocked_by = json(c.blocked_by, []);
       cards.set(row.id, { ...parsed, metadata, priority: row.priority ?? 0, workspace: row.workspace_kind + (row.workspace_kind !== 'scratch' && (c.workspace_anchor ?? row.workspace_path) ? `:${c.workspace_anchor ?? row.workspace_path}` : ''),
         branch: row.branch_name || undefined, machine: c.machine || undefined, paused: json(c.paused, null) ?? undefined, every: c.every || undefined,
@@ -499,20 +531,33 @@ class ZtrackBoard {
     }
     const renderedKeys = new Set();
     for (const row of rows.filter((r) => states.get(r.id)?.subtask_of && !this.errors.has(r.id))) {
-      const c = states.get(row.id); const parent = cards.get(c.subtask_of);
-      if (!parent) throw new Error(`subtask ${row.id} has no arc ${c.subtask_of}`);
+      const c = states.get(row.id);
+      if (!cards.has(c.subtask_of)) throw new Error(`subtask ${row.id} has no arc ${c.subtask_of}`);
       const taken = occupied.get(c.subtask_of) ?? new Set(); occupied.set(c.subtask_of, taken);
       const match = /^([a-z]+\d+)\s+(.+)$/.exec(row.title);
       let key = this.taskKeys.get(row.id)?.split(':').at(-1) ?? match?.[1];
       if (!key || renderedKeys.has(`${c.subtask_of}:${key}`)) { let n = 1; while (taken.has(`c${n}`)) n++; key = `c${n}`; }
       taken.add(key); renderedKeys.add(`${c.subtask_of}:${key}`); this.taskKeys.set(row.id, `${c.subtask_of}:${key}`);
+    }
+    for (const row of rows.filter((r) => states.get(r.id)?.subtask_of && !this.errors.has(r.id))) {
+      const c = states.get(row.id); const parent = cards.get(c.subtask_of);
+      const key = this.taskKeys.get(row.id).split(':').at(-1);
+      const match = /^([a-z]+\d+)\s+(.+)$/.exec(row.title);
       const parsed = this.preset.KanbanRootSchema.parse(this.preset.parseKanban([{ id: row.id, title: row.title, status: c.stage ?? row.status, body: row.body ?? '' }])).issues[0];
       const originalTask = this.originals.get(c.subtask_of)?.acceptanceCriteria.find((t) => t.id === key);
+      const blocks = json(c.blocked_by, []);
+      const messages = blocks.filter(block => block.kind === 'message');
       parent.acceptanceCriteria.push({ sources: originalTask?.sources, id: key, status: ['done', 'cancelled'].includes(c.stage ?? row.status) ? 'passed' : 'pending', evidence: [], text: match?.[2] ?? row.title,
         metadata: { id: row.id, status: c.stage ?? row.status, body: parsed.body, assignee: row.assignee, machine: c.machine,
           properties: Object.fromEntries(Object.entries(row).filter(([k,v]) => !RUNTIME.has(k) && !CARD_MAIN.has(k) && v != null)),
           card: { paused: json(c.paused, null) ?? undefined, every: c.every || undefined } }, lines: parsed.acceptance,
-        blockedBy: json(c.blocked_by, []).map((b) => ({ issue: b.id })) });
+        waitingOn: messages[0]?.id,
+        blockedBy: blocks.filter(block => block !== messages[0]).map(block => {
+          const target = this.taskKeys.get(block.id);
+          if (!target) return { issue: this.fileIds.get(block.id) ?? block.id };
+          const [arcId, taskKey] = target.split(':');
+          return { issue: this.fileIds.get(arcId) ?? arcId, ac: taskKey };
+        }) });
     }
     const open = [], archived = [];
     if(affected)for(const [id,{record,path}] of this.documentRecords??[])if(!affected.has(id)&&!this.errors.has(id))(path===this.path?open:archived).push(record);
@@ -532,7 +577,7 @@ class ZtrackBoard {
     }
     const original=this.documentRecords;
     const changedPath=path=>!affected||[...affected].some(id=>original?.get(id)?.path===path||cards.has(id)&&((states.get(id)?.archived||['done','cancelled'].includes(cards.get(id).status))?this.archive:this.path)===path);
-    return { open: !changedPath(this.path)?this.text:this.codec.renderBoardDocument(this.text, open, this.path, [...(this.preserve.get(this.path)??[])]), archived: !changedPath(this.archive)?this.archiveText:this.codec.renderBoardDocument(this.archiveText, archived, this.archive, [...(this.preserve.get(this.archive)??[])]) };
+    return { open: !changedPath(this.path)?this.text:this.renderDocument(this.text, open, this.path, [...(this.preserve.get(this.path)??[])]), archived: !changedPath(this.archive)?this.archiveText:this.renderDocument(this.archiveText, archived, this.archive, [...(this.preserve.get(this.archive)??[])]) };
   }
   snapshot(documents) {
     const fingerprints = this.fingerprints();
@@ -542,27 +587,39 @@ class ZtrackBoard {
     return { bodyProjection:2, documentHashes:{open:hash(documents.open),archived:hash(documents.archived)}, errors:[...this.errors], fingerprints: { ...fingerprints, ...this.publishedFingerprints }, taskIds: Object.fromEntries([...this.taskKeys].map(([id, key]) => [key, id])) };
   }
 
-  lift() {
-    if (!existsSync(this.compatPath)) return;
-    let entry; try { entry = workflowFor(this.root); } catch { return; }
-    const compat = new DatabaseSync(this.compatPath);
+  prepareHermes() {
+    if (this.seed || !existsSync(this.compatPath)) return null;
+    let entry; try { entry = workflowFor(this.root); } catch { return null; }
+    const compat = new DatabaseSync(this.compatPath, { readOnly: true });
     try {
+      const prepared = { entry, evidence: new Map(), version: this.get('version'), open: hash(read(this.path)), archived: hash(read(this.archive)) };
       const cursor = this.get('hermes_cursor', 0);
-      const rows = compat.prepare('SELECT * FROM task_events WHERE id > ? ORDER BY id').all(cursor);
-      const before = actorOf();
-      try {
-        for (const row of rows) {
-          const payload = json(row.payload, {}) ?? {};
-          if (payload.__supercode_export) continue;
-          const task = this.mem.prepare('SELECT * FROM tasks WHERE id = ?').get(row.task_id);
-          if (!task) continue;
-          this.mem.exec('SAVEPOINT hermes_card');
-          try {
+      prepared.rows = compat.prepare('SELECT * FROM task_events WHERE id > ? ORDER BY id').all(cursor);
+      for (const row of prepared.rows) {
+        const payload = json(row.payload, {}) ?? {};
+        if (row.kind !== 'completed' || payload.__supercode_export || !this.db.prepare('SELECT 1 FROM tasks WHERE id=?').get(row.task_id)) continue;
+        prepared.evidence.set(row.id, inspectCompletionEvidence(this.board(), row.task_id, entry, payload));
+      }
+      return prepared;
+    } finally { compat.close(); }
+  }
+  lift(prepared) {
+    if (!prepared) return;
+    const { entry, rows, evidence } = prepared;
+    const before = actorOf();
+    try {
+      for (const row of rows) {
+        const payload = json(row.payload, {}) ?? {};
+        if (payload.__supercode_export) continue;
+        const task = this.mem.prepare('SELECT * FROM tasks WHERE id = ?').get(row.task_id);
+        if (!task) continue;
+        this.mem.exec('SAVEPOINT hermes_card');
+        try {
           const roles = ['manager', 'reviewer', 'platform', 'hermes'];
           setActor(payload.by ?? 'hermes');
           let name = null; let words = { ...payload, reason: payload.reason ?? 'unblocked in Hermes' };
           if (row.kind === 'unblocked') { name = 'unblock'; words = { ...words, reason: 'unblocked in Hermes', hermes: true }; }
-          else if (row.kind === 'completed') { name = 'complete'; words.summary = payload.summary ?? task.result; }
+          else if (row.kind === 'completed') { name = 'complete'; words.summary = payload.summary ?? task.result; words.ci = evidence.get(row.id); }
           else if (row.kind === 'blocked' || row.kind === 'dependency_wait') { name = 'block'; words.on = payload.on ?? payload.parent ?? null; words.hermes = true; }
           else if (row.kind === 'archived' && statusOf(this.mem, task) !== 'done') name = 'cancel';
           if (row.kind === 'unblocked' && entry.workflow.verbs?.hermes_unpause) {
@@ -570,19 +627,19 @@ class ZtrackBoard {
             for (const effect of resumed.effects) this.mem.prepare('INSERT INTO supercode_effects (effect) VALUES (?)').run(JSON.stringify(effect));
           }
           if (name) {
-            const result = fire(this.mem, this.board(), entry, task.id, name, { roles, payload: words });
+            const apply = () => fire(this.mem, this.board(), entry, task.id, name, { roles, payload: words });
+            const result = name === 'complete' ? withCompletionEvidence(this.board(), task.id, words.ci, apply) : apply();
             for (const effect of result.effects) this.mem.prepare('INSERT INTO supercode_effects (effect) VALUES (?)').run(JSON.stringify(effect));
           }
           event(this.mem, task.id, 'hermes_lifted', { by: 'hermes', source_event: row.id, verb: name, kind: row.kind });
           this.mem.exec('RELEASE hermes_card');
-          } catch(error) {
-            this.mem.exec('ROLLBACK TO hermes_card; RELEASE hermes_card');
-            event(this.mem, task.id, 'hermes_refused', {by:'hermes',source_event:row.id,kind:row.kind,reason:error.message});
-          }
+        } catch(error) {
+          this.mem.exec('ROLLBACK TO hermes_card; RELEASE hermes_card');
+          event(this.mem, task.id, 'hermes_refused', {by:'hermes',source_event:row.id,kind:row.kind,reason:error.message});
         }
-      } finally { setActor(before); }
-      if (rows.length) this.put('hermes_cursor', rows.at(-1).id);
-    } finally { compat.close(); }
+      }
+    } finally { setActor(before); }
+    if (rows.length) this.put('hermes_cursor', rows.at(-1).id);
   }
   flushExport() {
     const changes = this.get('export_pending', []);

package/mcp/hermes-kanban-tools.json

@@ -345,6 +345,10 @@
     "inputSchema": {
       "type": "object",
       "properties": {
+        "review_only": {
+          "type": "boolean",
+          "description": "Declare a standalone independent review job, where permitted by the home's manager policy. Its verdict is accepted without another review of the review; implementation arcs keep their independent review requirement."
+        },
         "title": {
           "type": "string",
           "description": "Short task title (required)."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.4.145",
+  "version": "0.4.147",
   "type": "module",
   "description": "The orchestrator runtime over the Volter Harness ontology: one typed operational model whose folder is its serialization, read and written through the harness orchestration doors (docs/ORCHESTRATOR-IR.md)",
   "exports": {