@volter/supercode-orchestrator 0.4.144 → 0.4.146

package/README.md

@@ -299,25 +299,13 @@ platforms:
       host: 127.0.0.1
       port: 8090
       key: ${API_SERVER_KEY}
-  rh2:                        # -> adapters/rh2.mjs: Runhuman Room conversations as a channel
-    enabled: true
-    token: ${RH2_SESSION_TOKEN}                 # the bot principal's automation session; a reference loads as a
-                                                # credential only at the block's top level or under extra:
-    extra:
-      api_url: https://pilot.runhuman.com
-      organization: peakhealth
-      principal_id: prn_…                       # the bot's own principal (is_me, mentions)
 ```
 
-**The RH2 adapter** (`adapters/rh2.mjs`) holds an RH2 session, follows every active Room the bot is
-a member of (or `extra.rooms`), polls each conversation it may read (`GET …/messages?after=`), turns
-a person's line (`kind: human`, or a trigger's `automation`) into an `inbound` on the key
-`{platform: rh2, kind: channel, chat_id: <roomId>/<conversationId>}`, and posts the reply as an
-`agent`-kind message authored as the bot. Typing is RH2 conversation presence, tried once and
-forgotten if the deployment has no door for it.
-
-Both blocks show up in `supercode channels list --harness orchestrator` through the reader that was
-already there — `configured` by key *presence*, never by reading a value.
+RH2 integration attaches through an admin-consented app installation. A hand-written
+`platforms: rh2` block grants no integration authority and the runtime reports it as
+unsupported. The reusable RH2 transport remains in `adapters/rh2.mjs`; the Room-chat
+module supplies its app-owned settings and credentials when that module is installed.
+Native Hermes channel configuration remains the worker's configuration.
 
 **The Chat SDK sidecar** mounts `chat@4.39.0` (npm package `chat`, repo `vercel/chat`; a
 devDependency of this package, installed alongside `@chat-adapter/state-memory@4.39.0`). The

package/adapters/rh2.mjs

@@ -16,19 +16,9 @@
 //   PATCH /rooms/:room/conversations/:c/messages/:id        {body} — a streamed reply grows, a progress line updates, by edit
 //   POST /rooms/:room/conversations/:c/presence            {state: "typing"} — best effort, forgotten on 404
 //
-// The block:
-//   platforms:
-//     rh2:
-//       enabled: true
-//       token: ${RH2_SESSION_TOKEN}                      # the bot principal's session (loads as credentials.token;
-//                                                        # a nested `credentials:` block is not read as one)
-//       extra:
-//         api_url: https://pilot.runhuman.com            # or the boundary's RH2 route
-//         organization: peakhealth
-//         headers: '{"x-twins-key":"…"}'                 # optional extra request headers (JSON)
-//         rooms: room_a,room_b                           # optional; default every active Room the bot is in
-//         principal_id: prn_…                            # the bot's own principal (is_me / mentions)
-//         poll_seconds: 2
+// This is reusable transport code. The daemon does not attach it from a
+// platforms block; an installed integration module owns its settings and token.
+// See docs/adr/0006-teams-installable-apps.md (C1) and the Room-chat module (M4).
 //
 // The surface key is `{platform: 'rh2', kind: 'channel', chat_id: '<roomId>'}`: a Room is one surface, so the agent it
 // seats is one session however many of the Room's conversations it takes part in. A line wakes it where RH2 says the bot

package/bin/runtime.mjs

@@ -65,7 +65,7 @@ import { hermesAccess } from '../hermes-cli.mjs';
 
 import {
   load, save, refreshVault, step, importFrom, exportTo, closeWorld, Orchestrator, LoopbackAdapter,
-  ChatSdkAdapter, ApiServerAdapter, Rh2Adapter,
+  ChatSdkAdapter, ApiServerAdapter,
   TICK_MS, accessPolicy, applyOperator, performRemoveProfileDir, OPERATOR_OPS,
 } from '../index.mjs';
 import * as events from '../events.mjs';
@@ -86,7 +86,6 @@ const ADAPTERS = {
   loopback: (platform, profile) => new LoopbackAdapter({ platform, profile }),
   'chat-sdk': (platform, profile, ctx) => new ChatSdkAdapter({ platform, profile, profileDir: ctx.state.profiles[profile]?.dir ?? null, channel: ctx.channel, vault: ctx.vault, log: ctx.log }),
   api_server: (platform, profile, ctx) => new ApiServerAdapter({ platform, profile, channel: ctx.channel, vault: ctx.vault, state: ctx.state, log: ctx.log }),
-  rh2: (platform, profile, ctx) => new Rh2Adapter({ platform, profile, channel: ctx.channel, vault: ctx.vault, refreshVault: () => refreshVault(ctx.state, ctx.vault), log: ctx.log }),
 };
 
 /// The selector a `platforms:` block resolves through: its `extra.adapter`
@@ -341,6 +340,7 @@ function buildAdapters(state, vault = new Map(), log = () => {}) {
         continue;
       }
       const selector = adapterSelector(platform, channel);
+      if(selector==='rh2'){report.push({platform,profile:profileName,state:'unsupported (RH2 integration requires an installed app; a platforms block grants no integration authority)'});continue;}
       const make = ADAPTERS[selector];
       if (!make) {
         report.push({ platform, profile: profileName, state: `unsupported (no adapter \`${selector}\` for this platform yet)` });

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');
@@ -116,9 +117,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 +132,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)));
@@ -379,7 +384,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 +406,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 +435,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 };
@@ -485,6 +490,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 +505,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);
@@ -542,27 +561,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 +601,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.144",
+  "version": "0.4.146",
   "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": {