@volter/supercode-orchestrator 0.5.110 → 0.5.112

package/agents.mjs

@@ -174,6 +174,31 @@ export function localAgentRecord(root,org,id){
 export function localAgentSessions(root,org,id){
   const db=store(root);try{return db.prepare('SELECT session_ref AS session,machine,ended_at,end_reason FROM agent_runs WHERE org=? AND agent_id=? ORDER BY rowid DESC LIMIT 200').all(org,id);}finally{db.close();}
 }
+/** Retained starter receipts for this home's sessions, including explicit forks.
+ * Ended owners remain in the join so a live child keeps its original starter. */
+export function localSessionDelegations(root, localMachine) {
+  const db = store(root);
+  try {
+    const rows = db.prepare(`SELECT r.*, json_extract(i.declaration_json,'$.starterSession') AS declared_starter
+      FROM agent_runs r LEFT JOIN agent_intents i ON i.org=r.org AND i.id=r.agent_id`).all();
+    const addresses = new Map();
+    const address = row => row.session_ref.startsWith('sc:') ? row.session_ref
+      : /^(claude-code|codex):[^:]+$/.test(row.session_ref) ? `sc:${row.machine ?? localMachine}:${row.session_ref}` : null;
+    for (const row of rows) {
+      const key = `${row.org}|${row.session_ref}`, value = address(row);
+      if (value) addresses.set(key, value);
+    }
+    for (const alias of db.prepare('SELECT * FROM agent_runtime_sessions').all()) {
+      const value = addresses.get(`${alias.org}|${alias.session_ref}`);
+      if (value) addresses.set(`${alias.org}|${alias.runtime_ref}`, value);
+    }
+    return rows.filter(row => row.ended_at == null).map(row => {
+      const ref = row.starter_session ?? row.declared_starter;
+      return { session: address(row), starter: typeof ref === 'string' && ref.startsWith('sc:')
+        ? ref : addresses.get(`${row.org}|${ref}`) ?? null };
+    }).filter(edge => edge.session && edge.starter);
+  } finally { db.close(); }
+}
 /** Move identities minted before any Teams context into the Org that is now selected, keeping their ids. */
 function adoptLocalOrg(root,scope){
   const db=store(root);

package/board/ci.mjs

@@ -4,7 +4,7 @@ import { execFile } from 'node:child_process';
 import { readFileSync, realpathSync, writeFileSync, renameSync, statSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
 import { createHash } from 'node:crypto';
-import { branchCheckouts, checkoutOf, isLocalWorkspace, resolveWorkspace } from './workspace.mjs';
+import { branchCheckouts, checkoutOf, isLocalWorkspace, resolveWorkspace, plainWorkspace } from './workspace.mjs';
 import { noteStep } from '@volter/supercode-harness-sdk/slow-log';
 
 // GitHub is read through its REST API with Node's own fetch, in this process and awaited (never a child the caller
@@ -134,16 +134,50 @@ async function repositoryWorkspace(board, id) {
   const workspace = task?.workspace_kind === 'scratch' ? parent : task;
   if (!workspace || workspace.workspace_kind === 'scratch') return null;
   const here = isLocalWorkspace(workspace);
-  if (workspace.workspace_anchor) return { ...(await resolveWorkspace(workspace, false)), here };
+  if (workspace.workspace_anchor) {
+    // A portable remote declaration supplies the source identity. Reviewing
+    // its pushed head does not require that machine to keep the old checkout.
+    if (!here) {
+      const declared = plainWorkspace(workspace.workspace_kind, workspace.workspace_anchor, workspace.branch_name);
+      if (declared) return { ...declared, here: false };
+    }
+    const resolved = await resolveWorkspace(workspace, false);
+    // Resolution without create names a solo worktree even before it exists on
+    // this machine. Its portable repository and branch still identify the
+    // pushed PR. Only an actual directory can supply local source evidence.
+    return { ...resolved, here: here && checkoutPresent(resolved.path) };
+  }
   return workspace.workspace_path ? { path: workspace.workspace_path, here } : null;
 }
 
 const pullRequestLists = new Map();
+const mergedPullRequestLists = new Map();
+
+/** Historical work can already be merged when an outage prevented the board's
+ * review request. Read only the arc's declared branch, never all closed PRs. */
+async function mergedBranchPullRequests(repository, branch) {
+  const key = `${repository}:${branch}`;
+  let list = mergedPullRequestLists.get(key);
+  if (!list || Date.now() - list.at >= 60_000) {
+    const head = encodeURIComponent(`${repository.split('/')[0]}:${branch}`);
+    const items = (await github(`/repos/${repository}/pulls?state=closed&head=${head}&per_page=100`, true))
+      .filter(p => p.merged_at).map(p => pullRequest(repository, p));
+    if (mergedPullRequestLists.size >= 64) mergedPullRequestLists.delete(mergedPullRequestLists.keys().next().value);
+    list = { at: Date.now(), items }; mergedPullRequestLists.set(key, list);
+  }
+  return list.items;
+}
 
 async function branchCheckout(board, id, repository, branch) {
   const task = board.db.prepare('SELECT c.machine FROM tasks t LEFT JOIN supercode_cards c ON c.task_id=t.id WHERE t.id=?').get(id);
   if (!isLocalWorkspace(task ?? {})) return null;
-  try { return (await checkoutOf(task?.machine, repository, branch))?.path ?? null; } catch { return null; }
+  try { const path = (await checkoutOf(task?.machine, repository, branch))?.path; return checkoutPresent(path) ? path : null; } catch { return null; }
+}
+
+function checkoutPresent(path) {
+  if (!path) return false;
+  try { return statSync(path).isDirectory(); }
+  catch (error) { if (['ENOENT', 'ENOTDIR'].includes(error.code)) return false; throw error; }
 }
 
 /** The sibling checkouts an arc registered: each subtask (and the card itself) that declares a repository
@@ -174,7 +208,7 @@ export function declaredWorkBranches(db, id) {
   return [...new Set([...declared, ...reviewed].filter(Boolean))];
 }
 
-/** Every opened PR of the arc, each proposed to its repository's default branch: an open PR whose head is the card's
+/** Every opened PR of the arc, plus an unjudged merged PR on its declared branch, each proposed to its repository's default branch: an open PR whose head is the card's
  *  work branch in the card's own repository, a `wt/<card id>` branch in any repository this machine keeps a checkout
  *  of, or a sibling checkout the arc registered (`registeredBranches`). The repository's default branch, declared or
  *  checked out (or no branch), is not a work branch: such a card's PRs are only its `wt/<card>` and registered ones, and with none it
@@ -195,20 +229,39 @@ export async function openReviewPullRequests(board, id) {
     // Discovery is shared per repository for one minute; each selected PR/head is re-read before it authorizes a move.
     let list = pullRequestLists.get(repository);
     if (!list || Date.now() - list.at >= 60_000) {
-      let items = [];
-      try { items = (await github(`/repos/${repository}/pulls?state=open&per_page=100`, true)).map((p) => pullRequest(repository, p)); }
+      let items = [], defaultBranch = null;
+      try {
+        items = (await github(`/repos/${repository}/pulls?state=open&per_page=100`, true)).map((p) => pullRequest(repository, p));
+        defaultBranch = items.find(pr => pr.defaultBranch)?.defaultBranch ?? (await github(`/repos/${repository}`)).default_branch;
+      }
       catch (error) { if (repository === ownRepository || registered.some((r) => r.repository === repository)) throw error; } // another repository unreachable here is not this arc's
-      list = { at: Date.now(), items };
+      list = { at: Date.now(), items, defaultBranch };
       if (pullRequestLists.size >= 64) pullRequestLists.delete(pullRequestLists.keys().next().value);
       pullRequestLists.set(repository, list);
     }
     // The repository's default branch is not a work branch, declared or checked out (a card working in a `dir` on main).
     if (repository === ownRepository && branch) {
-      const defaultBranch = list.items.find((pr) => pr.defaultBranch)?.defaultBranch ?? (await (async () => { try { return (await run('git', ['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'], own.path)).replace(/^origin\//, ''); } catch { return null; } })());
-      if (branch === defaultBranch) branch = null;
+      if (branch === list.defaultBranch) branch = null;
     }
     // a draft is not handed over yet: its review starts when it is marked ready; a PR to another base (main→prod) is a release, not the arc's work
     for (const pr of list.items) if (!pr.isCrossRepository && !pr.isDraft && pr.baseRefName === pr.defaultBranch && mine(repository, pr.headRefName)) prs.push({ url: pr.url, head: pr.headRefOid });
+    // A manual review and merge during a dispatcher outage may predate any
+    // board request. The source-review door already accepts merged heads; make
+    // them discoverable so the ordinary independent verdict can be retained.
+    // An open PR (including a draft or wrong base) on that branch takes priority.
+    const historical = [...new Set([
+      ...(repository === ownRepository ? branch ? [branch] : [`wt/${id}`, `wt/${id.replace(/^t_/, 't-')}`] : []),
+      ...registered.filter(r => r.repository === repository).map(r => r.branch),
+    ])];
+    for (const headBranch of historical) {
+      if (headBranch === list.defaultBranch) continue;
+      if (list.items.some(pr => pr.headRefName === headBranch)) continue;
+      for (const pr of await mergedBranchPullRequests(repository, headBranch)) {
+        if (!pr.isCrossRepository && pr.headRefName === headBranch && pr.headRefName !== pr.defaultBranch
+          && pr.baseRefName === pr.defaultBranch && !judgedHead(board, id, pr.headRefOid)
+          && !prs.some(known => known.url === pr.url)) prs.push({ url: pr.url, head: pr.headRefOid });
+      }
+    }
   }
   if (!prs.length) return branch ? null : { waits: `the card has no work branch (${task?.branch_name ? `it declares ${task.branch_name}, its repository's default` : current ? `its checkout ${own.path} is on ${current}, its repository's default` : `its checkout ${own.path} is on no branch`}): give it one with --branch, or open its PR from a wt/${id} branch` };
   return { pr: prs.map((p) => p.url), pr_head: prs.map((p) => p.head), branch };

package/board/cli.mjs

@@ -1701,6 +1701,7 @@ async function serve(root, args = {}) {
     const refused = named?.refused ?? null;
     log(refusal ? `board events: not published; the machine daemon did not take this home: ${refusal}`
       : refused ? `board events: registered, but the team refused this machine's credential (${refused.status}); nothing is published until it is re-enrolled`
+      : named?.published === false ? `board ownership: registered locally; this machine has no team connector to publish events`
       : `board events: this home is published by the machine's connector`); }
   log('dispatch wakes on board writes, document edits and board mail; the interval sweep reads each machine\'s own door');
   const stuck = {};

package/board/dispatch.mjs

@@ -20,8 +20,11 @@ import { machineCall } from './doors.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, failedObservation, surfaceIncident, auditEndedRuns, originOf } from './incidents.mjs';
+import { monitorsRuns, recoversRuns, retainRecovery, failedObservation, surfaceIncident, auditEndedRuns, originOf } from './incidents.mjs';
 import { readMachineFleet } from './machine-fleet.mjs';
+import { delegatedWork, idleInterval } from './session-work.mjs';
+import { localSessionDelegations } from '../agents.mjs';
+import { creatorOf, sessionProgress } from './workflow.mjs';
 import { boardLabel, boardName } from '@volter/teams/board-name';
 let fleetRoot = null;
 import { inspectCompletionEvidence, noCodeChange, openReviewPullRequests, reviewDue, withCompletionEvidence, reviewCandidate, workflowRevision, retainWorkflowTick } from './ci.mjs';
@@ -376,6 +379,7 @@ async function supervise(board, fleet, settings, report, entry, effects) {
             if (bucket) report[bucket].push(id);
             return;
           }
+          if (recoversRuns(entry) && failedObservation(name)) retainRecovery(db, id, name, payload);
           const r = fire(db, board, entry, id, name, { roles: ['platform'], payload });
           staged.push(...r.effects);
           if (bucket) report[bucket].push(id);
@@ -778,6 +782,7 @@ function launchFailed(board, entry, id, error, payload) {
   return tx(board, (db) => {
     if (!runCurrent(db, id, error.launchRun)) return null;
     if (monitorsRuns(entry)) { surfaceIncident(db, board, entry, id, 'spawn_failed', payload, error.launchRun); return { effects: [] }; }
+    if (recoversRuns(entry)) retainRecovery(db, id, 'spawn_failed', payload, error.launchRun);
     return fire(db, board, entry, id, 'spawn_failed', { roles: ['platform'], payload });
   });
 }
@@ -1103,7 +1108,7 @@ export async function closeRequested(board, report, { taskId = null, caller = nu
   }
 }
 
-/** Quiet time is independent of dispatch cadence and the harness's busy label.
+/** Native idle intervals are independent of dispatch cadence and transcript writes.
  * Keep bounded readings on the run so an ordinary quiet stretch can be reviewed later. */
 async function observeIdle(board, fleet, settings, report, entry, effects) {
   if (!fleet.ok) return;
@@ -1116,11 +1121,28 @@ async function observeIdle(board, fleet, settings, report, entry, effects) {
     return Number(rows?.find((row) => row.locator?.session_id === session.session_id)?.updated_at_ms) || null;
   };
   const managers = [].concat(entry.params.managers ?? []).filter(Boolean);
+  const delegations = localSessionDelegations(board.root, localMachine());
+  const delegatedReadings = [...fleet.sessions];
+  // Forks and concurrent sessions need not have a pane. Read only the exact
+  // native identities this home's starter receipts name, before any write.
+  for (const { session: address } of delegations) {
+    if (delegatedReadings.some(row => row.address === address)) continue;
+    const match = /^sc:([^:]+):(claude-code|codex):([^:]+)$/.exec(address);
+    if (!match) continue;
+    const [, machine, harness, session_id] = match;
+    const child = { machine, harness, session_id, surface: 'native' };
+    await readBefore(fleet, child);
+    try {
+      const { row } = nativeReading(nativeSessions(machine, harness, session_id), child);
+      if (row?.activity) delegatedReadings.push({ address, state: row.activity.presence, turn: row.activity.turn });
+    } catch { /* an unread child is never called working */ }
+  }
   const running = board.db.prepare(entry.workflow.run ? "SELECT id FROM tasks WHERE current_run_id IS NOT NULL" : "SELECT id FROM tasks WHERE status = 'running'").all();
   // every running card a session is on: a session waiting on its user is told once, naming them all
   const cardsOf = new Map();
   for (const { id } of running) {
-    const session = currentRun(board.db, id)?.metadata?.supercode; await readBefore(fleet, session); if (session?.session_id) updatedAt(session);
+    const session = currentRun(board.db, id)?.metadata?.supercode; await readBefore(fleet, session);
+    await refreshCardInputs(board, id, { commits: true });
     if (addressOf(session)) cardsOf.set(addressOf(session), [...(cardsOf.get(addressOf(session)) ?? []), id]);
   }
   for (const { id } of running) {
@@ -1140,6 +1162,10 @@ async function observeIdle(board, fleet, settings, report, entry, effects) {
       const live = fleet.sessions.find((x) => x.address === addressOf(session)) ?? (nativeRow ? { address: addressOf(session), turn: nativeRow.activity?.turn ?? null, waiting_for: nativeRow.activity?.evidence?.waiting_for ?? null,
         turn_source: nativeRow.activity?.evidence?.source ?? null, turn_since_ms: nativeRow.activity?.evidence?.native_state_since_ms ?? null } : undefined);
       const observedAt = now();
+      const progress = sessionProgress(db, task);
+      const priorProgress = session.work_progress;
+      const worked = Boolean(priorProgress) && (progress.event > priorProgress.event || progress.commit > priorProgress.commit);
+      if (!priorProgress || worked) setRunSession(db, runRow.id, { work_progress: progress, ...(worked ? { goal_turns: 0 } : {}) });
       const lastAtMs = Number(live?.last_message_at_ms) || updatedAt(session);
       const lastAt = Math.floor(Number(lastAtMs) / 1000);
       const reading = {
@@ -1147,12 +1173,13 @@ async function observeIdle(board, fleet, settings, report, entry, effects) {
         last_message_at: lastAt > 0 ? lastAt : null,
         last_message_at_ms: lastAt > 0 ? Number(lastAtMs) : null,
         status: live?.status ?? null, turn: live?.turn ?? null, quiet_seconds: lastAt > 0 ? observedAt - lastAt : null,
-        threshold_seconds: settings.idleQuiet, turns_before: Number(session.goal_turns ?? 0),
+        threshold_seconds: settings.idleQuiet, turns_before: worked ? 0 : Number(session.goal_turns ?? 0),
+        progress,
       };
       const retain = (decision, extra = {}) => {
         // A reading that decides nothing is kept once per state: rewriting it each pass would wake the next pass.
         const prior = session.idle_observation;
-        if (!['dispatched', 'dispatch_failed', 'waiting_on_user'].includes(decision) && prior?.decision === decision && prior.last_message_at_ms === reading.last_message_at_ms && prior.status === reading.status) return prior;
+        if (!['dispatched', 'dispatch_failed', 'waiting_on_user'].includes(decision) && prior?.decision === decision && prior.turn === reading.turn && prior.idle_since === reading.idle_since && JSON.stringify(prior.delegated_sessions) === JSON.stringify(extra.delegated_sessions) && prior.status === reading.status && !worked) return prior;
         const observation = { ...reading, decision, turns_after: reading.turns_before, ...extra };
         const patch = { idle_observation: observation };
         if (decision === 'below_threshold') patch.idle_below_threshold = observation;
@@ -1160,11 +1187,20 @@ async function observeIdle(board, fleet, settings, report, entry, effects) {
         setRunSession(db, runRow.id, patch);
         return observation;
       };
-      // A session waiting on its user (a question, a permission prompt) or working without writing past the quiet
-      // threshold is told to the manager, with only what was read of it. Whether a harness's own state is a question
+      // A session waiting on its user is told to the manager, with only what was read of it. Whether a harness's own state is a question
       // put to its user is its harness's to say (`needs_input`); what it waits for is carried as it was read.
       const address = addressOf(session);
       const asked = live?.turn === 'needs_input';
+      const edges = [...delegations, ...fleet.sessions.filter(row => row.starter_session?.startsWith('sc:')).map(row => ({ starter: row.starter_session, session: row.address }))];
+      for (const child of db.prepare('SELECT id,current_run_id FROM tasks WHERE current_run_id IS NOT NULL').all()) {
+        const starter = creatorOf(db, child.id)?.replace(/^session:/, '');
+        const target = addressOf(currentRun(db, child.id)?.metadata?.supercode);
+        if (starter?.startsWith('sc:') && target) edges.push({ starter, session: target });
+      }
+      const delegated = delegatedWork(address, edges, delegatedReadings);
+      if (live?.turn === 'idle' || asked || live?.turn === 'working' || delegated.length) {
+        if (session.unknown_since != null || session.unknown_notice) setRunSession(db, runRow.id, { unknown_since: null, unknown_notice: null });
+      }
       // a reading that shows the session no longer waiting ends the prompt; a round that did not read it does not
       if (session.held_notice && live && !asked) setRunSession(db, runRow.id, { held_notice: null });
       if (asked) {
@@ -1186,20 +1222,41 @@ async function observeIdle(board, fleet, settings, report, entry, effects) {
         (report.held ??= []).push([id, 'waiting_on_user', address]);
         return;
       }
-      if (live?.turn === 'working' && lastAt > 0 && observedAt - lastAt >= settings.idleQuiet) {
-        if (session.idle_observation?.decision === 'working_silent' && session.idle_observation.last_message_at_ms === reading.last_message_at_ms) return;
-        const observation = retain('working_silent');
-        event(db, id, 'session_held', observation, runRow.id);
+      if (live?.turn === 'working' || delegated.length) {
+        if (session.idle_since != null) setRunSession(db, runRow.id, { idle_since: null });
+        retain(delegated.length ? 'delegated_work' : 'working', { delegated_sessions: delegated });
+        return;
+      }
+      // An unread or unknown turn does not prove idle, but cannot remain silent
+      // indefinitely. Bound the observed interval independently of transcript
+      // writes, and tell the manager once with the native facts we actually read.
+      if (live?.turn !== 'idle') {
+        const since = Number(session.unknown_since ?? observedAt);
+        reading.unknown_since = since;
+        reading.quiet_seconds = Math.max(0, observedAt - since);
+        if (session.unknown_since !== since) setRunSession(db, runRow.id, { unknown_since: since });
+        if (reading.quiet_seconds < settings.idleQuiet) { retain('turn_unknown'); return; }
+        if (session.unknown_notice) return;
+        const key = [address, live?.turn_since_ms ?? 'unknown'].join('|');
+        const told = db.prepare('SELECT r.metadata FROM task_runs r WHERE r.id != ? AND (r.ended_at IS NULL OR EXISTS (SELECT 1 FROM tasks t WHERE t.current_run_id = r.id))').all(runRow.id)
+          .some(r => json(r.metadata, {})?.supercode?.unknown_notice?.key === key);
+        setRunSession(db, runRow.id, { unknown_notice: { key, at: observedAt, since } });
+        const observation = retain('turn_unknown_reported', { waiting_for: live?.waiting_for ?? null, turn_source: live?.turn_source ?? null, since_ms: live?.turn_since_ms ?? null });
+        event(db, id, 'session_turn_unknown', observation, runRow.id);
         const to = managers[0] ?? null;
-        if (to) event(db, id, 'board_message', { to, text: `${id}: its session ${address} has reported working without writing anything for ${Math.round((observedAt - lastAt) / 60)} min.` }, null);
-        (report.held ??= []).push([id, 'working_silent', address]);
+        if (to && !told) {
+          const others = (cardsOf.get(address) ?? []).filter(card => card !== id);
+          event(db, id, 'board_message', { to, text: `${id}: its session ${address} has no known native turn after ${reading.quiet_seconds}s of observation (threshold ${settings.idleQuiet}s). Read status=${JSON.stringify(reading.status)}, turn=${JSON.stringify(reading.turn)}, source=${JSON.stringify(live?.turn_source ?? null)}, waiting_for=${JSON.stringify(live?.waiting_for ?? null)}, native_since_ms=${JSON.stringify(live?.turn_since_ms ?? null)}, last_message_at_ms=${JSON.stringify(reading.last_message_at_ms)}.${others.length ? ` It is also on ${others.join(', ')}.` : ''} Its liveness needs a decision; no idle state or permission answer was inferred.` }, null);
+        }
+        (report.held ??= []).push([id, 'turn_unknown', address]);
         return;
       }
-      // No timestamp is no reading, and no reading gives no verdict.
-      if (!(lastAt > 0)) { retain('no_timestamp'); return; }
+      // A native idle receipt also works without a transcript timestamp.
+      const interval = idleInterval(session, live, observedAt);
+      reading.idle_since = interval.since; reading.quiet_seconds = interval.quiet;
+      if (session.idle_since !== interval.since) setRunSession(db, runRow.id, { idle_since: interval.since });
       if (reading.quiet_seconds < settings.idleQuiet) { retain('below_threshold'); return; }
       if (session.goal_nudged_at && observedAt - session.goal_nudged_at < settings.idleQuiet) { retain('nudge_cooldown'); return; }
-      const worked = Boolean(session.goal_nudged_at) && lastAt > session.goal_nudged_at;
       try {
         const where = whereOf(board, task);
         // the ask names what the session may do, as its run's prompt did
@@ -1589,6 +1646,7 @@ async function reconcileLaunches(board, fleet, report, entry, effects, settings,
           setRunSession(db, row.id, { launch_pending: false, ...(s.mode === 'fresh' ? { forgotten: true } : {}) });
           const payload = { error: `launch ${s.launch_key} ended before session binding` };
           if (monitorsRuns(entry)) { surfaceIncident(db, board, entry, row.task_id, 'spawn_failed', payload); return { effects: [] }; }
+          if (recoversRuns(entry)) retainRecovery(db, row.task_id, 'spawn_failed', payload);
           return fire(db, board, entry, row.task_id, 'spawn_failed', { roles: ['platform'], payload });
         });
         if (moved) effects.push(...moved.effects);
@@ -1711,7 +1769,7 @@ async function launchPane(board, task, runId, lane, fleet, { input = null, slot
     if (paneLive && (prev.closed_at || prev.close_requested || prev.forgotten)) throw new Error(`session ${prev.session_id} still has live pane ${prev.pane}; cannot resume or replace it`);
     if (!prev.closed_at && !prev.close_requested && (prev.pane ? paneLive : sessionAlive(fleet, prev))) {
       // the session is kept; the heartbeat's count belongs to the run that ended, so the new run starts it again
-      const { missing_since: _m, goal_turns: _t, goal_nudged_at: _n, idle_observation: _io, idle_below_threshold: _ib, idle_eligible: _ie, close_requested: _q, closed_at: _c, close_confirmed_at: _cc, close_error: _ce, close_attempts: _ca, close_attempted_at: _ct, monitor_held: _mh, ...kept } = prev;
+      const { missing_since: _m, goal_turns: _t, goal_nudged_at: _n, idle_since: _is, unknown_since: _us, unknown_notice: _un, work_progress: _wp, idle_observation: _io, idle_below_threshold: _ib, idle_eligible: _ie, close_requested: _q, closed_at: _c, close_confirmed_at: _cc, close_error: _ce, close_attempts: _ca, close_attempted_at: _ct, monitor_held: _mh, ...kept } = prev;
       session = { ...kept, mode: 'adopt', launched_at: now(), seen_at: now() };
       // a kept session is told what this run is for (its card came back to it, with what happened since), only while
       // this run is still the card's current one (its pane and native reads were awaited)
@@ -2134,7 +2192,7 @@ async function reconnectContinuedSessions(board, fleet, entry, report) {
 async function fileMail(board, to, body, key, { ask = false, wake = true, subject } = {}) {
   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, subject: String(subject ?? String(body).split('\n')[0]).slice(0, 160),
+    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,

package/board/incidents.mjs

@@ -1,14 +1,33 @@
 // Service supervision retains evidence; only a manager/creator act releases dispatch.
 import { event, json, now } from './store.mjs';
-import { statusOf, creatorOf } from './workflow.mjs';
+import { statusOf, creatorOf, requestSessionClose } from './workflow.mjs';
 
-export const monitorsRuns = entry => entry?.params?.run_failure_policy !== 'retry';
+export const recoversRuns = entry => entry?.params?.run_failure_policy === 'recover';
+export const monitorsRuns = entry => !recoversRuns(entry) && entry?.params?.run_failure_policy !== 'retry';
 // Where a thrown failure came from: its first frames, with paths from the package root, kept as the incident's
 // evidence so a bare message ("database is locked") still names the statement's caller.
 export const originOf = (error) => String(error?.stack ?? '').split('\n').filter((line) => /^\s+at /.test(line)).slice(0, 5)
   .map((line) => line.trim().replace(/\((?:file:\/\/)?[^()]*\/(orchestrator\/|teams\/|volter-teams\/)/, '($1'));
 export const failedObservation = name => ['exited', 'session_closed', 'session_lost', 'spawn_failed', 'orphaned', 'timed_out', 'stale'].includes(name);
 
+/** Recovery is an explicit workflow policy. Keep the failure before the
+ * workflow ends its run; neither discard the incident nor hold dispatch. */
+export function retainRecovery(db, id, name, evidence = {}, runId = null) {
+  const task = db.prepare('SELECT current_run_id FROM tasks WHERE id=?').get(id);
+  runId ??= task?.current_run_id;
+  const row = db.prepare('SELECT * FROM task_runs WHERE id=? AND task_id=?').get(runId, id);
+  if (!row || row.ended_at != null) return;
+  if (db.prepare("SELECT 1 FROM task_events WHERE task_id=? AND run_id=? AND kind='run_incident'").get(id, runId)) return;
+  const session = json(row.metadata, {})?.supercode ?? {};
+  const reason = evidence.error ?? `run ${runId} needs continuation (${name})`;
+  const payload = { observation: name, run: runId, reason, policy: 'recover',
+    session: session.session_id ?? null, machine: session.machine ?? null, pane: session.pane ?? null,
+    launch_key: session.launch_key ?? null, pid: session.pid ?? null, evidence };
+  event(db, id, 'run_incident', payload, runId);
+  db.prepare('INSERT INTO task_comments(task_id,author,body,created_at) VALUES (?,?,?,?)')
+    .run(id, 'dispatcher', `Run #${runId}: ${reason}. The workflow will continue this card through its native session door. Evidence: ${JSON.stringify(payload)}`, now());
+}
+
 export function surfaceIncident(db, board, entry, id, name, evidence = {}, runId = null) {
   const task = db.prepare('SELECT * FROM tasks WHERE id=?').get(id);
   runId ??= task?.current_run_id;
@@ -42,6 +61,24 @@ export function surfaceIncident(db, board, entry, id, name, evidence = {}, runId
 
 /** Older ended runs are audited before eligibility: a completed run is not permission to repeat. */
 export function auditEndedRuns(db, board, entry) {
+  if (recoversRuns(entry)) {
+    // Changing the explicit policy releases only incident holds. A person's
+    // pause, dependency, dispatch switch or unrelated hold remains their act.
+    for (const task of db.prepare(`SELECT t.*,r.id run_id,r.metadata run_metadata FROM tasks t JOIN task_runs r
+      ON r.id=(SELECT MAX(id) FROM task_runs WHERE task_id=t.id)
+      WHERE t.current_run_id IS NULL AND r.ended_at IS NOT NULL AND t.status IN ('running','review')`).all()) {
+      const session = json(task.run_metadata, {})?.supercode;
+      if (!session?.monitor_held) continue;
+      const state = db.prepare('SELECT paused,blocked_by,archived FROM supercode_cards WHERE task_id=?').get(task.id);
+      if (json(state?.paused, null) || json(state?.blocked_by, [])?.length || state?.archived) continue;
+      const last = db.prepare("SELECT kind,payload FROM task_events WHERE task_id=? AND kind IN ('dispatch_held','dispatch_released','session_adopted') ORDER BY id DESC LIMIT 1").get(task.id);
+      const hold = json(last?.payload, {});
+      if (last?.kind !== 'dispatch_held' || hold.run !== task.run_id || hold.incident !== session.incident) continue;
+      requestSessionClose(db, task.id, { runId: task.run_id });
+      event(db, task.id, 'dispatch_released', { reason: 'workflow explicitly selected recovery', incident: session.incident, ended_run: task.run_id });
+    }
+    return;
+  }
   if (!monitorsRuns(entry)) return;
   for (const task of db.prepare(`SELECT t.*,r.id run_id,r.outcome,r.error,r.metadata run_metadata FROM tasks t JOIN task_runs r ON r.id=(SELECT MAX(id) FROM task_runs WHERE task_id=t.id)
     WHERE t.current_run_id IS NULL AND r.ended_at IS NOT NULL AND t.status NOT IN ('done','archived')`).all()) {

package/board/machine-fleet.mjs

@@ -66,6 +66,7 @@ export async function readMachineFleet(machines, local) {
       native.set(address, { alive: running ? true : null, states: [running ? true : null] });
       if (running) alive.add(address);
       sessions.push({ address, machine: row.machine, harness: activity.harness, session_id: activity.session_id, pane: pane.pane, name: pane.title ?? pane.label ?? null,
+        starter_session: pane.starter_session ?? null,
         state: running ? 'running' : 'unknown', turn: activity.turn ?? null, native_state: activity.evidence?.native_state ?? null,
         // what a session that needs input says it waits for and since when, where its harness publishes them
         waiting_for: activity.evidence?.waiting_for ?? null, turn_source: activity.evidence?.source ?? null, turn_since_ms: activity.evidence?.native_state_since_ms ?? null });

package/board/session-work.mjs

@@ -0,0 +1,30 @@
+// The dispatcher observes native turns and explicit session delegation. A
+// transcript write, a reminder reply, or sharing a profile proves no progress.
+
+/** Sessions this session started, transitively. Cycles never imply work. */
+export function delegatedWork(address, edges, sessions) {
+  const reached = new Set([address]), pending = [address], working = [];
+  const byStarter = new Map();
+  for (const { starter, session } of edges) {
+    if (!starter || !session || starter === session) continue;
+    const children = byStarter.get(starter) ?? [];
+    children.push(session); byStarter.set(starter, children);
+  }
+  while (pending.length) {
+    for (const child of byStarter.get(pending.pop()) ?? []) {
+      if (reached.has(child)) continue;
+      reached.add(child); pending.push(child);
+      const reading = sessions.find(row => row.address === child);
+      if (reading?.state === 'running' && reading.turn === 'working') working.push(child);
+    }
+  }
+  return working;
+}
+
+/** Idle time belongs to a native idle interval, never to transcript freshness. */
+export function idleInterval(session, live, observedAt) {
+  const nativeSince = Number(live?.turn_since_ms);
+  const since = nativeSince > 0 && nativeSince <= observedAt * 1000
+    ? Math.floor(nativeSince / 1000) : Number(session.idle_since ?? observedAt);
+  return { since, quiet: Math.max(0, observedAt - since) };
+}

package/board/workflow.mjs

@@ -246,6 +246,14 @@ async function observeLastCommit(path, id, branches = []) {
 }
 
 function lastCommitAt(path, id) { return path ? commitTimes.get(`${path}:${id}`)?.value ?? null : null; }
+/** Material card work. Comments, reminder replies and timestamp writes are
+ * deliberately absent; a heartbeat is a separately bounded waiting lease. */
+export function sessionProgress(db, task) {
+  const event = one(db, `SELECT MAX(e.id) AS id FROM task_events e WHERE
+    (e.task_id=? AND e.kind IN ('specified','review_requested','review_pass','changes_requested','audited')) OR
+    (e.task_id IN (SELECT task_id FROM supercode_cards WHERE subtask_of=?) AND e.kind IN ('completed','cancelled'))`, task.id, task.id);
+  return { event: Number(event?.id ?? 0), commit: Number(lastCommitAt(task.workspace_path, task.id) ?? 0) };
+}
 /** Observe external facts before entering an optimistic board mutation. */
 export async function refreshCardInputs(board, id, { commits = false } = {}) {
   const task=board.db.prepare('SELECT t.*,c.subtask_of FROM tasks t LEFT JOIN supercode_cards c ON c.task_id=t.id WHERE t.id=?').get(id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.110",
+  "version": "0.5.112",
   "type": "module",
   "description": "The orchestrator runtime over the Volter Harness ontology: one typed operational model whose folder is its serialization, read and written through the harness orchestration doors (docs/ORCHESTRATOR-IR.md)",
   "exports": {
@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "@volter/supercode-harness-sdk": "^0.3.60",
-    "@volter/teams": "0.2.45",
+    "@volter/teams": "0.2.46",
     "@volter/ztrack": "^2.4.23",
     "yaml": "^2.9.0"
   },