@volter/supercode-orchestrator 0.5.112 → 0.5.114

package/board/ci.mjs

@@ -118,7 +118,7 @@ export function withCompletionEvidence(board, id, state, fn) {
 export function reviewCandidate(board, id) {
   const row = board.db.prepare("SELECT payload FROM task_events WHERE task_id=? AND kind='review_requested' ORDER BY id DESC LIMIT 1").get(id);
   const payload = row && JSON.parse(row.payload);
-  return payload?.ci?.pr ? payload.ci : null;
+  return payload?.ci?.pr || payload?.ci?.no_code ? payload.ci : null;
 }
 
 /** The PRs an evidence record covers: every PR of one arc review (the first is also its top-level PR). */
@@ -215,17 +215,17 @@ export function declaredWorkBranches(db, id) {
  *  answers `{ waits }` saying so. One review covers them all; the caller decides the transition. */
 export async function openReviewPullRequests(board, id) {
   const own = await repositoryWorkspace(board, id);
-  if (!own) return null;
+  const registered = registeredBranches(board, id);
+  if (!own && !registered.length) return null;
   const task = board.db.prepare('SELECT branch_name FROM tasks WHERE id=?').get(id);
-  const ownRepository = own.repository ?? (own.here ? await originOf(own.path) : null);
-  if (!ownRepository) return null;
-  const current = task?.branch_name ? null : own.branch ?? (own.here ? await run('git', ['branch', '--show-current'], own.path) : null);
+  const ownRepository = own?.repository ?? (own?.here ? await originOf(own.path) : null);
+  if (!ownRepository && !registered.length) return null;
+  const current = task?.branch_name ? null : own?.branch ?? (own?.here ? await run('git', ['branch', '--show-current'], own.path) : null);
   let branch = task?.branch_name ?? (current || null);
-  const registered = registeredBranches(board, id);
   const mine = (repository, head) => (repository === ownRepository && head === branch) || namedWorkBranch(id, head)
     || registered.some((r) => r.repository === repository && r.branch === head);
   const prs = [];
-  for (const repository of new Set([ownRepository, ...registered.map((r) => r.repository), ...(await knownRepositories())])) {
+  for (const repository of new Set([ownRepository, ...registered.map((r) => r.repository), ...(await knownRepositories())].filter(Boolean))) {
     // Discovery is shared per repository for one minute; each selected PR/head is re-read before it authorizes a move.
     let list = pullRequestLists.get(repository);
     if (!list || Date.now() - list.at >= 60_000) {
@@ -263,7 +263,19 @@ export async function openReviewPullRequests(board, id) {
       }
     }
   }
-  if (!prs.length) return branch ? null : { waits: `the card has no work branch (${task?.branch_name ? `it declares ${task.branch_name}, its repository's default` : current ? `its checkout ${own.path} is on ${current}, its repository's default` : `its checkout ${own.path} is on no branch`}): give it one with --branch, or open its PR from a wt/${id} branch` };
+  // A source declaration (an implementer's or manager's card comment, engine.comment) adds merged or moved PRs that
+  // discovery cannot see; it never hides what discovery found. Only repositories the card's workspace or registered
+  // branches name count, and each declared PR is followed at its current head (GitHub's), never pinned to the
+  // declared one, so a push after the declaration is reviewed instead of failing every tick.
+  const declaration = board.db.prepare("SELECT payload FROM task_events WHERE task_id=? AND kind='commented' AND json_type(payload,'$.sources')='array' ORDER BY id DESC LIMIT 1").get(id);
+  const repositories = new Set([ownRepository, ...registered.map((r) => r.repository)].filter(Boolean).map((r) => r.toLowerCase()));
+  for (const source of declaration ? JSON.parse(declaration.payload).sources : []) {
+    if (!repositories.has(repositoryOf(source.url).toLowerCase()) || prs.some((known) => known.url === source.url)) continue;
+    const pr = await readPullRequest(source.url);
+    if (pr.isCrossRepository || !['OPEN', 'MERGED'].includes(pr.state) || (pr.state === 'OPEN' && pr.isDraft)) continue;
+    if (!prs.some((known) => known.url === pr.url)) prs.push({ url: pr.url, head: pr.headRefOid });
+  }
+  if (!prs.length) return branch || !ownRepository ? null : { waits: `the card has no work branch (${task?.branch_name ? `it declares ${task.branch_name}, its repository's default` : current ? `its checkout ${own.path} is on ${current}, its repository's default` : `its checkout ${own.path} is on no branch`}): give it one with --branch, or open its PR from a wt/${id} branch` };
   return { pr: prs.map((p) => p.url), pr_head: prs.map((p) => p.head), branch };
 }
 
@@ -271,6 +283,14 @@ export async function openReviewPullRequests(board, id) {
  *  beyond its repository's default branch, locally or on origin, its checkout holds no uncommitted work, no PR was
  *  ever opened from it, and it registered no other branch. Answers what its review reads instead of a diff, or null when the arc carries (or may carry) code. */
 export async function noCodeChange(board, id) {
+  const taskRow = board.db.prepare('SELECT workspace_kind FROM tasks WHERE id=?').get(id);
+  if (taskRow?.workspace_kind === 'scratch') {
+    if (board.db.prepare("SELECT 1 FROM tasks t JOIN supercode_cards c ON c.task_id=t.id WHERE c.subtask_of=? AND t.workspace_kind!='scratch' AND t.status!='cancelled' LIMIT 1").get(id)) return null;
+    // Scratch declares an operational disposition rather than repository code.
+    // Closed tasks/results and the retained card thread are the review source;
+    // this does not invent a verdict or assert that an external act succeeded.
+    return { pr: [], pr_head: [], branch: null, no_code: { kind: 'disposition' } };
+  }
   const checkout = await repositoryWorkspace(board, id);
   if (!checkout?.here) return null;
   const own = checkout.path;
@@ -357,6 +377,7 @@ export async function inspectCompletionEvidence(board, id, entry, payload = {},
       const candidate = stage === 'acceptance' ? reviewCandidate(board, id) : null;
       if (candidate) {
         const row = board.db.prepare("SELECT id,payload FROM task_events WHERE task_id=? AND kind='review_pass' ORDER BY id DESC LIMIT 1").get(id);
+        if (!row) throw new Error('The current candidate needs its independent verdict before acceptance.');
         const voided = board.db.prepare("SELECT id FROM task_events WHERE task_id=? AND kind='review_voided' ORDER BY id DESC LIMIT 1").get(id);
         if (voided && (!row || voided.id > row.id)) throw new Error('The manager voided this verdict; the board must obtain a new review before acceptance.');
         const passed = candidatePullRequests(row && JSON.parse(row.payload)?.ci);
@@ -370,13 +391,19 @@ export async function inspectCompletionEvidence(board, id, entry, payload = {},
       }
       return state;
     }
-    const own = await repositoryWorkspace(board, id);
     const asked = stage === 'review_verdict' ? reviewCandidate(board, id) : null;
     const urls = [].concat(payload.pr ?? payload.metadata?.pr ?? candidatePullRequests(asked).map((c) => c.pr.url)).filter(Boolean);
-    if (!own) {
-      if (urls.length) throw new Error('A PR candidate needs a resolved repository workspace.');
+    if (!urls.length && asked?.no_code) return { ...state, no_code: asked.no_code };
+    if (urls.some(url => typeof url !== 'string' || !/^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/[1-9][0-9]*\/?$/.test(url))) throw new Error('Name each GitHub PR URL with --pr.');
+    // Merged source is immutable and needs no surviving workspace. Resolve an
+    // unmerged candidate's checkout as before; a broken legacy path never
+    // prevents a verdict on already merged commits.
+    const mergedOnly = urls.length && (await Promise.all(urls.map(readPullRequest))).every(pr => pr.state === 'MERGED');
+    const own = mergedOnly ? null : await repositoryWorkspace(board, id);
+    if (!own && !urls.length) {
       return state;
     }
+    if (!own && !mergedOnly) throw new Error('An unmerged PR candidate needs a resolved repository workspace.');
     // A verdict with no requested PR (a scratch arc) keeps its own contract. An arc's review
     // always names every opened PR it changed, independent of completion_ci.
     if (stage === 'review_verdict' && !asked && !urls.length) return state;
@@ -412,7 +439,7 @@ async function verifyPullRequest(board, id, entry, own, url, supplied, stage) {
   // card's own checkout, and this machine's checkout of the PR's branch when it keeps one, must also hold that head
   // with nothing uncommitted. A card on another machine is reviewed at its pushed head: its checkout is not read from here.
   const observed = await readPullRequest(url);
-  const path = !own.here ? null : await originOf(own.path) === repository && await run('git', ['branch', '--show-current'], own.path) === observed.headRefName ? own.path : await branchCheckout(board, id, repository, observed.headRefName);
+  const path = !own?.here || observed.state === 'MERGED' ? null : await originOf(own.path) === repository && await run('git', ['branch', '--show-current'], own.path) === observed.headRefName ? own.path : await branchCheckout(board, id, repository, observed.headRefName);
   // A PR merged before its review (an outage fix landed first) is still reviewed: its head is fixed for good, so the
   // verdict is recorded on that head, and nothing about a worktree or its base can move under it any more.
   const merged = observed.state === 'MERGED';

package/board/cli.mjs

@@ -11,6 +11,7 @@ import { homeOf, parse } from './args.mjs';
 import { BOARD_OPERATION_VERBS, boardHome, boardOwnerSocket, CALLER_FACTS } from '@volter/teams/board-owner';
 import { current, isCallersCall, ownCall, within } from './call.mjs';
 import { taskStatusOf } from './published.mjs';
+import { executionOf } from './session-work.mjs';
 import { createServer } from 'node:net';
 import { chmodSync, existsSync, mkdirSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, copyFileSync, readFileSync, appendFileSync, writeFileSync } from 'node:fs';
 import { notRuntime, ownHome } from './owner-files.mjs';
@@ -93,7 +94,7 @@ The board's verbs, with their flags:
   set <id> <assignee|machine|model|every> <value|none> [--provider] [--ids ...]   assign <id> <profile|none>   set-model <id> [model] [--provider]   set-goal <id>... [--goal-max-turns N] [--off]
   reassign <id> --agent AGENT [--role implementer]   (moves a card role's assignment to another agent; sessions keep their identity)
   claim <id> [--ttl]   reclaim <id> [--reason]   heartbeat <id> [--note] [--until <time|30m>]   link|unlink <parent> <child>
-  comment <id> (<text> | --file PATH|-) [--author] [--max-len]   attach <id> <path> [--name] [--content-type]   attachments <id>   attach-rm <n>
+  comment <id> (<text> | --file PATH|-) [--author] [--max-len] [(--pr URL --pr-head SHA)...]   attach <id> <path> [--name] [--content-type]   attachments <id>   attach-rm <n>
   complete <id>... [--result] [--summary] [--metadata JSON]   edit <id> --result [--summary] [--metadata]
   block <id> [reason] (--on <card> | --waiting-on <message id>) [--ids ...]   schedule <id> [reason] [--ids ...]
   pause <id> --reason <why>   resume <id>   cancel <id> --reason <why>
@@ -135,6 +136,7 @@ And:
 
   specify <id> --workspace dir:<repository> --branch NAME: the manager retargets a stopped card without replacing its history.
   specify <id> --workspace … --machine M: declares the workspace on M and moves the card there, never asking the machine it leaves.
+  comment <id> TEXT (--pr URL --pr-head SHA)...: the card's implementer or the manager adds PRs (including merged ones) to the arc's discovered source set, in the card's own repositories, each followed at its current head; the latest declaration replaces the previous one. This records evidence; only the board starts its review.
   request-review <id> (--pr URL --pr-head SHA)...: hand over every open PR the arc changed, each at its pushed head; one review covers them all.
   request-state <id> --state done (--reviewed-sha SHA)...: record the verdict on every requested PR head.
   request-state <id>... --state STATE --reason REASON: request several decisions in one retained manager mail.
@@ -289,14 +291,14 @@ const ts = (t) => {
   return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
 };
 // a card's status is the workflow's (triaging, reviewing, …); kanban.db stores the Hermes status it maps to
-const line = (t) => `${ICONS[t.status] ?? '?'} ${t.id}  ${(t.stage ?? t.status).padEnd(8)}  ${(t.assignee || '(unassigned)').padEnd(20)}${t.tenant ? ` [${t.tenant}]` : ''}  ${t.title}${t.machine ? `  @${t.machine}` : ''}`;
+const line = (t) => `${ICONS[t.status] ?? '?'} ${t.id}  ${(t.stage ?? t.status).padEnd(8)}${['running','review'].includes(t.status) ? ` [session ${t.execution?.state ?? 'unknown'}]` : ''}  ${(t.assignee || '(unassigned)').padEnd(20)}${t.tenant ? ` [${t.tenant}]` : ''}  ${t.title}${t.machine ? `  @${t.machine}` : ''}`;
 const cardDict = (t) => ({
   id: t.id, title: t.title, body: t.body, assignee: t.assignee, status: t.status, priority: t.priority, tenant: t.tenant,
   workspace_kind: t.workspace_kind, repository: t.workspace_anchor ?? null, workspace_path: t.workspace_path, branch_name: t.branch_name, project_id: t.project_id,
   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, execution: t.execution ?? null,
 });
 
 /** Hermes's durations: seconds, or 30s / 5m / 2h / 1d. */
@@ -523,7 +525,7 @@ export async function runVerb(argv) {
           return [t.id, {
             workflow_status: t.stage ?? t.status,
             parents: b.db.prepare('SELECT parent_id FROM task_links WHERE child_id = ? ORDER BY parent_id').all(t.id).map((r) => r.parent_id),
-            run: run ? { id: run.id, status: run.status, started_at: run.started_at, session: session.address ?? session.session_id ?? null } : null,
+            run: run ? { id: run.id, status: run.status, started_at: run.started_at, session: session.address ?? session.session_id ?? null, execution: executionOf(run) } : null,
             // the message whose answer its standing block waits for (`block --waiting-on`)
             waiting_on: (() => {
               const last = b.db.prepare("SELECT kind, payload FROM task_events WHERE task_id = ? AND kind IN ('blocked', 'unblocked', 'dependency_wait') ORDER BY id DESC LIMIT 1").get(t.id);
@@ -546,6 +548,8 @@ export async function runVerb(argv) {
       const card = withBoard((b) => {
         const got = engine.showCard(b.db, id);
         got.runs = engine.runs(b.db, id, { stateType: args['state-type'] ?? null, stateName: args['state-name'] ?? null });
+        got.task.execution = executionOf(engine.currentRun(b.db, id));
+        got.runs = got.runs.map(run => ({ ...run, execution: executionOf(run) }));
         got.diagnostics = engine.diagnose(b.db, got.task, { failureLimit: settings.failureLimit, launchWindowSeconds: settings.launchWindow });
         got.stage = statusOf(b.db, got.task);
         got.time = scopeOf(b.db, b, got.task, { params: workflowFor(root).params }).card.time;
@@ -603,7 +607,7 @@ export async function runVerb(argv) {
         for (const r of card.runs) {
           const s = r.metadata?.supercode;
           out.push(`  #${String(r.id).padEnd(3)} ${(r.outcome || r.status || 'active').padEnd(12)} @${r.profile || '-'}  ${r.ended_at ? `${Math.max(0, r.ended_at - r.started_at)}s` : 'active'}  ${ts(r.started_at)}`);
-          if (s) out.push(`        ⇢ ${s.session_id ? `session ${s.session_id}${s.pane ? ` in pane ${s.pane}` : ''}` : `worker pid ${s.pid}`} on ${s.machine} (${s.mode})`);
+          if (s) out.push(`        ⇢ ${s.session_id ? `session ${s.session_id}${s.pane ? ` in pane ${s.pane}` : ''}` : `worker pid ${s.pid}`} on ${s.machine} (${s.mode}); observed ${executionOf(r).state}`);
           if (r.summary) out.push(`        → ${r.summary.split('\n')[0].slice(0, 160)}`);
           if (r.error) out.push(`        ! ${r.error.split('\n')[0].slice(0, 160)}`);
         }
@@ -717,7 +721,7 @@ export async function runVerb(argv) {
       need(args.file !== undefined ? 1 : 2, 'a card id and the text (or --file PATH, - for stdin)');
       let text = textFrom(args.file, 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, isLatestReviewer(b.db, id, actorOf()) ? actorOf() : 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, { pr: args.pr ?? null, pr_head: args['pr-head'] ?? null }));
       say(args, `Comment added to ${id}`, { ok: true, comment: n }); return 0;
     }
     case 'attach': {
@@ -966,9 +970,9 @@ export async function runVerb(argv) {
         // planned through the workflow's own dispatch (its start event, eligible, order and limits), writing nothing
         const reports = await plan({ root, lanes, settings, params, slugs: [slug] });
         const would = reports.flatMap((r) => r.would), reviews = reports.flatMap((r) => r.would_review ?? []);
-        const lines = [...reviews.map((r) => `would request review of ${r.id}: ${r.no_code ? `no code changed (${r.no_code.repository} ${r.no_code.branch} holds no commit beyond ${r.no_code.base}, no PR from it)` : r.prs.map((url, i) => `${url} at ${r.heads[i]}`).join(', ')}`),
+        const lines = [...reviews.map((r) => `would request review of ${r.id}: ${r.no_code ? r.no_code.kind === 'disposition' ? 'scratch operational disposition (card evidence and closed tasks)' : `no code changed (${r.no_code.repository} ${r.no_code.branch} holds no commit beyond ${r.no_code.base}, no PR from it)` : r.prs.map((url, i) => `${url} at ${r.heads[i]}`).join(', ')}`),
           ...would.map((w) => `would start ${w.id} (${w.status}${w.role ? `, its ${w.role}` : ''}) as ${w.surface} for ${w.assignee}${w.machine ? ` on ${w.machine}` : ''}`)];
-        say(args, lines.length ? lines.join('\n') : 'nothing would start', args.json ? { would, would_review: reviews } : would);
+        say(args, lines.length ? lines.join('\n') : 'nothing would start', args.json ? { would, would_review: reviews, queued: reports.flatMap(r => r.queued ?? []) } : would);
         return 0;
       }
       // This process holds the home's lock for the round, so it is the board's owner for it: it registers its pid, which

package/board/dispatch.mjs

@@ -340,6 +340,15 @@ const unavailable = message => Object.assign(new Error(message), { launchDeferre
 
 // ------------------------------------------------------------------ supervise
 
+/** Material card work (workflow.mjs sessionProgress) recorded since the run began. */
+function progressedSince(db, task, runRow) {
+  const started = Number(runRow?.started_at ?? 0);
+  const progress = sessionProgress(db, task);
+  if (progress.commit >= started && progress.commit > 0) return true;
+  const at = progress.event ? db.prepare('SELECT created_at FROM task_events WHERE id=?').get(progress.event)?.created_at : null;
+  return at != null && Number(at) >= started;
+}
+
 async function supervise(board, fleet, settings, report, entry, effects) {
   const rows = board.db.prepare(entry.workflow.run ? "SELECT id FROM tasks WHERE current_run_id IS NOT NULL" : "SELECT id FROM tasks WHERE status = 'running'").all();
   // Published native observations are the only liveness input. Missing data remains unknown. A launch the
@@ -352,7 +361,14 @@ async function supervise(board, fleet, settings, report, entry, effects) {
     if (!session?.launch_key || !fleet.ok || sessionAlive(fleet, session) !== false) continue;
     // how a keyed launch ended, where its machine keeps that record: read when it can be, never waited on
     if (!fleet.capabilities?.get(normalMachine(session.machine))?.launches) continue;
-    try { const receipt = await launchReceipt(board, session); if (receipt?.live === false && receipt.exit) exits.set(id, { ...receipt.exit, launch_key: session.launch_key }); }
+    try {
+      const receipt = await launchReceipt(board, session);
+      if (receipt?.live === false && receipt.exit) {
+        exits.set(id, { ...receipt.exit, launch_key: session.launch_key });
+        // a clean exit is judged against the card's commits, read before the board write
+        if (!receipt.exit.failed && recoversRuns(entry)) await refreshCardInputs(board, id, { commits: true });
+      }
+    }
     catch (error) { report.failed.push([id, `exit receipt unavailable; retaining liveness observation: ${error.message}`]); }
   }
   for (const { id } of rows) {
@@ -371,6 +387,21 @@ async function supervise(board, fleet, settings, report, entry, effects) {
         event(db,id,'session_rebound',{session_id:session.session_id,pane:session.pane},runRow.id);
       }
       const t = now();
+      if (runRow && session) {
+        const alive = session.surface === 'headless' ? pidAlive(session.pid) : sessionAlive(fleet, session);
+        let native = fleet.sessions?.find(item => item.address === addressOf(session));
+        if (!native && session.session_id) try {
+          const row = nativeReading(nativeSessions(session.machine, session.harness ?? 'claude-code', session.session_id), session).row;
+          native = { turn: row?.activity?.turn };
+        } catch { /* an unread turn stays unknown */ }
+        const reading = { alive: alive ?? null, turn: alive === true ? native?.turn ?? null : null, observed_at: t };
+        const prior = session.presence_observation;
+        // Keep state changes immediately and renew unchanged readings once a minute.
+        if (!prior || prior.alive !== reading.alive || prior.turn !== reading.turn || t - prior.observed_at >= 60) {
+          setRunSession(db, runRow.id, { presence_observation: reading });
+          session = { ...session, presence_observation: reading };
+        }
+      }
       // what the dispatcher saw becomes a platform event; the card's workflow says what it does
       const observe = (name, payload, bucket) => {
         try {
@@ -474,12 +505,23 @@ async function supervise(board, fleet, settings, report, entry, effects) {
           const ended = { code: exit.failed ? 1 : 0, error: `native session ${session.session_id} ended: ${exit.how}`, session_id: session.session_id, pane: session.pane };
           if (!exit.failed) {
             if (monitorsRuns(entry)) { observe('session_closed', {...ended,exit},'crashed'); return; }
+            // Under recover a clean exit continues the card. One with no material card progress since its run began
+            // is an unsuccessful continuation: it counts toward the failure limit like any failed run, so a session
+            // that always ends cleanly (fresh or resumed) stops at the limit and the workflow asks the manager.
+            if (recoversRuns(entry) && !progressedSince(db, task, runRow)) {
+              observe('exited', { ...ended, error: `${ended.error} with no card progress since run ${runRow.id} began` }, 'crashed');
+              return;
+            }
             try {
+              if (recoversRuns(entry)) retainRecovery(db, id, 'session_closed', { ...ended, exit });
               const r = fire(db, board, entry, id, 'session_closed', { roles: ['platform'], payload: ended });
               staged.push(...r.effects); (report.closed_by_hand ??= []).push(id);
               return;
             } catch (error) { if (!error.noTransition) { report.failed.push([id, `session_closed: ${String(error.message).slice(-200)}`]); return; } }
           }
+          if (exit.failed && session.mode === 'resume' && !session.seen_at) {
+            setRunSession(db, runRow.id, { resumable: false, resume_failed_before_live: true });
+          }
           observe('exited', ended, 'crashed');
           return;
         }
@@ -1797,7 +1839,8 @@ async function launchPane(board, task, runId, lane, fleet, { input = null, slot
       const launchKey = `board-${task.id}-r${runId}-resume`;
       session = await openOwned(launchKey, prev.session_id, 'resume', ['open', '--new', its.program, ...base.slice(3),
         '--key', launchKey, '--input', told, '--', ...its.resume(prev.session_id), ...tail]);
-    } else replaced = { session_id: prev.session_id, why: 'its resume never came up' };
+    } else replaced = { session_id: prev.session_id, why: 'its resume never came up',
+      letGo: recoversRuns(workflowFor(board.root)) && Boolean(prev.resume_failed_before_live) && Boolean(prev.close_confirmed_at) };
   } else if (prev) replaced = { session_id: prev.session_id, why: `the card moved from ${prev.machine} to ${machine}` };
   // a card keeps its context: a slot's session that cannot be kept or resumed stops the launch, and only a session the
   // workflow let go (`forget_session`) or its manager did (a reassignment to another harness's lane) is replaced
@@ -2631,17 +2674,30 @@ export async function plan({ root, lanes, settings, slugs = null, params = {} })
   return out;
 }
 
-/** Whether an arc with no open PR may be one that changed no code and is due its review: it filed and closed tasks
- *  (a fresh arc with none has not started), and no review of it is pending or passed (after changes are requested,
- *  closing the tasks that own the findings makes it due again). */
+/** Whether an arc with no open PR may be one that changed no code and is due its review: it has done work, by filing
+ *  tasks or by a run that ended with an Acceptance outcome ticked (a fresh arc with neither has not started), and no
+ *  review of it is pending or passed (after changes are requested, closing the tasks that own the findings makes it
+ *  due again). */
 function noCodeReviewDue(board, id) {
   return view(board, (db) => {
-    if (!db.prepare('SELECT 1 FROM supercode_cards WHERE subtask_of = ? LIMIT 1').get(id)) return false;
+    const filed = db.prepare('SELECT 1 FROM supercode_cards WHERE subtask_of = ? LIMIT 1').get(id);
+    if (!filed && !(db.prepare('SELECT 1 FROM task_runs WHERE task_id = ? AND ended_at IS NOT NULL LIMIT 1').get(id) &&
+      outcomeTicked(db.prepare('SELECT body FROM tasks WHERE id = ?').get(id)?.body))) return false;
     const last = db.prepare("SELECT kind FROM task_events WHERE task_id = ? AND kind IN ('review_requested', 'changes_requested', 'review_pass','review_voided') ORDER BY id DESC LIMIT 1").get(id);
     return !last || ['changes_requested','review_voided'].includes(last.kind);
   });
 }
 
+/** Whether a card body ticks some outcome under its Acceptance heading. */
+function outcomeTicked(body) {
+  let acceptance = false;
+  return String(body ?? '').split('\n').some((line) => {
+    const heading = /^#{1,6}\s+(.+?)\s*$/.exec(line);
+    if (heading) acceptance = heading[1].toLowerCase() === 'acceptance';
+    return acceptance && /^\s*[-*] \[[xX]\] \S/.test(line);
+  });
+}
+
 /** An opened PR asks for the declared review transition once the arc's tasks are closed. */
 // A task written in the card's own Tasks section that did not become a subtask holds its review too.
 /** The arc's session still in a turn: its review, and the close of that session the request brings (end_run), wait for
@@ -2660,7 +2716,7 @@ async function turnInFlight(board, id, fleet) {
 async function activatePullRequestReviews(board, entry, report, effects, { only = null, dry = false, fleet = null } = {}) {
   const candidates = view(board, db => db.prepare(`SELECT t.id FROM tasks t JOIN supercode_cards c ON c.task_id=t.id
     WHERE c.subtask_of IS NULL AND c.every IS NULL
-    AND t.workspace_kind!='scratch' ${only ? 'AND t.id=?' : ''}`).all(...(only ? [only] : [])));
+    ${only ? 'AND t.id=?' : ''}`).all(...(only ? [only] : [])));
   for (const { id } of candidates) {
     const eligible = db => {
       const task = getTask(db, id);
@@ -2684,7 +2740,7 @@ async function activatePullRequestReviews(board, entry, report, effects, { only
       // requested the next run is the implementer's, until a new head is pushed.
       // An arc that closed its tasks having changed no code gets its one review of the act itself (ADR 0003).
       if (!payload && noCodeReviewDue(board, id)) payload = await noCodeChange(board, id);
-      if (!payload) { report.queued.push([id, 'review waits: no open PR on its branch, a wt/<card> branch or a registered checkout']); continue; }
+      if (!payload) { report.queued.push([id, 'review waits: no open or unjudged merged PR on its declared branches, and no completed disposition']); continue; }
       if (payload.waits) { report.queued.push([id, `review waits: ${payload.waits}`]); payload = null; continue; }
       if (!payload.no_code && !await reviewDue(board, id, payload.pr.map((url, index) => ({ url, head: payload.pr_head[index] })))) {
         report.queued.push([id, `review waits: every open PR head (${payload.pr.join(', ')}) has a verdict or predates the last one; push a commit that answers it`]);
@@ -2700,8 +2756,8 @@ async function activatePullRequestReviews(board, entry, report, effects, { only
         if (eligible(db) !== true) return null;
         return withCompletionEvidence(board, id, evidence, () => fire(db, board, entry, id, 'request_review', {
           roles: ['platform'], payload: { ...payload, run_id: task.current_run_id, ci: evidence, summary: payload.no_code
-            ? `No code changed: ${payload.no_code.repository} ${payload.branch} holds no commit beyond ${payload.no_code.base} and no PR was opened from it. Review the arc's act from the card: its comments, its tasks' results and what they point at.`
-            : `Opened ${payload.pr.map((url, index) => `${url} at ${payload.pr_head[index]}`).join(', ')}` }
+            ? `${payload.no_code.kind === 'disposition' ? 'Scratch operational disposition.' : `No code changed: ${payload.no_code.repository} ${payload.branch} holds no commit beyond ${payload.no_code.base} and no PR was opened from it.`} Review the arc's act from the card: its comments, its tasks' results and what they point at.`
+            : `Source ${payload.pr.map((url, index) => `${url} at ${payload.pr_head[index]}`).join(', ')}` }
         }));
       });
       if (moved) {

package/board/engine.mjs

@@ -8,6 +8,7 @@
 // Each function takes an open board (`store.mjs`) and runs in one write transaction. Nothing here launches,
 // observes or sends: the dispatcher (`dispatch.mjs`) does, and records what it did through these.
 import { current } from './call.mjs';
+import { executionOf } from './session-work.mjs';
 import { spawn, execFile } from 'node:child_process';
 import { existsSync, rmSync } from 'node:fs';
 import { join, resolve } from 'node:path';
@@ -721,10 +722,22 @@ export async function unlink(board, parent, child, { roles } = {}) {
 }
 
 /** A comment on the card's thread; answers its id. */
-export async function comment(board, id, author, body, { roles } = {}) {
+export async function comment(board, id, author, body, { roles, pr = null, pr_head = null } = {}) {
   if (!String(body ?? '').trim()) throw new Error('a comment has a body');
   if (!String(author ?? '').trim()) throw new Error('a comment has an author');
-  const result = await act(board, id, 'comment', { roles, payload: { author: author.trim(), body } });
+  let sources;
+  if (pr != null || pr_head != null) {
+    const urls = [].concat(pr ?? []), heads = [].concat(pr_head ?? []);
+    if (!urls.length || urls.length !== heads.length) throw new Error('Record every PR with --pr URL --pr-head SHA, one full head per URL.');
+    if (new Set(urls).size !== urls.length) throw new Error('Record each PR once.');
+    sources = urls.map((url, i) => {
+      if (!/^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/[1-9][0-9]*\/?$/.test(url) || !/^[a-f0-9]{40}$/.test(heads[i])) throw new Error('A source declaration needs a GitHub PR URL and its full head SHA.');
+      return { url: url.replace(/\/$/, ''), head: heads[i] };
+    });
+    // Only the card's own implementer or the board's manager declares its sources; the author text is not identity.
+    if (!(roles ?? callerRoles(board.db, id)).some((role) => role === 'implementer' || role === 'manager')) throw new Error(`Only ${id}'s implementer or the manager records its PR sources.`);
+  }
+  const result = await act(board, id, 'comment', { roles, payload: { author: author.trim(), body, ...(sources ? { sources } : {}) } });
   return result.commentId;
 }
 
@@ -812,7 +825,7 @@ export function listCards(db, { status = null, assignee = null, machine = null,
   const rows = all(db, `SELECT t.*, c.machine, c.subtask_of, c.stage, c.tags, c.sponsor FROM tasks t LEFT JOIN supercode_cards c ON c.task_id = t.id
     WHERE (? IS NULL OR t.status = ? OR c.stage = ?) AND (? IS NULL OR t.assignee = ?) AND (? IS NULL OR c.machine = ?) AND (? OR t.status != 'archived')
     ORDER BY t.priority DESC, t.created_at ASC`, status, status, status, assignee, assignee, machine, machine, includeArchived ? 1 : 0);
-  return rows.map((r) => ({ ...r, skills: json(r.skills, []) ?? [] }));
+  return rows.map((r) => ({ ...r, skills: json(r.skills, []) ?? [], execution: executionOf(r.current_run_id ? one(db, 'SELECT metadata,ended_at FROM task_runs WHERE id=?', r.current_run_id) : null) }));
 }
 
 export function showCard(db, id) {

package/board/incidents.mjs

@@ -62,6 +62,33 @@ export function surfaceIncident(db, board, entry, id, name, evidence = {}, runId
 /** Older ended runs are audited before eligibility: a completed run is not permission to repeat. */
 export function auditEndedRuns(db, board, entry) {
   if (recoversRuns(entry)) {
+    // Retained positive exit receipts from an earlier version qualify the same
+    // failed-before-live fallback as a newly supervised resume. An unknown
+    // reading, a mere ended row or a once-live resume does not qualify.
+    for (const row of db.prepare(`SELECT r.id,r.metadata FROM task_runs r JOIN tasks t ON t.id=r.task_id
+      WHERE r.id=(SELECT MAX(id) FROM task_runs WHERE task_id=t.id) AND r.ended_at IS NOT NULL
+      AND t.current_run_id IS NULL AND t.status NOT IN ('done','cancelled','archived')`).all()) {
+      const metadata = json(row.metadata, {}), session = metadata.supercode;
+      if (session?.mode !== 'resume' || session.seen_at || session.resume_failed_before_live) continue;
+      const exit = db.prepare("SELECT 1 FROM task_events WHERE run_id=? AND kind='run_incident' AND json_extract(payload,'$.observation')='exited' AND json_extract(payload,'$.evidence.code')=1").get(row.id);
+      if (!exit) continue;
+      metadata.supercode = { ...session, resumable: false, resume_failed_before_live: true };
+      db.prepare('UPDATE task_runs SET metadata=? WHERE id=?').run(JSON.stringify(metadata), row.id);
+    }
+    // The older organization workflow automatically paused a clean native exit.
+    // Release only that exact platform outcome, never a person's later pause.
+    for (const task of db.prepare(`SELECT t.id,c.paused FROM tasks t JOIN supercode_cards c ON c.task_id=t.id
+      WHERE t.current_run_id IS NULL AND t.status NOT IN ('done','cancelled','archived') AND c.paused IS NOT NULL AND NOT COALESCE(c.archived,0)`).all()) {
+      const pause = json(task.paused, null);
+      const last = db.prepare("SELECT kind,payload FROM task_events WHERE task_id=? AND kind IN ('closed_by_hand','paused','resumed') ORDER BY id DESC LIMIT 1").get(task.id);
+      const ended = json(last?.payload, {});
+      // The machine may have moved since this run. Match the retained board
+      // actor's exact label, never a user's actor or just the reason text.
+      if (last?.kind !== 'closed_by_hand' || !pause?.by?.endsWith(`:board:${board.label}`) || !pause.by.startsWith('sc:')) continue;
+      if (pause.reason !== `its session ended cleanly (${ended.error}); resume the card to start it again`) continue;
+      db.prepare('UPDATE supercode_cards SET paused=NULL WHERE task_id=? AND paused=?').run(task.id, task.paused);
+      event(db, task.id, 'automatic_close_pause_released', { reason: 'workflow selected native continuation after clean exit', prior_pause: pause });
+    }
     // Changing the explicit policy releases only incident holds. A person's
     // pause, dependency, dispatch switch or unrelated hold remains their act.
     for (const task of db.prepare(`SELECT t.*,r.id run_id,r.metadata run_metadata FROM tasks t JOIN task_runs r

package/board/published.mjs

@@ -5,6 +5,7 @@
 // supercode_publication_dirty, whoever writes (this process, Hermes's native writer, a document import). A transaction
 // publishes the marked cards and clears their marks; one that marked nothing reads one row and publishes nothing.
 import { createHash, randomUUID } from 'node:crypto';
+import { executionOf } from './session-work.mjs';
 export const PUBLICATION_SCHEMA = `
 CREATE TABLE IF NOT EXISTS supercode_publications (
   sequence INTEGER PRIMARY KEY AUTOINCREMENT, id TEXT NOT NULL UNIQUE, resource_id TEXT NOT NULL,
@@ -95,14 +96,16 @@ export function cardSnapshot(db,row,rows=perCard(db)) {
   const comments=rows.comments(row.id).map(comment=>({...comment,created_at:at(comment.created_at)}));
   const verdicts={review_requested:'requested',approved:'approved',review_approved:'approved',changes_requested:'changes_requested',escalated:'escalated'};
   const reviews=rows.reviews(row.id).map(event=>{const payload=parse(event.payload,{});return {id:event.id,verdict:verdicts[event.kind],by:payload.reviewer??payload.by??payload.profile,reason:payload.reason,at:at(event.created_at)};});
-  const attempts=rows.attempts(row.id).map(run=>{
+  const runs=rows.attempts(row.id);
+  const attempts=runs.map(run=>{
     const native=parse(run.metadata,{})?.supercode??null;
     const session=native?{machine:native.machine,harness:native.harness,session_id:native.session_id,address:native.address,pane:native.pane,surface:native.surface,state:native.state,closed_at:native.closed_at,agent:native.agent_id??null,counted:native.counted??null,profile_differences:native.agent_profile_mismatch?.differences??null}:null;
     const metadata=parse(run.metadata,{});delete metadata.supercode;
-    return {id:String(run.id),profile:run.profile,step:run.step_key,status:run.status,started_at:at(run.started_at),ended_at:at(run.ended_at),outcome:run.outcome,error:run.error,session,handoff:run.summary||Object.keys(metadata).length?{summary:run.summary,metadata}:null};
+    return {id:String(run.id),profile:run.profile,step:run.step_key,status:run.status,started_at:at(run.started_at),ended_at:at(run.ended_at),outcome:run.outcome,error:run.error,execution:executionOf(run),session,handoff:run.summary||Object.keys(metadata).length?{summary:run.summary,metadata}:null};
   });
   const lane=own.stage??row.status;
   return {id:row.id,title:row.title,body:row.body??'',assignee:row.assignee,status:taskStatusOf(lane,row.completed_at),lane,
+    execution:executionOf(runs.find(run=>run.id===row.current_run_id)),
     priority:row.priority,created_by:row.created_by,created_at:at(row.created_at),started_at:at(row.started_at),completed_at:at(row.completed_at),result:row.result,skills:parse(row.skills,[]),model:row.model_override,provider:row.provider_override,
     tags:parse(own.tags,null)??(row.tenant?[row.tenant]:[]),sponsor:own.sponsor??null,sponsor_evidence:parse(own.sponsor_evidence),requested_by_unverified:parse(own.requested_by_unverified),machine:own.machine??null,subtask_of:own.subtask_of??null,archived:!!own.archived,
     blocked_by:parse(own.blocked_by,[]),paused:parse(own.paused),every:own.every??null,

package/board/session-work.mjs

@@ -1,6 +1,25 @@
 // The dispatcher observes native turns and explicit session delegation. A
 // transcript write, a reminder reply, or sharing a profile proves no progress.
 
+/** A retained reading, separate from the card's workflow lane and launch receipt.
+ * An ended attempt is never a live session; an unread live attempt is unknown. */
+export function executionOf(run) {
+  if (!run) return { state: 'awaiting_session', alive: false, observed_at: null };
+  let metadata = run.metadata;
+  if (typeof metadata === 'string') { try { metadata = JSON.parse(metadata); } catch { metadata = null; } }
+  const session = metadata?.supercode;
+  if (run.ended_at != null || session?.close_confirmed_at || session?.released) return { state: 'ended', alive: false, observed_at: session?.presence_observation?.observed_at ?? null };
+  const reading = session?.presence_observation;
+  if (!reading) return { state: 'unknown', alive: null, observed_at: null };
+  const freshUntil = Number(reading.observed_at) + 90;
+  // A stopped dispatcher cannot keep advertising its last positive reading.
+  // Cached snapshot consumers use the same expiry without another publication.
+  if (Date.now() / 1000 > freshUntil) return { state: 'unknown', alive: null, observed_at: reading.observed_at, fresh_until: freshUntil };
+  const delegated = session?.idle_observation?.decision === 'delegated_work' && session.idle_observation.turn === reading.turn;
+  return { ...reading, fresh_until: freshUntil, state: reading.alive === false ? 'ended' : reading.alive == null ? 'unknown'
+    : delegated ? 'delegating' : reading.turn ?? 'live' };
+}
+
 /** Sessions this session started, transitively. Cycles never imply work. */
 export function delegatedWork(address, edges, sessions) {
   const reached = new Set([address]), pending = [address], working = [];

package/board/workflow.mjs

@@ -760,7 +760,7 @@ const FORMAT = {
   model_override_set: ({ e }) => ({ model: (e.field === 'model' ? e.value : e.model) || null, provider: e.provider || null }),
   goal_set: ({ after }) => ({ goal_mode: Boolean(after.goal_mode), goal_max_turns: after.goal_mode ? after.goal_max_turns ?? null : null }),
   heartbeat: ({ e }) => (e.note || e.until ? { ...(e.note ? { note: e.note } : {}), ...(e.until ? { until: Number(e.until) } : {}) } : null),
-  commented: ({ e }) => ({ author: String(e.author ?? 'user').trim(), len: String(e.body ?? '').length }),
+  commented: ({ e }) => ({ author: String(e.author ?? 'user').trim(), len: String(e.body ?? '').length, ...(e.sources ? { sources: e.sources } : {}) }),
   archived: () => null,
   status: ({ e, before, to }) => ({ status: to, reason: e.reason ?? 'reopened', previous_status: before.stored_as }),
   machine_set: ({ e, before }) => ({ machine: e.field === 'machine' ? e.value ?? null : e.machine ?? null, was: before.machine }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.112",
+  "version": "0.5.114",
   "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": {