@volter/supercode-orchestrator 0.4.147 → 0.4.149

package/board/dispatch.mjs

@@ -15,7 +15,7 @@
 // Every side effect follows a committed transition: a card is claimed before its session is launched, and a
 // subscriber's cursor moves only after its notice was delivered, so two dispatchers over one board never both
 // launch and a crash between the two steps is answered by the next tick.
-import { workflowRevision, retainWorkflowTick } from './ci.mjs';
+import { inspectCompletionEvidence, openReviewPullRequests, reviewDue, withCompletionEvidence, reviewCandidate, workflowRevision, retainWorkflowTick } from './ci.mjs';
 import { createRequire } from 'node:module';
 import { spawn as spawnChild, spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
@@ -24,12 +24,14 @@ import { basename, dirname, join } from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { view, boardPath, claimer, event, json, listBoards, logsDir, now, openBoard, setActor, tx } from './store.mjs';
-import { doors, fire, loadWorkflow, resumeOf, runSpec, runWorkingSeconds, requestSessionClose, retireSupersededRuns, refreshRelationAnswers, transitionsFor, scopeOf, statusOf, templateValue, workflowFor } from './workflow.mjs';
+import { doors, fire, loadWorkflow, resumeOf, runSpec, runWorkingSeconds, requestSessionClose, retireSupersededRuns, refreshCardInputs, refreshRelationAnswers, transitionsFor, scopeOf, statusOf, templateValue, workflowFor } from './workflow.mjs';
 import { checkWorkspace, assertWorkspaceOwner, resolveWorkspace } from './workspace.mjs';
 import { evaluate, holds, render } from './expr.mjs';
+import { identifyNotice } from './notices.mjs';
+import { pendingRequestMail } from './request-mail.mjs';
 import {
   cardContext, claimTtl, currentRun, DEFAULT_FAILURE_LIMIT, extendClaim, getTask, lastSession,
-  recomputeReady, runEffects, setRunSession, subscribeIn, subscriptions,
+  recomputeReady, runEffects, setRunSession, subscribeIn, subscriptions, reconcileDependencySubscriptions,
 } from './engine.mjs';
 
 const WORKER = fileURLToPath(new URL('../bin/hermes-worker.mjs', import.meta.url));
@@ -331,13 +333,13 @@ function supervise(board, fleet, settings, report, entry, effects) {
         return;
       }
       // a run past its runtime limit (the status's `run.limits.runtime`), as Hermes times its workers out
-      if (limits.runtime && runRow && session?.wait_started_at == null && runWorkingSeconds(runRow, t) > Number(limits.runtime)) {
+      if (limits.runtime && runRow && runWorkingSeconds(runRow, t) > Number(limits.runtime)) {
         observe('timed_out', { limit_seconds: limits.runtime, error: `ran past max_runtime ${limits.runtime}s` }, 'timed_out');
         return;
       }
       if (session?.surface === 'headless') {
         // Hermes's stale check: a worker running past the limit with no heartbeat in the last hour is stopped
-        if (limits.stale && runRow && session?.wait_started_at == null && runWorkingSeconds(runRow, t) >= Number(limits.stale) && !(task.last_heartbeat_at && t - Number(task.last_heartbeat_at) < 3600)) {
+        if (limits.stale && runRow && runWorkingSeconds(runRow, t) >= Number(limits.stale) && !(task.last_heartbeat_at && t - Number(task.last_heartbeat_at) < 3600)) {
           observe('stale', { timeout_seconds: limits.stale, pid: session.pid, error: `no heartbeat after ${t - Number(runRow.started_at)}s running` }, 'reclaimed');
           return;
         }
@@ -589,7 +591,7 @@ export function launchRun(board, entry, id, lane, fleet, settings) {
     const reviewer = view(board, (db) => lastSession(db, id, slot));
     if (slot === 'worker' || (worker?.session_id && worker.session_id === reviewer?.session_id)) throw new Error('a reviewer must have a different session from the implementer');
   }
-  const meta = { status, role: spec.role, slot };
+  const meta = { status, role: spec.role, slot, ...(spec.role === 'reviewer' ? { review_candidate: reviewCandidate(board, id) } : {}) };
   try {
     const result = surface === 'pane'
       ? launchPane(board, task, runId, lane, fleet, { input: prompt, slot, meta })
@@ -652,17 +654,26 @@ export function closeRequested(board, report, { taskId = null, caller = null } =
   const panes = new Map();
   for (const row of rows) {
     let session = json(board.db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(row.id)?.metadata, {})?.supercode;
-    if (session?.launch_key && !session.pane && (row.ended_at || session.close_requested)) {
+    if (!session || session.close_transferred_to || session.close_confirmed_at) continue;
+    if (session.launch_key && (session.launch_pending || !session.pane) && (row.ended_at || session.close_requested)) {
       let receipt = null, receiptError = null;
-      try { receipt = launchReceipt(board, session); } catch (error) { receiptError = error.message; }
-      if (receipt?.pane) { bindLaunch(board, row, session, receipt.pane, session.session_id); session = { ...session, pane: receipt.pane }; }
+      try {
+        receipt = launchReceipt(board, session);
+        if (!receipt) receipt = cancelUnissuedLaunch(board, session);
+      } catch (error) { receiptError = error.message; }
+      if (unissuedLaunch(receipt, session) && retireUnissuedLaunch(board, row, session, receipt)) {
+        (report.closed ??= []).push({ task_id: row.task_id, ...session, receipt });
+        continue;
+      }
+      if (receipt?.pane && receipt.status !== 'issued' && (receipt.status || receipt.live || receipt.exit)) { bindLaunch(board, row, session, receipt.pane, session.session_id); session = { ...session, pane: receipt.pane }; }
       else {
-        const error = `close deferred: ${receiptError ?? `awaiting launch receipt ${session.launch_key}`}`;
+        const error = `close deferred: ${receiptError ?? `awaiting terminal launch receipt ${session.launch_key} (${receipt?.status ?? 'unknown'})`}`;
         tx(board, (db) => {
           setRunSession(db, row.id, { close_error: error, close_requested: session.close_requested ?? now() });
           if (session.close_error !== error) event(db, row.task_id, 'session_close_failed', { error, retry: true }, row.id);
         });
         report.undelivered.push([row.task_id, addressOf(session), error]);
+        continue;
       }
     }
     if ((!session?.pane && session?.surface !== 'native') || session.close_transferred_to || session.close_confirmed_at || (!row.ended_at && !session.close_requested)) continue;
@@ -679,7 +690,7 @@ export function closeRequested(board, report, { taskId = null, caller = null } =
         if (reading.alive) {
           const protectedNow = active.some(r => addressOf(json(r.metadata, {})?.supercode) === addressOf(session));
           if (protectedNow) throw new Error('close deferred: native session is owned by an unended run');
-          if (session.lifecycle_notice_pending) throw new Error(`close deferred: lifecycle notice ${session.lifecycle_notice_pending} has not been delivered`);
+          if (noticeHoldsClose(session, null)) throw new Error(`close deferred: lifecycle notice ${session.lifecycle_notice_pending} has not been filed`);
           stopSession(board, session);
         }
       } else {
@@ -692,7 +703,7 @@ export function closeRequested(board, report, { taskId = null, caller = null } =
       if (observed.error) throw new Error(observed.error);
       if (observed.live.has(session.pane)) {
         const pendingNotice = view(board, (db) => db.prepare("SELECT id FROM supercode_effects WHERE json_extract(effect, '$.kind')='session_notice' AND json_extract(effect, '$.runId')=? LIMIT 1").get(row.id));
-        if (pendingNotice || session.lifecycle_notice_pending) throw new Error(`close deferred: lifecycle notice ${pendingNotice?.id ?? session.lifecycle_notice_pending} has not been delivered: ${session.lifecycle_notice_error ?? 'pending'}`);
+        if (noticeHoldsClose(session, pendingNotice)) throw new Error(`close deferred: lifecycle notice ${pendingNotice?.id ?? session.lifecycle_notice_pending} has not been filed: ${session.lifecycle_notice_error ?? 'pending'}`);
         const protectedNow = view(board, (db) => db.prepare(`SELECT metadata FROM task_runs r WHERE r.ended_at IS NULL OR EXISTS (SELECT 1 FROM tasks t WHERE t.current_run_id = r.id)`).all())
           .some((r) => { const s = json(r.metadata, {})?.supercode; return s?.pane === session.pane && normalMachine(s.machine) === normalMachine(session.machine); });
         if (protectedNow) throw new Error(`close deferred: pane ${session.pane} is owned by an unended run`);
@@ -733,7 +744,6 @@ function observeIdle(board, fleet, settings, report, entry, effects) {
       if (!(entry.workflow.statuses[status]?.on?.session_idle || entry.workflow.on?.session_idle || entry.workflow.run?.on?.session_idle)) return;
       const runRow = currentRun(db, id);
       const session = runRow?.metadata?.supercode;
-      if (session?.wait_started_at != null) return;
       if (!session?.session_id || !['pane', 'native'].includes(session.surface) || session.offline_since != null) return;
       if (session.surface === 'native' && fleet.native?.get(addressOf(session))?.alive !== true) return;
       const live = fleet.sessions.find((x) => x.address === addressOf(session));
@@ -790,7 +800,10 @@ export async function sessionNotice(board, e) {
   const prior = view(board, (db) => json(db.prepare('SELECT metadata FROM task_runs WHERE id=?').get(e.runId)?.metadata, {})?.supercode);
   if (prior?.close_confirmed_at) {
     tx(board, (db) => {
-      event(db, e.id, 'session_notice_failed', { address: e.address, verb: e.verb, notice: e.durableId, error: 'session closure already confirmed; notice cannot be delivered', retry: false }, e.runId);
+      const unissued = unissuedLaunch(prior.launch_cancellation, prior);
+      event(db, e.id, unissued ? 'session_notice_not_required' : 'session_notice_failed', { address: e.address, verb: e.verb, notice: e.durableId,
+        error: unissued ? 'machine confirmed launch was not issued; no session exists to notify' : 'session closure already confirmed; notice cannot be delivered', retry: false,
+        ...(unissued ? { receipt: prior.launch_cancellation } : {}) }, e.runId);
       if (prior.lifecycle_notice_pending === e.durableId) setRunSession(db, e.runId, { lifecycle_notice_pending: null });
     });
     return true;
@@ -800,26 +813,31 @@ export async function sessionNotice(board, e) {
   try {
     if (!e.address) throw new Error('lifecycle notice awaits the owned launch session identity');
     receipt = await send(boardAddress(board.label), board.label, e.address, e.text, effectMessageKey(e));
-    if (!receipt.delivered) error = receipt.reason ?? 'notice queued; native transcript confirmation pending'; }
+    // A notice filed in the session's mailbox is done: the session reads its mail at its next
+    // turn, and a resumed session first. Only a notice no mailbox took is retried.
+    if (!receipt.delivered && !receipt.queued) error = receipt.reason ?? 'notice was not filed'; }
   catch (failure) { error = String(failure.message).slice(-500); }
   tx(board, (db) => {
     const session = json(db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(e.runId)?.metadata, {})?.supercode;
     if (session) setRunSession(db, e.runId, { ...session,
-      ...(error ? { lifecycle_notice_error: error } : { lifecycle_notice_error: null, ...(session.lifecycle_notice_pending === e.durableId ? { lifecycle_notice_pending: null } : {}) }) });
-    if (!error || session?.lifecycle_notice_error !== error) event(db, e.id, error ? (receipt?.queued ? 'session_notice_queued' : 'session_notice_failed') : 'session_notice_delivered', { address: e.address, verb: e.verb, source_event: e.sourceEvent, notice: e.durableId, receipt, ...(error ? { error, retry: true } : {}) }, e.runId);
+      ...(error ? { lifecycle_notice_error: error, lifecycle_notice_failures: Number(session.lifecycle_notice_failures ?? 0) + 1 }
+        : { lifecycle_notice_error: null, lifecycle_notice_failures: 0, ...(session.lifecycle_notice_pending === e.durableId ? { lifecycle_notice_pending: null } : {}) }) });
+    if (!error || session?.lifecycle_notice_error !== error) event(db, e.id, error ? 'session_notice_failed' : receipt?.delivered ? 'session_notice_delivered' : 'session_notice_queued', { address: e.address, verb: e.verb, source_event: e.sourceEvent, notice: e.durableId, receipt, ...(error ? { error, retry: true } : {}) }, e.runId);
   });
   return !error;
 }
 
+// A close waits for its run's lifecycle notice to be filed, but not past this many failed
+// attempts: an unreachable session must not hold its pane, and its slot's next launch, forever.
+const NOTICE_ATTEMPTS_BEFORE_CLOSE = 3;
+const noticeHoldsClose = (session, pending) => Boolean(pending || session.lifecycle_notice_pending)
+  && Number(session.lifecycle_notice_failures ?? 0) < NOTICE_ATTEMPTS_BEFORE_CLOSE;
+
 /** A session effect a committed move asked for: a message to the card's current actor, or closing a slot's pane. */
 export async function sessionEffect(board, e) {
   if (e.kind === 'send_to_actor') {
     const row = view(board, db => e.runId ? db.prepare('SELECT metadata FROM task_runs WHERE id=?').get(e.runId) : null);
     const session = json(row?.metadata, {})?.supercode;
-    if (session?.wait_started_at != null) {
-      tx(board, db => event(db, e.id, 'actor_notice_suppressed', { notice: e.durableId, reason: 'run is waiting', run_id: e.runId }, e.runId));
-      return true;
-    }
     const address = addressOf(session);
     let receipt;
     try {
@@ -928,6 +946,45 @@ function launchReceipt(board, session) {
   return receipt;
 }
 
+function cancelUnissuedLaunch(board, session) {
+  const result = sc(['teams', 'launches', 'cancel', session.launch_key, ...onMachine(session.machine)],
+    { timeout: 30_000, as: boardAddress(board.label) });
+  if (result.code !== 0) throw unavailable(`launch cancellation unavailable on ${session.machine}; retain ${session.launch_key}: ${(result.stderr || result.stdout).trim().slice(-300)}`);
+  const receipt = lastJson(result.stdout);
+  if (!receipt || receipt.key !== session.launch_key) throw unavailable(`invalid cancellation receipt for ${session.launch_key}`);
+  return receipt;
+}
+
+function unissuedLaunch(receipt, session) {
+  return receipt?.key === session?.launch_key && receipt?.status === 'cancelled' && receipt?.cancelled === true &&
+    receipt?.outcome === 'not_issued' && receipt?.live === false && receipt?.pane === null;
+}
+
+function retireUnissuedLaunch(board, row, session, receipt, { entry = null, effects = [] } = {}) {
+  if (!unissuedLaunch(receipt, session)) return false;
+  const result = tx(board, db => {
+    const current = db.prepare('SELECT ended_at, metadata FROM task_runs WHERE id=?').get(row.id);
+    const saved = json(current?.metadata, {})?.supercode;
+    if (!saved || saved.launch_key !== session.launch_key || saved.pane || saved.address || saved.pid) return { retired: false, effects: [] };
+    if (!current.ended_at && (!entry || getTask(db, row.task_id)?.current_run_id !== row.id)) return { retired: false, effects: [] };
+    if (saved.close_confirmed_at) return { retired: true, effects: [] };
+    const collected = [];
+    const at = now();
+    setRunSession(db, row.id, { launch_pending: false, launch_cancellation: receipt, launch_error: 'machine confirmed launch was not issued',
+      close_requested: saved.close_requested ?? at, closed_at: at, close_confirmed_at: at, close_error: null,
+      forgotten: saved.mode === 'fresh' ? true : Boolean(saved.forgotten) });
+    event(db, row.task_id, 'session_launch_cancelled', { key: session.launch_key, machine: session.machine, receipt }, row.id);
+    if (!current.ended_at) {
+      const moved = fire(db, board, entry, row.task_id, 'spawn_failed', { roles: ['platform'], payload: { error: `launch ${session.launch_key} was not issued; its machine retired the key` } });
+      collected.push(...moved.effects);
+    }
+    event(db, row.task_id, 'session_closed', { key: session.launch_key, machine: session.machine, reason: 'launch not issued', receipt }, row.id);
+    return { retired: true, effects: collected };
+  });
+  effects.push(...result.effects);
+  return result.retired;
+}
+
 function bindLaunch(board, row, session, pane, sid) {
   return tx(board, (db) => {
     const current = db.prepare('SELECT ended_at, metadata FROM task_runs WHERE id=?').get(row.id);
@@ -989,13 +1046,22 @@ function reconcileLaunches(board, fleet, report, entry, effects, settings, lanes
       report.failed.push([id,error.message]);
     }
   }
-  const rows = view(board, (db) => db.prepare(`SELECT id, task_id, ended_at, metadata FROM task_runs
+  const rows = view(board, (db) => db.prepare(`SELECT id, task_id, started_at, ended_at, metadata FROM task_runs
     WHERE json_extract(metadata, '$.supercode.launch_pending') = 1
     AND json_extract(metadata, '$.supercode.close_confirmed_at') IS NULL`).all());
   for (const row of rows) {
     const s = json(row.metadata, {})?.supercode;
     try {
-      const receipt = launchReceipt(board, s);
+      let receipt = launchReceipt(board, s);
+      if (!receipt && (row.ended_at || now() - Number(s.launched_at ?? row.started_at) >= settings.launchWindow)) receipt = cancelUnissuedLaunch(board, s);
+      if (unissuedLaunch(receipt, s)) {
+        if (!retireUnissuedLaunch(board, row, s, receipt, { entry, effects })) report.failed.push([row.task_id, 'negative launch receipt conflicts with a bound session; retaining ownership']);
+        continue;
+      }
+      if (receipt?.status === 'issued' || (receipt?.live === false && !receipt.status && !receipt.exit)) {
+        report.queued.push([row.task_id, `launch ${s.launch_key} is issued or uncertain; retaining ownership`]);
+        continue;
+      }
       if (!receipt?.pane) { report.queued.push([row.task_id, s.launch_error ?? `awaiting launch receipt ${s.launch_key}`]); continue; }
       const sid = s.session_id ?? fleet.sessions?.find((f) => f.pane === receipt.pane && String(f.address).startsWith(`sc:${s.machine}:${s.harness}:`))?.address.split(':')[3];
       bindLaunch(board, row, s, receipt.pane, receipt.live ? sid : null);
@@ -1016,6 +1082,10 @@ function reconcileLaunches(board, fleet, report, entry, effects, settings, lanes
 
 function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'worker', meta = {} } = {}) {
   const machine = normalMachine(task.machine);
+  // Whether a board session opens a terminal window on its machine is the workflow's choice, stated on every launch;
+  // no machine default decides it.
+  const window = workflowFor(board.root).params.session_window;
+  if (typeof window !== 'boolean') throw unavailable('the workflow declares no params.session_window (true or false): whether a board session opens a window on its machine is the workflow\'s choice');
   {
     const made = resolveLocalWorkspace(board, task);
     tx(board, (db) => {
@@ -1028,7 +1098,7 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
   if (lane.harness === 'codex' && lane.reasoning_effort) tail.push('-c', `model_reasoning_effort=${JSON.stringify(lane.reasoning_effort)}`);
   const harness = HARNESSES[lane.harness] ? lane.harness : 'claude-code';
   const how = HARNESSES[harness];
-  const base = ['open', '--new', how.program, '--detach', '--on', task.machine, '--cwd', task.workspace_path];
+  const base = ['open', '--new', how.program, '--detach', `--window=${window}`, '--on', task.machine, '--cwd', task.workspace_path];
   // the slot's last session: kept when live, resumed when lost, never another slot's (a reviewer's is its own)
   // a close its session's own command asked for is carried out first, so its pane is gone before the slot's next
   // session starts (never two processes on one session)
@@ -1350,23 +1420,31 @@ async function send(from, label, to, body, key, { queue = false, ask = false, su
  * (the id is the send's idempotency key). One that fails is tried again next tick.
  */
 export async function sendBoardMessages(board, report, taskId = null) {
-  const rows = view(board, (db) => db.prepare(`SELECT id, task_id, payload FROM task_events e WHERE kind = 'board_message' AND NOT EXISTS
-    (SELECT 1 FROM task_events s WHERE s.kind = 'board_message_sent' AND s.task_id = e.task_id AND json_extract(s.payload, '$.event') = e.id) ORDER BY id`).all());
-  for (const row of rows) {
-    if (taskId && row.task_id !== taskId) continue;
-    const m = json(row.payload, {}) ?? {};
+  const pending = view(board, db => db.prepare(`SELECT 1 FROM task_events original WHERE kind='board_message'
+    AND NOT EXISTS (SELECT 1 FROM task_events sent WHERE sent.kind='board_message_sent'
+      AND sent.task_id=original.task_id AND json_extract(sent.payload,'$.event')=original.id) LIMIT 1`).get());
+  if (!pending) return;
+  const planned = tx(board, db => pendingRequestMail(db, taskId));
+  if (Number.isFinite(planned.nextAt)) report.next_mail_at = Math.min(report.next_mail_at ?? Infinity, planned.nextAt);
+  for (const mail of planned.ready) {
+    const first = mail.members[0];
     try {
-      const task = view(board, db => getTask(db, row.task_id));
-      const receipt = await send(boardAddress(board.label), board.label, m.to, m.text, m.message_id ?? `board-message-${row.id}`, { ask: Boolean(m.message_id), subject: `${task?.title || row.task_id} · ${m.message_id ? 'Question' : 'Update'}` });
+      const task = view(board, db => getTask(db, first.task_id));
+      const subject = mail.requester ? `State requests · ${mail.members.length} request(s) · ${task?.title || first.task_id}` : `${task?.title || first.task_id} · ${mail.message_id ? 'Question' : 'Update'}`;
+      const receipt = await send(boardAddress(board.label), board.label, mail.to, mail.text, mail.message_id ?? `board-message-${first.id}`, { ask: Boolean(mail.message_id), subject });
       if (!receipt.delivered) throw new Error(receipt.reason ?? 'queued; native transcript confirmation pending');
-      tx(board, (db) => event(db, row.task_id, 'board_message_sent', { event: row.id, to: m.to, receipt, ...(m.message_id ? { message_id: m.message_id } : {}) }));
+      tx(board, db => {
+        for (const member of mail.members) event(db, member.task_id, 'board_message_sent', { event: member.id, to: mail.to, receipt, ...(mail.message_id ? { message_id: mail.message_id, request_id: member.message_id ?? mail.message_id } : {}) });
+      });
     } catch (error) {
       const reason = String(error.message).slice(-200);
-      report.undelivered.push([row.task_id, m.to, reason]);
+      for (const member of mail.members) report.undelivered.push([member.task_id, mail.to, reason]);
       tx(board, db => {
-        const previous = db.prepare("SELECT payload,created_at FROM task_events WHERE task_id=? AND kind='board_message_failed' AND json_extract(payload,'$.event')=? ORDER BY id DESC LIMIT 1").get(row.task_id, row.id);
-        if (json(previous?.payload, {})?.reason !== reason || now() - (previous?.created_at ?? 0) >= 60)
-          event(db, row.task_id, 'board_message_failed', { event: row.id, to: m.to, message_id: m.message_id, reason });
+        for (const member of mail.members) {
+          const previous = db.prepare("SELECT payload,created_at FROM task_events WHERE task_id=? AND kind='board_message_failed' AND json_extract(payload,'$.event')=? ORDER BY id DESC LIMIT 1").get(member.task_id, member.id);
+          if (json(previous?.payload, {})?.reason !== reason || now() - (previous?.created_at ?? 0) >= 60)
+            event(db, member.task_id, 'board_message_failed', { event: member.id, to: mail.to, message_id: mail.message_id, reason });
+        }
       });
     }
   }
@@ -1399,6 +1477,7 @@ function ensureSubscriptions(board, entry) {
   const managers = Array.isArray(entry.params.managers) ? entry.params.managers.map(String) : [];
   const toManagers = Object.keys(entry.workflow.notify?.manager ?? {}).length > 0;
   tx(board, (db) => {
+    reconcileDependencySubscriptions(db);
     for (const t of db.prepare("SELECT id, current_run_id FROM tasks WHERE status NOT IN ('done', 'archived')").all()) {
       if (toManagers) for (const m of managers) subscribeIn(db, t.id, m, 'manager');
       if (!t.current_run_id) continue;
@@ -1418,6 +1497,7 @@ async function notify(board, fleet, report, entry) {
   const from = boardAddress(board.label);
   // each subscription's notices go in order; different subscribers are told side by side
   await pool(subscriptions(board.db).filter((sub) => sub.platform === 'supercode'), SEND_CONCURRENCY, async (sub) => {
+    if (sub.delivery_metadata?.dependent_card && sub.delivery_metadata.waiting_recipient) return;
     const role = ['worker', 'dependency', 'manager'].includes(sub.delivery_metadata?.role) ? sub.delivery_metadata.role : 'creator';
     // a session the fleet does not list this tick is told next tick: one reading is not a loss (a loaded box drops
     // sessions from a read, and a dropped subscription never came back), and a session that is replaced on its card
@@ -1425,7 +1505,7 @@ async function notify(board, fleet, report, entry) {
     if (role !== 'creator' && fleet.ok && !fleet.alive.has(sub.chat_id)) return;
     const kinds = heardBy(entry, role);
     if (!kinds.length) return;
-    const events = board.db.prepare(`SELECT id, kind, payload, created_at FROM task_events WHERE task_id = ? AND id > ? AND kind IN (${kinds.map(() => '?').join(', ')}) ORDER BY id`)
+    const events = board.db.prepare(`SELECT id, kind, payload, created_at, run_id FROM task_events WHERE task_id = ? AND id > ? AND kind IN (${kinds.map(() => '?').join(', ')}) ORDER BY id`)
       .all(sub.task_id, sub.last_event_id, ...kinds);
     if (!events.length) return;
     // the card as the workflow names it (its status the workflow's: triaging, reviewing, stopped; `stored_as` kanban.db's)
@@ -1444,7 +1524,8 @@ async function notify(board, fleet, report, entry) {
           text = c ? noticeOf(entry, role, ev.kind, task, p, c) : null;
         } else text = noticeOf(entry, role, ev.kind, task, p);
         if (text) {
-          const receipt = await send(from, board.label, sub.chat_id, text, `board-${sub.task_id}-${ev.id}-${sub.chat_id.slice(-12)}`, { queue: !entry.workflow.run && sub.delivery_mode === 'notify', subject: `${task?.title || sub.task_id} · ${ev.kind.replaceAll('_', ' ')}` });
+          const body = ['worker', 'dependency'].includes(role) ? identifyNotice(ev, text) : text;
+          const receipt = await send(from, board.label, sub.chat_id, body, `board-${sub.task_id}-${ev.id}-${sub.chat_id.slice(-12)}`, { queue: !entry.workflow.run && sub.delivery_mode === 'notify', subject: `${ev.kind.replaceAll('_', ' ')} · run ${ev.run_id ?? 'none'} · event ${ev.id} · ${task?.title || sub.task_id}` });
           if (!receipt.delivered) { pending = Boolean(receipt.queued); throw new Error(receipt.reason ?? 'native delivery confirmation pending'); }
           tx(board, (db) => event(db, sub.task_id, 'notice_delivered', { source_event: ev.id, kind: ev.kind, address: sub.chat_id, receipt }));
           report.notified.push([sub.task_id, ev.kind, sub.chat_id]);
@@ -1463,12 +1544,13 @@ async function notify(board, fleet, report, entry) {
     }
     // the cursor moves past what was delivered (a failed delivery is retried next tick; the mail id dedupes)
     tx(board, (db) => {
-      const where = "WHERE task_id = ? AND platform = 'supercode' AND chat_id = ?";
-      db.prepare(`UPDATE kanban_notify_subs SET last_event_id = ? ${where} AND last_event_id < ?`).run(cursor, sub.task_id, sub.chat_id, cursor);
+      const where = "WHERE task_id = ? AND platform = 'supercode' AND chat_id = ? AND thread_id = ?";
+      const identity = [sub.task_id, sub.chat_id, sub.thread_id ?? ''];
+      db.prepare(`UPDATE kanban_notify_subs SET last_event_id = ? ${where} AND last_event_id < ?`).run(cursor, ...identity, cursor);
       const failures = failed && !pending ? Number(sub.delivery_metadata?.failures ?? 0) + 1 : 0;
-      if (failures >= MAX_SEND_FAILURES) { db.prepare(`DELETE FROM kanban_notify_subs ${where}`).run(sub.task_id, sub.chat_id); return; }
-      if (failures !== Number(sub.delivery_metadata?.failures ?? 0)) db.prepare(`UPDATE kanban_notify_subs SET delivery_metadata = ? ${where}`).run(JSON.stringify({ ...sub.delivery_metadata, failures }), sub.task_id, sub.chat_id);
-      if (task?.status === 'archived' && cursor >= events.at(-1).id) db.prepare(`DELETE FROM kanban_notify_subs ${where}`).run(sub.task_id, sub.chat_id);
+      if (failures >= MAX_SEND_FAILURES) { db.prepare(`DELETE FROM kanban_notify_subs ${where}`).run(...identity); return; }
+      if (failures !== Number(sub.delivery_metadata?.failures ?? 0)) db.prepare(`UPDATE kanban_notify_subs SET delivery_metadata = ? ${where}`).run(JSON.stringify({ ...sub.delivery_metadata, failures }), ...identity);
+      if (task?.status === 'archived' && cursor >= events.at(-1).id) db.prepare(`DELETE FROM kanban_notify_subs ${where}`).run(...identity);
     });
   });
 }
@@ -1703,6 +1785,49 @@ export async function plan({ root, lanes, settings, slugs = null, params = {} })
   return out;
 }
 
+/** 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.
+async function activatePullRequestReviews(board, entry, report, effects, { only = 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] : [])));
+  for (const { id } of candidates) {
+    const eligible = db => {
+      const task = getTask(db, id);
+      if (!task) return false;
+      const scope = scopeOf(db, board, task, { params: entry.params });
+      if (!transitionsFor(entry.workflow, statusOf(db, task), 'request_review').some(t => !t.by || t.by.includes('platform')) ||
+        scope.card.dispatch_hold || scope.card.paused || scope.card.blocked_by.length) return false;
+      // The card's Tasks are its subtasks; an open one holds the review, and says so.
+      const open = scope.card.subtasks.filter(t => !['done', 'cancelled'].includes(t.status));
+      return open.length ? open : true;
+    };
+    const ready = view(board, eligible);
+    if (!ready) continue;
+    if (ready !== true) { report.queued.push([id, `review waits: ${ready.length} open task(s) in the card's Tasks: ${ready[0].id} ${ready[0].title}`]); continue; }
+    try {
+      const payload = openReviewPullRequests(board, id);
+      // The arc's open PRs ask for one review only while some head has no verdict: after changes are
+      // requested the next run is the implementer's, until a new head is pushed.
+      if (!payload || !reviewDue(board, id, payload.pr.map((url, index) => ({ url, head: payload.pr_head[index] })))) continue;
+      const evidence = inspectCompletionEvidence(board, id, entry, payload, 'request_review');
+      if (!evidence.ready) throw new Error(evidence.reason);
+      refreshCardInputs(board, id, { commits: true });
+      const moved = tx(board, db => {
+        const task = getTask(db, id);
+        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, summary: `Opened ${payload.pr.map((url, index) => `${url} at ${payload.pr_head[index]}`).join(', ')}`, ci: evidence }
+        }));
+      });
+      if (moved) {
+        effects.push(...moved.effects);
+        (report.review_requested ??= []).push({ id, prs: payload.pr, heads: payload.pr_head });
+      }
+    } catch (error) { report.queued.push([id, `PR review waits: ${error.message}`]); }
+  }
+}
+
 /**
  * One tick over every board of the home at `root`. `lanes` from `lanesOf`, `settings` from `boardSettings`.
  * `only` limits starting to one card (a create that answers whether its card started). Each board is ticked under its
@@ -1750,6 +1875,7 @@ export async function tick({ root, lanes, settings, only = null, slugs = null, d
       reconcileLaunches(board, fleet, report, entry, effects, settings, lanes); supervise(board, fleet, settings, report, entry, effects); await runEffects(board, effects.splice(0), { retryNotices: true }); closeRequested(board, report); phase('supervise');
       report.unsettled = [];
       report.promoted = recomputeReady(board, effects, report.unsettled);
+      if (dispatch) await activatePullRequestReviews(board, entry, report, effects, { only });
       await sendBoardMessages(board, report);
       const before = report.started.length;
       if (dispatch) startCards(board, fleet, lanes, settings, report, entry, effects, { only, hostRunning });