@volter/supercode-orchestrator 0.5.205 → 0.5.206

package/board/dispatch.mjs

@@ -18,11 +18,13 @@
 // acts on and does nothing when another round already acted (see `tick`). Every side effect follows a committed claim, so
 // a crash between the two steps is answered by the next round.
 import { machineCall } from './doors.mjs';
+import { detachedCard, detachedSession, personCustody, sessionOperation, takeSessionCustody } from './custody.mjs';
 import { processSession } from './caller-session.mjs';
 import { callerOf, current, isCallersCall, ownCall } from './call.mjs';
 import { noteStep } from '@volter/supercode-harness-sdk/slow-log';
 import { monitorsRuns, recoversRuns, retainRecovery, failedObservation, surfaceIncident, auditEndedRuns, originOf } from './incidents.mjs';
 import { readMachineFleet } from './machine-fleet.mjs';
+import { homeFleetMachines } from './fleet-targets.mjs';
 import { delegatedWork, idleInterval } from './session-work.mjs';
 import { localSessionDelegations } from '../agents.mjs';
 import { creatorOf, sessionProgress } from './workflow.mjs';
@@ -35,6 +37,8 @@ import { agentScope, localCardAgent, localReaderContext, localAgentSessions, run
 import { finishCardAgentAssignment, recordCardAgentAssignment } from './agent-declarations.mjs';
 import { materializeAgentHome } from '../agent-home.mjs';
 import { memorySnapshot } from '../hermes-cli.mjs';
+import { hermesModel } from '../worker-route.mjs';
+import { MODEL_ARGUMENTS } from '../activation.mjs';
 import { createRequire } from 'node:module';
 import { spawn as spawnChild, execFile } from 'node:child_process';
 import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
@@ -48,10 +52,11 @@ import { checkWorkspace, assertWorkspaceOwner, notePresence, resolveWorkspace }
 import { capacity, dispatched, executionHost, harnessDefaults, holdings } from './capacity.mjs';
 import { evaluate, holds, render } from './expr.mjs';
 import { identifyNotice } from './notices.mjs';
+import { noticeReceiptsInTurns, noticeKey, requireNoticeBasis, noticeWriterBasis } from './notice-receipts.mjs';
 import { pendingRequestMail } from './request-mail.mjs';
 import {
   cardContext, claimTtl, currentRun, DEFAULT_FAILURE_LIMIT, extendClaim, getTask, lastSession,
-  recomputeReady, runEffects, queueEffects, setRunSession, subscribeIn, subscriptions, reconcileDependencySubscriptions,
+  recomputeReady, runEffects, queueEffects, setRunSession, subscribeIn, replaceWorkerSubscriptions, subscriptions, reconcileDependencySubscriptions,
 } from './engine.mjs';
 
 const WORKER = fileURLToPath(new URL('../bin/hermes-worker.mjs', import.meta.url));
@@ -66,8 +71,10 @@ export function normalMachine(name) {
 
 /** This machine's name as supercode's addresses spell it: its Teams enrollment, else its host name. */
 let localMachineName;
-/** Learn it once per process, from the machine's own daemon (in-process: doors.mjs); a host with no daemon is its OS name. */
-export async function knowLocalMachine() {
+/** Learn it once per process, from the machine's own daemon (in-process: doors.mjs); a host with no daemon is its OS name.
+ *  `known`: the name this process's owner already learned (the owner's read door, owner-door.mjs). */
+export async function knowLocalMachine(known = null) {
+  if (known && !localMachineName) localMachineName = normalMachine(known);
   if (localMachineName) return localMachineName;
   try { const machine = await machineCall(null, 'harness.v1.machine.describe', {}, { timeoutMs: 15_000 }); localMachineName = normalMachine(machine.name ?? machine.hostname); }
   catch { localMachineName = normalMachine(hostname()); }
@@ -144,17 +151,7 @@ export function callerSession() {
 /** The fleet as the home's machines answer for themselves (machine-fleet.mjs): this machine, and every machine an open
  * card of the home names or one of its notice subscribers is on. */
 export async function observeFleet(root = fleetRoot) {
-  const machines = new Set();
-  for (const slug of root ? listBoards(root) : []) {
-    try {
-      const b = openBoard(root, slug);
-      try {
-        const live = "t.status NOT IN ('done', 'cancelled', 'archived') AND NOT COALESCE(c.archived, 0)";
-        for (const { machine } of b.db.prepare(`SELECT DISTINCT c.machine FROM supercode_cards c JOIN tasks t ON t.id = c.task_id WHERE c.machine IS NOT NULL AND c.machine != '' AND ${live}`).all()) machines.add(normalMachine(machine));
-        for (const { chat_id: address } of b.db.prepare(`SELECT DISTINCT s.chat_id FROM kanban_notify_subs s JOIN tasks t ON t.id = s.task_id JOIN supercode_cards c ON c.task_id = t.id WHERE s.platform = 'supercode' AND s.chat_id LIKE 'sc:%' AND ${live}`).all()) machines.add(normalMachine(address.split(':')[1]));
-      } finally { b.close(); }
-    } catch { /* its own tick reports it */ }
-  }
+  const machines = await homeFleetMachines(root, normalMachine);
   const fleet = await readMachineFleet(machines, localMachine());
   presenceReading = { known: fleet.presenceKnown === true, online: new Set([localMachine(), ...fleet.online]), unknown: fleet.unknown ?? new Set() };
   notePresence(presenceReading);
@@ -389,7 +386,8 @@ export function lanesOf(profiles = {}) {
   for (const [name, p] of Object.entries(profiles)) {
     const w = p?.worker;
     if (!w?.harness) continue;
-    out[name] = { name, dir: p.dir, harness: w.harness, model: w.model ?? null, reasoning_effort: w.reasoning_effort ?? null, surface: w.surface ?? 'headless', capacity: w.capacity ?? null };
+    const model = w.model ?? (MODEL_ARGUMENTS[w.harness] ? hermesModel(p)?.model ?? null : null);
+    out[name] = { name, dir: p.dir, harness: w.harness, model, reasoning_effort: w.reasoning_effort ?? null, surface: w.surface ?? 'headless', capacity: w.capacity ?? null };
   }
   return out;
 }
@@ -444,16 +442,43 @@ async function recordBounces(board, fleet, entry, report) {
   try {
     const answer = await runtimeDoor(null, 'harness.v1.mail.expired', {}, { timeout: 15_000 });
     const expired = answer.code === 0 ? lastJson(answer.stdout)?.rows ?? [] : [];
-    for (const expiry of expired.filter((row) => row?.bounced === true && row.id && at - Number(row.expired_at_ms) < 24 * 3600_000)) tx(board, (db) => {
-      const filed = db.prepare("SELECT task_id, payload FROM task_events WHERE kind IN ('notice_filed', 'session_notice_filed', 'actor_notice_filed') AND json_extract(payload, '$.message_id') = ? ORDER BY id DESC LIMIT 1").get(expiry.id);
-      if (!filed || db.prepare("SELECT 1 FROM task_events WHERE task_id = ? AND kind = 'notice_bounced' AND json_extract(payload, '$.message_id') = ?").get(filed.task_id, expiry.id)) return;
-      const run = currentRun(db, filed.task_id), session = run?.metadata?.supercode;
-      const uncounted = Boolean(run && !run.ended_at && json(filed.payload, {})?.verb === 'session_idle' && addressOf(session) === expiry.to && Number(session.goal_turns) > 0);
-      if (uncounted) setRunSession(db, run.id, { goal_turns: Number(session.goal_turns) - 1 });
-      event(db, filed.task_id, 'notice_bounced', { message_id: expiry.id, to: expiry.to, reason: expiry.reason, expired_at_ms: expiry.expired_at_ms, idle_turn_uncounted: uncounted }, run?.id ?? null);
-      tell(db, filed.task_id, `${filed.task_id}: the board's notice ${expiry.id} to ${expiry.to} bounced: ${expiry.reason}. It stays unread in that mailbox and is not sent again.`);
-      (report.bounced ??= []).push([filed.task_id, expiry.to, expiry.id]);
-    });
+    const eligible = expired.filter((row) => row?.bounced === true && row.id && at - Number(row.expired_at_ms) < 24 * 3600_000);
+    if (eligible.length) {
+      const receipts = await noticeReceiptsInTurns(board, eligible.map(row => row.id));
+      const pending = eligible.filter(row => {
+        const filed = receipts.filed.get(row.id);
+        return filed && !receipts.bounced.has(noticeKey(filed.task_id, row.id));
+      });
+      let revision = receipts.revision;
+      // Eight expiries per writer turn; the historical search and duplicate lookup have already yielded.
+      for (let offset = 0; offset < pending.length; offset += 8) {
+        requireNoticeBasis(board, revision);
+        const recorded = tx(board, db => {
+          const basis = noticeWriterBasis(board, revision, receipts.ceiling);
+          const added = new Set(), staged = [];
+          for (const expiry of pending.slice(offset, offset + 8)) {
+            const found = receipts.filed.get(expiry.id), key = noticeKey(found.task_id, expiry.id);
+            if (receipts.bounced.has(key) || added.has(key)) continue;
+            // Revalidate the selected immutable receipt by primary key; no historical payload predicate in the writer.
+            const filed = db.prepare("SELECT task_id, payload FROM task_events WHERE id = ? AND kind IN ('notice_filed', 'session_notice_filed', 'actor_notice_filed') AND json_extract(payload, '$.message_id') = ?").get(found.id, expiry.id);
+            if (!filed) continue;
+            const run = currentRun(db, filed.task_id), session = run?.metadata?.supercode;
+            const uncounted = Boolean(run && !run.ended_at && json(filed.payload, {})?.verb === 'session_idle' && addressOf(session) === expiry.to && Number(session.goal_turns) > 0);
+            if (uncounted) setRunSession(db, run.id, { goal_turns: Number(session.goal_turns) - 1 });
+            event(db, filed.task_id, 'notice_bounced', { message_id: expiry.id, to: expiry.to, reason: expiry.reason, expired_at_ms: expiry.expired_at_ms, idle_turn_uncounted: uncounted }, run?.id ?? null);
+            tell(db, filed.task_id, `${filed.task_id}: the board's notice ${expiry.id} to ${expiry.to} bounced: ${expiry.reason}. It stays unread in that mailbox and is not sent again.`);
+            added.add(key);
+            staged.push([filed.task_id, expiry.to, expiry.id]);
+          }
+          return { rows: staged, revision: basis, ceiling: db.prepare('SELECT MAX(id) AS id FROM task_events').get().id };
+        });
+        for (const row of recorded.rows) receipts.bounced.add(noticeKey(row[0], row[2]));
+        (report.bounced ??= []).push(...recorded.rows);
+        receipts.ceiling = recorded.ceiling;
+        revision = requireNoticeBasis(board, recorded.revision, { ownWrites: true });
+        if (offset + 8 < pending.length) await yieldToOwner();
+      }
+    }
   } catch (error) { report.undelivered?.push(['mail', 'bounces', String(error.message).slice(-200)]); }
   // the first input of each session launched in the last ten minutes, until its machine's launch record settles it
   const running = view(board, (db) => db.prepare('SELECT t.id, r.id run_id, r.metadata FROM tasks t JOIN task_runs r ON r.id = t.current_run_id WHERE r.ended_at IS NULL').all());
@@ -481,8 +506,25 @@ async function supervise(board, fleet, settings, report, entry, effects) {
   // Published native observations are the only liveness input. Missing data remains unknown. A launch the
   // observations show stopped is asked, through its machine's door, how it ended.
   const exits = new Map();
+  const firstResponses = new Map();
   // every running session's liveness is read before anything is decided of it (unknown stays unknown)
   for (const { id } of rows) await readBefore(fleet, currentRun(board.db, id)?.metadata?.supercode);
+  // A living terminal can have refused its first turn. Read the native
+  // assistant outcome through the session door, before any board write.
+  for (const { id } of rows) {
+    const run = currentRun(board.db, id), session = run?.metadata?.supercode;
+    if (session?.harness !== 'claude-code' || session.mode !== 'fresh' || !session.launch_key || session.first_response || !session.session_id) continue;
+    let locator;
+    try { locator = nativeReading(nativeSessions(session.machine, session.harness, session.session_id), session).row?.locator; } catch { continue; }
+    if (!locator) continue;
+    const answer = await doorOn(session.machine, 'harness.v1.sessions.load', { locator, options: { include_subagents: false, message_limit: 0, inline_media: 'metadata' } }, { timeout: NATIVE_DISCOVERY_MS });
+    const loaded = answer.code === 0 ? lastJson(answer.stdout) : null;
+    const response = loaded?.session?.first_response;
+    if (loaded?.session?.session_id !== session.session_id || !['response', 'error'].includes(response?.outcome)
+      || !Number.isFinite(Date.parse(response.at)) || !Number.isFinite(run.started_at)
+      || Date.parse(response.at) < run.started_at * 1000) continue;
+    firstResponses.set(id, { run: run.id, session: session.session_id, response });
+  }
   for (const { id } of rows) {
     const session = currentRun(board.db, id)?.metadata?.supercode;
     if (!session?.launch_key || !fleet.ok || sessionAlive(fleet, session) !== false) continue;
@@ -548,6 +590,16 @@ async function supervise(board, fleet, settings, report, entry, effects) {
         }
       };
       const limits = limitsOf(db, board, entry, task, session);
+      const first = firstResponses.get(id);
+      if (first?.run === runRow?.id && first.session === session?.session_id && !session.first_response) {
+        session = { ...session, first_response: first.response };
+        setRunSession(db, runRow.id, session);
+        if (first.response.outcome === 'error') {
+          observe('exited', { error: `native session ${session.session_id} refused its first response (${first.response.error_code ?? 'native API error'})`,
+            session_id: session.session_id, pane: session.pane, first_response: first.response }, 'crashed');
+          return;
+        }
+      }
       // A verified adoption binds the run to its session; a launch key still pending beside it is the reconciler's to
       // retire at its machine, and no longer what the run waits on.
       const adopted = session?.mode === 'adopt' && Boolean(session.address);
@@ -714,6 +766,11 @@ function limitsOf(db, board, entry, task, session) {
 
 async function stopSession(board, session) {
   if (!session) return;
+  if (view(board, db => detachedSession(db, session))) throw Object.assign(new Error('close deferred: session was detached to a person'), { sessionDetached: true });
+  return sessionOperation(board, { address: addressOf(session), kind: 'session close' }, () => stopOwnedSession(board, session));
+}
+
+async function stopOwnedSession(board, session) {
   if (boardCopyOf(board)) throw copyRefusal(board, 'closes no session');
   if (session.surface === 'headless' && pidAlive(session.pid)) {
     // SIGTERM to the worker's process group, then SIGKILL if it is still there after a grace, as Hermes stops its own
@@ -764,11 +821,11 @@ async function homeHoldings(root, slugs, lanes, fleet, entry) {
         // each run's session read before it is counted live or not (unknown stays unknown)
         for (const r of b.db.prepare('SELECT r.metadata FROM tasks t JOIN task_runs r ON r.id = t.current_run_id').all()) await readBefore(fleet, json(r.metadata, {})?.supercode);
         const storedOf = (id) => storedStatus(b.db, b, entry, id).stored;
-        out.push(...holdings(b, { lanes, fleetOk: fleet.ok, alive: (s) => sessionAlive(fleet, s), liveRecord: live, modelOf: transcriptModel, storedOf, machineOf: normalMachine, home: localMachine(),
+        out.push(...await holdings(b, { lanes, fleetOk: fleet.ok, alive: (s) => sessionAlive(fleet, s), liveRecord: live, modelOf: transcriptModel, storedOf, machineOf: normalMachine, home: localMachine(),
           runLaneOf: row => runLane(b.db, b, entry, getTask(b.db, row.id), lanes) }));
       }
       finally { b.close(); }
-    } catch { /* its own tick reports it */ }
+    } catch (error) { if (error.capacityUnread) throw error; /* its own tick reports other board errors */ }
   }
   out.defaults = harnessDefaults(out);
   return out;
@@ -832,7 +889,7 @@ async function startCards(board, fleet, lanes, settings, report, entry, effects,
   const tickState = { local_started: 0 };
   const startable = new Set(Object.keys(workflow.statuses).filter((status) => transitionsFor(workflow, status, d.start).length));
   const everyCard = board.db.prepare("SELECT id FROM tasks WHERE status != 'archived'").all().map((r) => getTask(board.db, r.id));
-  const scopeFor = (task, extra = {}) => scopeOf(board.db, board, task, { params, extra: { host: hostOf(pressure), tick: tickState, ...extra } });
+  const scopeFor = (task, extra = {}) => scopeOf(board.db, board, task, { params, lazy: true, extra: { host: hostOf(pressure), tick: tickState, ...extra } });
   // who would run it: the role of the status its start moves it to, and that role's lane
   const planOf = (task, scope) => {
     const status = statusOf(board.db, task);
@@ -855,6 +912,7 @@ async function startCards(board, fleet, lanes, settings, report, entry, effects,
     if (task.subtask_of || task.current_run_id) continue;
     const state = scopeFor(task).card;
     if (state.archived || ['done', 'cancelled'].includes(state.status)) continue;
+    if (state.detached) { waiting(task, `session belongs to ${state.detached.person}; verified adoption is required`); continue; }
     if (state.dispatch_hold) { waiting(task, 'dispatch held: an explicit start or verified adoption must release it'); continue; }
     if (workflow.run && state.paused) { waiting(task, `paused: ${state.paused.reason ?? 'manager pause'}`); continue; }
     if (workflow.run && state.blocked_by.length) { waiting(task, `blocked by ${state.blocked_by.map(b => b.id).join(', ')}`); continue; }
@@ -989,7 +1047,7 @@ function launchFailed(board, entry, id, error, payload) {
  *  longer the card's current one is its supersession, whatever failed, so no caller reports it against the successor. */
 export async function launchRun(board, entry, id, lane, fleet, settings) {
   const runId = getTaskNow(board, id).current_run_id;
-  try { return await launchAttempt(board, entry, id, lane, fleet, settings, runId); }
+  try { return await sessionOperation(board, { taskId: id, kind: 'session launch' }, () => launchAttempt(board, entry, id, lane, fleet, settings, runId)); }
   catch (error) {
     error.launchRun = runId;
     if (!error.launchSuperseded && !view(board, (db) => runCurrent(db, id, runId))) error.launchSuperseded = true;
@@ -1021,7 +1079,19 @@ async function launchAttempt(board, entry, id, lane, fleet, settings, runId) {
   // caps here too, excluding this attempt's own reservation. Other cap kinds keep their existing admission rules.
   const sessionCaps = entry.workflow.dispatch.capacity?.filter(cap => cap.counts === 'sessions' && cap.where?.dispatch === true) ?? [];
   if (sessionCaps.length) {
-    const held = await homeHoldings(board.root, listBoards(board.root), lanesOf(entry.profiles), fleet, entry);
+    let held;
+    try { held = await homeHoldings(board.root, listBoards(board.root), lanesOf(entry.profiles), fleet, entry); }
+    catch (error) {
+      if (!error.capacityUnread) throw error;
+      // No launch door has been issued. Keep this reservation retryable, including a deferred run whose
+      // reconciliation claim just cleared launch_deferred. Top-level capacity reads still propagate unread.
+      runTx(board, id, runId, db => {
+        const previous = currentRun(db, id)?.metadata?.supercode;
+        setRunSession(db, runId, { status, role: spec.role, slot, launched_at: now(), launch_deferred: true, launch_deferred_error: error.message });
+        if (previous?.launch_deferred_error !== error.message) event(db, id, 'launch_deferred', { reason: error.message }, runId);
+      });
+      throw Object.assign(error, { launchDeferred: true, launchPending: true });
+    }
     const others = held.filter(x => !(x.board === board.slug && x.run === runId));
     const refused = capacity(sessionCaps, others, evaluate).admit({ card: id, board: board.slug, machine: executionHost(lane, task.machine, localMachine(), normalMachine),
       assignee: lane.name ?? task.assignee, status, stored: scope.card.stored ?? status, model: task.model_override ?? lane.model ?? null, harness: lane.harness,
@@ -1121,6 +1191,7 @@ export async function startCard(board, id, { roles = ['manager'], lanes, setting
   const fleet = await observeFleet();
   const before = getTaskNow(board, id), checked = await checkWorkspace(board, before);
   const moved = tx(board, (db) => {
+    if (detachedCard(db, id)) throw new Error(`${id} is detached to a person; request and verify adoption before starting it`);
     assertWorkspaceOwner(db, before, checked);
     if (checked) db.prepare('UPDATE supercode_cards SET workspace_root=? WHERE task_id=?').run(checked.mainRoot, id);
     if (!roles.some(role => ['manager', 'creator'].includes(role))) throw new Error('Only the manager or creator starts a held card; request its decision.');
@@ -1163,6 +1234,27 @@ export const unboundLaunch = (session, launchWindow, at = now()) => Boolean(sess
   && Number(session.launched_at) > 0 && at - Number(session.launched_at) >= launchWindow);
 /** The fleet turns of a session read in a turn (`needs_input`: a turn stopped on a permission or a question). */
 const TURN_IN_PROGRESS = new Set(['working', 'needs_input']);
+/**
+ * A harness's own blocking prompt on the pane's screen, which no input from the board answers: the session is stopped,
+ * not between turns. Claude Code's usage limit ("What do you want to do? 1. Stop and wait for limit to reset …") is
+ * one; its reset time is said when the prompt names it. Null when the screen shows none.
+ */
+const BLOCKING_PROMPTS = [
+  { reason: 'provider-limit', harness: 'claude-code', test: /Stop and wait for limit to reset/i, resets: /continue automatically at ([^\n│]+?)\s*(?:│|$)/im },
+];
+async function blockingPrompt(session) {
+  if (!session?.pane) return null;
+  const machine = session.machine ?? localMachine();
+  const r = await doorOn(machine, 'harness.v1.panes.capture', { pane: session.pane, lines: 60 }, { timeout: 10_000 });
+  const text = r.code === 0 ? lastJson(r.stdout)?.text : null;
+  if (typeof text !== 'string') return null; // unread (or a release without this door): the turn reading stands
+  for (const prompt of BLOCKING_PROMPTS) {
+    if (prompt.harness !== (session.harness ?? 'claude-code') || !prompt.test.test(text)) continue;
+    const resets = prompt.resets.exec(text)?.[1]?.trim() ?? null;
+    return { reason: prompt.reason, resets, observed_at: now() };
+  }
+  return null;
+}
 /** The watch on a session whose turn is not published: it began (`since`) at the first such reading, at the reading
  *  that found its record written again (`mark`: its last write and when its harness says its state began, in ms), or
  *  at the first reading after more than `gap` seconds unread (`seen`: the last reading). */
@@ -1170,7 +1262,7 @@ function unreadWatch(held, mark, gap, at = now()) {
   const kept = held && Number(held.mark) === mark && Number(held.since) <= at && at - Number(held.seen) <= gap;
   return { since: kept ? Number(held.since) : at, mark, seen: at };
 }
-async function turnAtClose(session, pane = null, { launchWindow = null, quiet = null, gap = 0 } = {}) {
+async function turnAtClose(session, pane = null, { launchWindow = null, quiet = null, gap = 0, inputAbandonment = null } = {}) {
   const machine = session.machine ?? localMachine();
   const recordOf = (rows, id, harness) => rows.find((row) => row.locator?.session_id === id && row.locator?.harness === harness);
   let activity, rows = null;
@@ -1208,12 +1300,21 @@ async function turnAtClose(session, pane = null, { launchWindow = null, quiet =
   }
   if (activity.presence && activity.presence !== 'running') return null;
   if (activity.turn === 'idle') return null;
+  if (inputAbandonment && activity.presence === 'running' && activity.turn === 'needs_input'
+    && activity.session_id === session.session_id && activity.harness === session.harness) {
+    return { abandonInput: { ...inputAbandonment, observed_at: now(), session_id: activity.session_id,
+      harness: activity.harness, pane: session.pane, turn: activity.turn } };
+  }
   const who = activity.session_id ? `sc:${normalMachine(machine)}:${activity.harness ?? session.harness}:${activity.session_id}` : addressOf(session);
   const inTurn = (turn) => ({ why: `its session ${who} is in a turn (${turn}); it closes once the turn ends`, unread: null });
   if (TURN_IN_PROGRESS.has(activity.turn)) return inTurn(activity.turn);
   // No turn published: the session's own record says whether anything goes on in it. One whose record does not answer,
   // or shows neither a write nor when its state began, has nothing to count from and waits.
   const unknown = `its session ${who} publishes no turn (${activity.turn ?? 'unknown'})`;
+  // A harness held at its own blocking prompt (a provider's usage limit) is stopped, whatever its record shows: closed,
+  // with why, rather than waited on until the limit resets.
+  const blocked = await blockingPrompt(session).catch(() => null);
+  if (blocked) return { stopped: blocked };
   const sessionId = activity.session_id ?? session.session_id, harness = activity.harness ?? session.harness ?? 'claude-code';
   if (!sessionId || !quiet) return { why: unknown };
   if (!rows) try { rows = (await discoverNative(machine, harness, sessionId)).sessions; }
@@ -1229,13 +1330,60 @@ async function turnAtClose(session, pane = null, { launchWindow = null, quiet =
 /** Hold the close of an ended run's session for what `turnAtClose` read, with the watch that reading leaves on the run. */
 async function holdForTurn(session, pane, options) {
   const held = await turnAtClose(session, pane, options);
+  if (held?.abandonInput) return held.abandonInput;
+  if (held?.stopped) return { stopped: held.stopped };
   if (held) throw Object.assign(new Error(`close deferred: ${held.why}`), 'unread' in held ? { closeUnread: held.unread } : {});
 }
 
+/** Only a recorded manager/creator release of this ended worker permits abandoning input. */
+function reassignedInputClose(board, row, session) {
+  if (!row.ended_at || !row.profile || !session.pane || !session.session_id || !session.harness
+    || (session.slot ?? 'worker') !== 'worker' || !session.launch_key || !['fresh', 'resume'].includes(session.mode)) return null;
+  return view(board, (db) => {
+    const release = db.prepare(`SELECT id, payload, created_at FROM task_events WHERE task_id = ? AND kind = 'dispatch_released'
+      AND json_extract(payload, '$.ended_run') = ? ORDER BY id DESC LIMIT 1`).get(row.task_id, row.id);
+    const intent = json(release?.payload, null);
+    if (intent?.reason !== 'explicit set') return null;
+    if (intent.abandon_waiting_input === true && Object.hasOwn(intent, 'reassigned_to') && intent.reassigned_from === row.profile
+      && intent.reassigned_to !== intent.reassigned_from) return { release_event: release.id, assignment_event: null };
+    // Older writers recorded the role-authorized release and assignment separately.
+    // Require the same actor, exact ended run and end timestamp; a model change is insufficient.
+    const assignment = db.prepare(`SELECT id, payload, created_at FROM task_events WHERE task_id = ? AND run_id = ?
+      AND kind = 'assigned' AND id < ? ORDER BY id DESC LIMIT 1`).get(row.task_id, row.id, release.id);
+    const changed = json(assignment?.payload, null);
+    if (!changed?.by || !Object.hasOwn(changed, 'assignee') || changed.by !== intent.by || changed.assignee === row.profile
+      || assignment.created_at !== row.ended_at || release.created_at < assignment.created_at
+      || release.created_at > assignment.created_at + 1) return null;
+    return { release_event: release.id, assignment_event: assignment.id };
+  });
+}
+
+function recordInputClose(board, row, session, reading) {
+  return tx(board, (db) => {
+    const latest = db.prepare('SELECT ended_at, metadata FROM task_runs WHERE id = ? AND task_id = ?').get(row.id, row.task_id);
+    const current = json(latest?.metadata, {})?.supercode;
+    if (!latest?.ended_at || !current || current.pane !== session.pane || current.session_id !== session.session_id
+      || normalMachine(current.machine) !== normalMachine(session.machine) || !current.close_requested
+      || current.close_confirmed_at || current.close_transferred_to || current.close_claim?.lock !== claimer()
+      || !(Number(current.close_claim?.expires) > now())) return false;
+    const protectedNow = 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) return false;
+    const prior = current.close_input_reading;
+    setRunSession(db, row.id, { close_input_reading: reading });
+    if (prior?.release_event !== reading.release_event || prior?.session_id !== reading.session_id)
+      event(db, row.task_id, 'session_input_close_authorized', reading, row.id);
+    return true;
+  });
+}
+
 /** The closes this process is making now, by run: each one's outcome, for a pass that meets it under way. */
 const closesUnderway = new Map();
 export async function closeRequested(board, report, { taskId = null, caller = null, ttl = null, fleet = null } = {}) {
-  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, profile, ended_at, metadata FROM task_runs
     WHERE metadata IS NOT NULL ${taskId ? 'AND task_id = ?' : ''}`).all(...(taskId ? [taskId] : [])));
   // Repair pre-transfer history once: only identities with an older unended reference need a write.
   const latest = new Map(), transfers = new Map();
@@ -1255,7 +1403,7 @@ export async function closeRequested(board, report, { taskId = null, caller = nu
   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 || session.close_transferred_to || session.close_confirmed_at) continue;
+    if (!session || detachedSession(board.db, session) || session.close_transferred_to || session.close_confirmed_at) continue;
     // A keyed launch is reconciled by its machine's own daemon (D137), never by a door the close waits on. A session
     // adopted onto a run whose launch was still pending did not come from that launch: the key is let go and the
     // session is the run's, released or closed as its own below. A launch that never bound a pane left nothing the
@@ -1340,7 +1488,7 @@ export async function closeRequested(board, report, { taskId = null, caller = nu
     try {
     const claimed = tx(board, (db) => {
       const current = json(db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(row.id)?.metadata, {})?.supercode;
-      if (!current || current.close_confirmed_at || current.close_transferred_to || current.pane !== session.pane || current.session_id !== session.session_id || claimHolds(current.close_claim)) return false;
+      if (!current || detachedSession(db, current) || current.close_confirmed_at || current.close_transferred_to || current.pane !== session.pane || current.session_id !== session.session_id || claimHolds(current.close_claim)) return false;
       requestSessionClose(db, row.task_id, { runId: row.id });
       // a close this process already claims, with a minute of its claim left, is tried again without a new claim
       const own = current.close_claim?.lock === claimer() && Number(current.close_claim.expires) > now() + 60;
@@ -1373,7 +1521,20 @@ export async function closeRequested(board, report, { taskId = null, caller = nu
         if (protectedNow) throw new Error(`close deferred: pane ${session.pane} is owned by an unended run`);
         // An ended run's session is closed only between its turns, read last, after the claim and the pane list (a pane
         // already gone is settled above with no reading; t_f34710bc's coder was cut mid-proof at 15:01:13Z, 2026-10-04).
-        if (row.ended_at) { const { launchWindow, idleQuiet: quiet, interval } = boardSettings(workflowFor(board.root).params); await holdForTurn(session, observed.live.get(session.pane), { launchWindow, quiet, gap: Math.max(3 * interval, quiet / 2) }); }
+        if (row.ended_at) {
+          const { launchWindow, idleQuiet: quiet, interval } = boardSettings(workflowFor(board.root).params);
+          const reading = await holdForTurn(session, observed.live.get(session.pane), {
+            launchWindow, quiet, gap: Math.max(3 * interval, quiet / 2),
+            inputAbandonment: reassignedInputClose(board, row, session),
+          });
+          if (reading?.stopped) {
+            // the run says why its session stopped (a provider's limit, and when it resets), then the close proceeds
+            const { reason, resets, observed_at } = reading.stopped;
+            tx(board, (db) => event(db, row.task_id, 'run_incident', { observation: 'session_stopped', run: row.id, session: addressOf(session), pane: session.pane,
+              reason: `${addressOf(session)} stopped at its harness's ${reason} prompt${resets ? `; it resets ${resets}` : ''}`, stopped: reason, resets, observed_at }, row.id));
+          } else if (reading && !recordInputClose(board, row, session, reading))
+            throw new Error('close deferred: ownership changed before ending its input dialog');
+        }
         await stopSession(board, session); observed.live.delete(session.pane);
       }
       }
@@ -1387,7 +1548,7 @@ export async function closeRequested(board, report, { taskId = null, caller = nu
     }
     tx(board, (db) => {
       const current = json(db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(row.id)?.metadata, {})?.supercode;
-      if (!current || current.pane !== session.pane || current.session_id !== session.session_id) return;
+      if (!current || detachedSession(db, current) || current.pane !== session.pane || current.session_id !== session.session_id) return;
       const at = now();
       // a close confirmed meanwhile (a claim that expired under a slow close) is not undone by this attempt's failure
       if (error && current.close_confirmed_at) return;
@@ -1629,10 +1790,10 @@ function effectMessageKey(effect) {
  */
 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) {
+  if (prior?.close_confirmed_at || view(board, db => detachedSession(db, prior))) {
     tx(board, (db) => {
       // A closed session has nothing to be told; its next run starts with its own prompt.
-      event(db, e.id, 'session_notice_not_required', { address: e.address, verb: e.verb, notice: e.durableId, reason: 'session closed' }, e.runId);
+      event(db, e.id, 'session_notice_not_required', { address: e.address, verb: e.verb, notice: e.durableId, reason: prior?.detached_at ? 'session detached to a person' : 'session closed' }, e.runId);
       if (prior.lifecycle_notice_pending === e.durableId) setRunSession(db, e.runId, { lifecycle_notice_pending: null });
     });
     return true;
@@ -1643,6 +1804,7 @@ export async function sessionNotice(board, e) {
   tx(board, (db) => {
     const session = json(db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(e.runId)?.metadata, {})?.supercode;
     if (session?.lifecycle_notice_pending === e.durableId) setRunSession(db, e.runId, { lifecycle_notice_pending: null });
+    if (filed.detached) event(db, e.id, 'session_notice_not_required', { address, notice: e.durableId, reason: 'session detached to a person' }, e.runId);
     if (filed.new) event(db, e.id, 'session_notice_filed', { address, verb: e.verb, source_event: e.sourceEvent, notice: e.durableId, message_id: filed.message_id }, e.runId);
   });
   return true;
@@ -1653,6 +1815,7 @@ 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 (view(board, db => detachedSession(db, session))) return true;
     const address = addressOf(session);
     if (!address) throw new Error('actor session identity unavailable');
     // filed in the actor's mailbox, which delivers it
@@ -1842,9 +2005,8 @@ function bindLaunch(board, row, session, pane, sid) {
       ...(address ? { address, launch_pending: false, launch_error: null, seen_at: now() } : {}) });
     if (current.ended_at) requestSessionClose(db, row.task_id, { runId: row.id });
     else if (address && getTask(db, row.task_id)?.current_run_id === row.id) {
-      subscribeIn(db, row.task_id, address, 'worker');
+      replaceWorkerSubscriptions(db, row.task_id, address);
       for (const p of db.prepare('SELECT parent_id FROM task_links WHERE child_id=?').all(row.task_id)) subscribeIn(db, p.parent_id, address, 'dependency');
-      for (const t of db.prepare('SELECT task_id FROM supercode_cards WHERE subtask_of=?').all(row.task_id)) subscribeIn(db, t.task_id, address, 'worker');
     }
     if (sid && saved.launch_pending) event(db, row.task_id, 'session_launch_reconciled', { key: session.launch_key, pane, session_id: sid, role: saved.role }, row.id);
     return true;
@@ -1909,7 +2071,7 @@ async function synchronizeAgents(board, report) {
     .map(row=>{const session=json(row.metadata,{})?.supercode;return [session?.session_id?addressOf(session):`run:${row.id}`,row];})).values()];
   for(const row of agentRuns){
     const session=json(row.metadata,{})?.supercode;
-    if(!session?.session_id||!session.agent_org)continue;
+    if(!session?.session_id||!session.agent_org||view(board,db=>detachedSession(db,session)))continue;
     const ref=`${session.harness}:${session.session_id}`;
     // An ended run whose session the agent store already holds for another agent lost that claim when it ran: no round
     // can change an ended run, so the disagreement is history. It is said once on its card (agent_ownership_conflict)
@@ -1932,7 +2094,7 @@ async function synchronizeAgents(board, report) {
     let read=0;
     for(const row of runsAwaitingUsage(board.root,org)){
       const run=agentRuns.find(item=>String(item.id)===String(row.run_id));
-      if(!run?.ended_at||read>=5)continue;
+      if(!run?.ended_at||read>=5||view(board,db=>detachedSession(db,json(run.metadata,{})?.supercode)))continue;
       await readRunUsage(board.root,org,row,run.ended_at);read++;
     }
   }
@@ -2209,11 +2371,10 @@ async function launchPane(board, task, runId, lane, fleet, { input = null, slot
     // the working session hears updates to its card; the slot's previous session no longer does (a reviewer starting
     // leaves the implementer's, and a subtask's arc session's, subscription alone)
     const before = prev ? addressOf(prev) : null;
-    if (before && before !== session.address) db.prepare("DELETE FROM kanban_notify_subs WHERE task_id = ? AND platform = 'supercode' AND chat_id = ?").run(task.id, before);
-    subscribeIn(db, task.id, session.address, 'worker');
+    if (before && before !== session.address) db.prepare("DELETE FROM kanban_notify_subs WHERE task_id = ? AND platform = 'supercode' AND chat_id = ? AND json_extract(delivery_metadata,'$.role')='worker'").run(task.id, before);
+    replaceWorkerSubscriptions(db, task.id, session.address);
     // it sees the cards its own depends on change, and works its subtasks
     for (const p of db.prepare('SELECT parent_id FROM task_links WHERE child_id = ?').all(task.id)) subscribeIn(db, p.parent_id, session.address, 'dependency');
-    for (const t of db.prepare('SELECT task_id FROM supercode_cards WHERE subtask_of = ?').all(task.id)) subscribeIn(db, t.task_id, session.address, 'worker');
     return true;
   });
   if (!recorded) return { ...session, mode: 'finished_during_launch' };
@@ -2464,6 +2625,7 @@ async function adoptSession(board, id, who, { request = null, open = request, pr
   const native = found.pane ? null : nativeReading(await readNative(host, harness, sessionId), { session_id: sessionId, harness });
   if (found.pane ? !await panePresent(host, found.pane) : native.alive !== true) throw new Error(`${found.address} has no verified live native process or pane`);
   const beforeRun = view(board, (db) => currentRun(db, id));
+  const beforeCustody = view(board, db => JSON.stringify(detachedCard(db, id)));
   const beforeSession = beforeRun?.metadata?.supercode;
   if (beforeRun && beforeSession?.session_id !== sessionId) throw new Error(`${id} has another active run/session; end it before adopting a different identity`);
   if (beforeSession?.pane && beforeSession.pane !== found.pane && await panePresent(beforeSession.machine, beforeSession.pane)) throw new Error(`${id} still has live pane ${beforeSession.pane}; close the extra pane before rebinding ${sessionId}`);
@@ -2489,6 +2651,7 @@ async function adoptSession(board, id, who, { request = null, open = request, pr
   const stale = (db) => {
     if (request !== null && !adoptionOpenTo(db, id, request, open)) return Object.assign(new Error(`${id}'s adoption request was answered or claimed meanwhile`), { superseded: true });
     if ((getTask(db, id)?.current_run_id ?? null) !== (beforeRun?.id ?? null)) return new Error(`${id} changed runs during adoption; retry against its current run`);
+    if (JSON.stringify(detachedCard(db, id)) !== beforeCustody) return new Error(`${id} changed session custody during adoption; request adoption again`);
     return null;
   };
   if (request !== null) tx(board, (db) => {
@@ -2529,14 +2692,19 @@ async function adoptSession(board, id, who, { request = null, open = request, pr
     const expected = runSpec(entry, statusOf(db, task), task);
     if (role && role !== expected?.role) throw new Error(`${id} needs its ${expected?.role ?? 'declared'} role, not ${role}`);
     if (expected?.role === 'reviewer') {
-      const implementer = lastSession(db, id, 'worker');
+      // Independence reads history even when its implementer's custody was handed back.
+      const implementer = json(db.prepare(`SELECT metadata FROM task_runs WHERE task_id=?
+        AND COALESCE(json_extract(metadata,'$.supercode.slot'),'worker')='worker'
+        AND json_extract(metadata,'$.supercode.session_id') IS NOT NULL ORDER BY id DESC LIMIT 1`).get(id)?.metadata, {})?.supercode;
       if (implementer?.session_id === sessionId) throw new Error('a reviewer must be independent of the implementer session');
     }
+    takeSessionCustody(db, id, found.address);
     event(db, id, 'dispatch_released', { reason: 'verified adoption', session: found.address });
     // the manager's adoption is the workflow's own `adopt` verb where it declares one, sent as the manager; else its
     // dispatch start, which the platform sends for a verified adoption
     if (!beforeRun) { const verb = adoptionVerb(entry);
-      fire(db, board, entry, id, verb, { roles: [verb === 'adopt' ? 'manager' : 'platform'], payload: { lock: claimer() } }); }
+      fire(db, board, entry, id, verb, { roles: [verb === 'adopt' ? 'manager' : 'platform'], payload: { lock: claimer() },
+        noticeSession: { address: found.address, session_id: sessionId, machine: host, harness } }); }
     const runId = getTask(db, id).current_run_id;
     if (!runId) throw new Error(`${id} waits on parents that are not done`);
     // the agent joined above is the one of the run's own role; a run of another role would name the wrong agent
@@ -2546,13 +2714,23 @@ async function adoptSession(board, id, who, { request = null, open = request, pr
       ...(agent ? { agent_id: agent.identity.id, agent_org: team.org, agent_context: context ?? null,
         agent_profile_intent: { ...structuredClone(agent.intended.resolved), worker: { ...agent.intended.resolved?.worker, harness: lane.harness, model: lane.model ?? null, cwd: dir ?? task.workspace_path ?? null } } } : {}) };
     // a deferred launch was never issued: the adopted session is the run's, and no later round launches another
-    setRunSession(db, runId, { ...(currentRun(db, id)?.metadata?.supercode ?? {}), ...session, launch_deferred: false, slot: currentRun(db, id)?.metadata?.supercode?.slot ?? beforeSession?.slot ?? expected?.session ?? 'worker', close_requested: null, closed_at: null, close_confirmed_at: null, close_error: null, missing_since: null });
+    setRunSession(db, runId, { ...(currentRun(db, id)?.metadata?.supercode ?? {}), ...session, detached_at: null, detached_to: null, launch_deferred: false, slot: currentRun(db, id)?.metadata?.supercode?.slot ?? beforeSession?.slot ?? expected?.session ?? 'worker', close_requested: null, closed_at: null, close_confirmed_at: null, close_error: null, missing_since: null });
     event(db, id, 'session_adopted', { session_id: sessionId, machine: host, pane: session.pane, address: found.address, mode: 'adopt', role: currentRun(db, id)?.metadata?.supercode?.role }, runId);
-    subscribeIn(db, id, found.address, 'worker');
+    replaceWorkerSubscriptions(db, id, found.address);
     for (const p of db.prepare('SELECT parent_id FROM task_links WHERE child_id = ?').all(id)) subscribeIn(db, p.parent_id, found.address, 'dependency');
     return { ...session, run: runId, workspace: dir };
   });
-  if (agent) recordAgentRun(board.root, team.org, agent.identity.id, { session: `${harness}:${sessionId}`, machine: host, run: adopted.run });
+  if (agent) {
+    recordAgentRun(board.root, team.org, agent.identity.id, { session: `${harness}:${sessionId}`, machine: host, run: adopted.run });
+    // Teams learns whose the session is the way a launch tells it (ADR 0013, "launched or adopted"): the session's machine
+    // queues it with the same agent environment a launch carries, and binds it when Teams answers. The adoption stands
+    // either way; the card says whether the machine took it.
+    const environment = agentEnvironment(agent, { root: board.root, context: normalMachine(host) === localMachine() ? localReaderContext(team.org, agent.identity.id) ?? undefined : undefined });
+    const r = await doorOn(host, 'harness.v1.sessions.own', { session: `${harness}:${sessionId}`, environment }, { timeout: 30_000 });
+    const answer = r.code === 0 ? lastJson(r.stdout) : null;
+    tx(board, (db) => event(db, id, answer?.queued === true ? 'agent_session_queued' : 'agent_session_unqueued',
+      { session: found.address, agent: agent.identity.id, ...(answer?.queued === true ? {} : { reason: String(answer?.reason ?? (r.stderr || r.stdout || 'the machine did not answer')).slice(0, 300) }) }, adopted.run));
+  }
   return adopted;
 }
 
@@ -2565,7 +2743,7 @@ async function reconnectContinuedSessions(board, fleet, entry, report) {
   const panes = new Map();
   for (const row of rows) {
     const saved = json(row.metadata,{})?.supercode;
-    if (!saved?.session_id || saved.forgotten || saved.close_transferred_to) continue;
+    if (!saved?.session_id || saved.forgotten || saved.close_transferred_to || view(board, db => detachedCard(db, row.task_id) || detachedSession(db, saved))) continue;
     if (!saved.monitor_held && !['crashed','closed','reclaimed','failed'].includes(row.outcome)) continue;
     const live = fleet.sessions?.find(s => s.address === addressOf(saved) && s.state === 'running' && s.pane);
     if (!live) continue;
@@ -2581,7 +2759,7 @@ async function reconnectContinuedSessions(board, fleet, entry, report) {
     tx(board, db => {
       const task = getTask(db,row.task_id), scope = scopeOf(db,board,task,{params:entry.params});
       const automaticPause = scope.card.paused?.reason?.startsWith('its session ended cleanly (');
-      if (task.current_run_id || (scope.card.paused && !automaticPause) || scope.card.blocked_by.length || scope.card.archived || statusOf(db,task) !== saved.status) return;
+      if (task.detached || detachedSession(db, saved) || task.current_run_id || (scope.card.paused && !automaticPause) || scope.card.blocked_by.length || scope.card.archived || statusOf(db,task) !== saved.status) return;
       if (automaticPause) db.prepare('UPDATE supercode_cards SET paused=NULL WHERE task_id=?').run(row.task_id);
       const session = { ...saved,pane,mode:'manual-continuation',state:entry.workflow.run?.initial ?? 'active',monitor_held:false,
         prior_intervals:[...(saved.prior_intervals??[]),{ended_at:row.ended_at,outcome:row.outcome,error:row.error}],
@@ -2594,8 +2772,7 @@ async function reconnectContinuedSessions(board, fleet, entry, report) {
       db.prepare('UPDATE tasks SET current_run_id=?,claim_lock=?,claim_expires=? WHERE id=?').run(row.id,claimer(),now()+900,row.task_id);
       projectStatus(db,board,entry,row.task_id);
       event(db,row.task_id,'dispatch_released',{reason:'verified manual continuation',session:addressOf(session),incident:saved.incident??null});
-      subscribeIn(db,row.task_id,addressOf(session),'worker');
-      for (const sub of db.prepare('SELECT task_id FROM supercode_cards WHERE subtask_of=?').all(row.task_id)) subscribeIn(db,sub.task_id,addressOf(session),'worker');
+      replaceWorkerSubscriptions(db,row.task_id,addressOf(session));
       (report.continued ??= []).push([row.task_id,addressOf(session),pane]);
     });
   }
@@ -2613,18 +2790,33 @@ async function reconnectContinuedSessions(board, fleet, entry, report) {
  * A question the board waits on (`ask`) is answered by a reply to the board's address; a notice is not. Throws only
  * when the filing failed.
  */
-async function fileMail(board, to, body, key, { ask = false, wake = true, subject } = {}) {
+async function fileMail(board, to, body, key, { ask = false, wake = true, subject, eligible = null } = {}) {
   if (boardCopyOf(board)) throw copyRefusal(board, 'files no mail for sessions or managers');
-  const request = {
-    from: boardAddress(board.label), from_name: `${board.label} board`, to, id: key, wake, notice: !ask, subject: String(subject ?? String(body).split('\n')[0]).slice(0, 160),
-    body: ask ? `[A question from the ${board.label} board] ${body}` : `[Board notice from the ${board.label} board] ${body}\n\n(An automated notice from the board's dispatcher; replies to this address go nowhere.)`,
-    // the board's own Teams context (the call it files in): the sender is observed in that team, never the daemon's
-    context: current().facts.SUPERCODE_CONTEXT ?? null,
+  const perform = async () => {
+    if (eligible && !eligible()) return { filed: false, new: false, skipped: true };
+    const request = {
+      from: boardAddress(board.label), from_name: `${board.label} board`, to, id: key, wake, notice: !ask, subject: String(subject ?? String(body).split('\n')[0]).slice(0, 160),
+      body: ask ? `[A question from the ${board.label} board] ${body}` : `[Board notice from the ${board.label} board] ${body}\n\n(An automated notice from the board's dispatcher; replies to this address go nowhere.)`,
+      // the board's own Teams context (the call it files in): the sender is observed in that team, never the daemon's
+      context: current().facts.SUPERCODE_CONTEXT ?? null,
+    };
+    const r = await runtimeDoor(null, 'harness.v1.mail.file', request, { timeout: 30_000 });
+    const answer = r.code === 0 ? lastJson(r.stdout) : null;
+    if (answer?.code !== 0) throw new Error((answer?.text || (lastJson(r.stderr)?.message ?? r.stderr) || 'no answer from the mailbox\'s filing door').trim().slice(-300));
+    return { filed: true, message_id: answer.message_id, new: answer.new === true };
   };
-  const r = await runtimeDoor(null, 'harness.v1.mail.file', request, { timeout: 30_000 });
-  const answer = r.code === 0 ? lastJson(r.stdout) : null;
-  if (answer?.code !== 0) throw new Error((answer?.text || (lastJson(r.stderr)?.message ?? r.stderr) || 'no answer from the mailbox\'s filing door').trim().slice(-300));
-  return { filed: true, message_id: answer.message_id, new: answer.new === true };
+  // Dispatcher mail reserves this exact identity before entering the mailbox door.
+  if (!board.db) throw new Error('mail filing requires the board custody store');
+  try { return await sessionOperation(board, { address: to, kind: 'mail filing' }, perform); }
+  catch (error) {
+    if (!error.sessionDetached) throw error;
+    return { filed: false, new: false, detached: true };
+  }
+}
+
+/** Fleet listener mail uses the owner's ordinary filing door, including board-copy refusal and sender custody. */
+export function fileFleetNotice(root, to, body, key) {
+  return fileMail({ root, label: boardLabel(root, 'default') }, to, body, key);
 }
 
 /**
@@ -2636,9 +2828,15 @@ export async function alertManagers(root, slug, text, key) {
   try { const entry = await loadWorkflow(root); managers = Array.isArray(entry.params.managers) ? entry.params.managers.map(String) : []; } catch { /* a workflow that cannot load names nobody */ }
   const label = boardLabel(root, slug);
   let told = 0;
-  for (const to of managers) {
-    try { await fileMail({ root, label }, to, text, key, { subject: text.split('\n')[0] }); told += 1; } catch { /* a filing that failed here is said by the next alert */ }
-  }
+  if (!managers.length) return told;
+  let board;
+  try { board = openBoard(root, slug); board.label = label; }
+  catch { return told; } // an unavailable store grants no permission to wake a session
+  try {
+    for (const to of managers) {
+      try { const filed = await fileMail(board, to, text, key, { subject: text.split('\n')[0] }); if (filed.filed) told += 1; } catch { /* a filing that failed here is said by the next alert */ }
+    }
+  } finally { board.close(); }
   return told;
 }
 
@@ -2667,9 +2865,13 @@ export async function fileBoardMail(board, report, taskId = null) {
       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 filed = await fileMail(board, mail.to, mail.text, mail.message_id ?? `board-message-${first.id}`, { ask: Boolean(mail.message_id), subject });
       tx(board, db => {
+        if (filed.detached) {
+          for (const member of mail.members) event(db, member.task_id, 'board_message_passed', { event: member.id, to: mail.to, reason: 'session detached to a person' });
+          return;
+        }
         for (const member of mail.members) if (!db.prepare("SELECT 1 FROM task_events WHERE kind='board_message_sent' AND task_id=? AND json_extract(payload,'$.event')=?").get(member.task_id, member.id)) event(db, member.task_id, 'board_message_sent', { event: member.id, to: mail.to, message_id: filed.message_id, ...(mail.message_id ? { request_id: member.message_id ?? mail.message_id } : {}) });
       });
-      (report.mailed ??= []).push([first.task_id, mail.to]);
+      if (filed.filed) (report.mailed ??= []).push([first.task_id, mail.to]);
     } catch (error) {
       for (const member of mail.members) report.undelivered.push([member.task_id, mail.to, String(error.message).slice(-200)]);
     }
@@ -2710,8 +2912,7 @@ function ensureSubscriptions(board, entry) {
       const session = json(db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(t.current_run_id)?.metadata, {})?.supercode;
       const address = addressOf(session);
       if (!address || (session.slot ?? 'worker') !== 'worker') continue;
-      subscribeIn(db, t.id, address, 'worker');
-      for (const st of db.prepare('SELECT task_id FROM supercode_cards WHERE subtask_of = ?').all(t.id)) subscribeIn(db, st.task_id, address, 'worker');
+      replaceWorkerSubscriptions(db, t.id, address);
     }
   });
 }
@@ -2794,18 +2995,29 @@ async function notify(board, fleet, report, entry) {
   for (const sub of subscriptions(board.db).filter((s) => s.platform === 'supercode')) {
     await yieldToOwner();
     if (stopping) break;
+    if (view(board, db => personCustody(db, sub.chat_id))) continue;
     if (sub.delivery_metadata?.dependent_card && sub.delivery_metadata.waiting_recipient) continue;
     const role = ['worker', 'dependency', 'manager'].includes(sub.delivery_metadata?.role) ? sub.delivery_metadata.role : 'creator';
+    // Native notices wait with their cursor intact until their own door proves
+    // liveness. A failed fleet reading supplies no permission to file them.
+    // Agent, board and operator mailboxes route independently of a native PID.
+    if (sessionAt(sub.chat_id)) {
+      const alive = fleet.ok ? await subscriberAlive(fleet, sub.chat_id) : null;
+      if (alive !== true) {
+        report.undelivered.push([sub.task_id, sub.chat_id, alive === false ? 'its session is not running; its notices wait' : 'its liveness could not be read; its notices wait until it can be']);
+        continue;
+      }
+    }
     // a session the fleet does not list this pass is told next pass: 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
     // has its subscription moved when the new one starts
     const ended = recordedEnded(record, sub.chat_id);
-    if ((role !== 'creator' || ended) && fleet.ok) {
+    if (!sessionAt(sub.chat_id) && (role !== 'creator' || ended) && fleet.ok) {
       const alive = await subscriberAlive(fleet, sub.chat_id);
       if (alive === false) continue;
       // unknown is not absent: its notices wait, and the wait is said, until its liveness can be read
       if (alive === null) { report.undelivered.push([sub.task_id, sub.chat_id, 'its liveness could not be read; its notices wait until it can be']); continue; }
-    } else if (ended) continue; // no fleet reading: nothing is filed unread to a session recorded as ended
+    } else if (!sessionAt(sub.chat_id) && ended) continue; // native sessions already required a current live observation
     const kinds = heardBy(entry, role);
     if (!kinds.length) continue;
     // The retained cursor resumes the next page; one native read never materializes the whole unread history.
@@ -2847,11 +3059,21 @@ 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) {
+          // A verified binding may have replaced this audience while liveness
+          // or an earlier filing awaited a door. Re-read before every filing.
+          const currentSub = board.db.prepare(`SELECT last_event_id,delivery_metadata FROM kanban_notify_subs ${where}`).get(...identity);
+          const currentRole = json(currentSub?.delivery_metadata, {})?.role ?? 'creator';
+          if (!currentSub || currentRole !== role) break;
+          if (Number(currentSub.last_event_id) >= ev.id) { cursor = Math.max(cursor, Number(currentSub.last_event_id)); continue; }
           const body = ['worker', 'dependency'].includes(role) ? identifyNotice(ev, text) : text;
           // filed under its fixed key: a second pass filing the same notice files nothing new
-          const filed = await fileMail(board, sub.chat_id, body, `board-${sub.task_id}-${ev.id}-${sub.chat_id.slice(-12)}`, { wake, subject: `${ev.kind.replaceAll('_', ' ')} · run ${ev.run_id ?? 'none'} · event ${ev.id} · ${task?.title || sub.task_id}` });
+          const filed = await fileMail(board, sub.chat_id, body, `board-${sub.task_id}-${ev.id}-${sub.chat_id.slice(-12)}`, { wake, subject: `${ev.kind.replaceAll('_', ' ')} · run ${ev.run_id ?? 'none'} · event ${ev.id} · ${task?.title || sub.task_id}`,
+            eligible: () => view(board, db => {
+              const currentSub = db.prepare(`SELECT last_event_id FROM kanban_notify_subs ${where}`).get(...identity);
+              return Boolean(currentSub) && Number(currentSub.last_event_id) < ev.id;
+            }) });
           if (filed.new) tx(board, (db) => event(db, sub.task_id, 'notice_filed', { source_event: ev.id, kind: ev.kind, address: sub.chat_id, message_id: filed.message_id, wake }));
-          report.notified.push([sub.task_id, ev.kind, sub.chat_id]);
+          if (filed.filed) report.notified.push([sub.task_id, ev.kind, sub.chat_id]);
         }
         cursor = ev.id;
         forward(cursor);
@@ -3163,7 +3385,7 @@ async function activatePullRequestReviews(board, entry, report, effects, { only
       if (!task) return false;
       // a status the platform cannot request a review from needs no scope built to say so
       if (!transitionsFor(entry.workflow, statusOf(db, task), 'request_review').some(t => !t.by || t.by.includes('platform'))) return false;
-      const scope = scopeOf(db, board, task, { params: entry.params });
+      const scope = scopeOf(db, board, task, { params: entry.params, lazy: true });
       if (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));