@volter/supercode-orchestrator 0.4.108 → 0.4.109

package/board/cli.mjs

@@ -12,7 +12,7 @@ import { read } from '../orchestration.mjs';
 import { view, backingPaths, layOut, backingOf, boardExists, boardPath, DEFAULT_BOARD, event, json, listBoards, logsDir, now, openBoard, setActor, tx } from './store.mjs';
 import { openZtrackBoard } from './ztrack.mjs';
 import * as engine from './engine.mjs';
-import { adoptSession, boardAddress, boardLabel, boardSettings, callerSession, closeRequested, lanesOf, localMachine, observeFleet, paused, plan, startCard, tick } from './dispatch.mjs';
+import { adoptSession, boardAddress, boardLabel, boardSettings, callerSession, reconcileCallerLaunch, closeRequested, lanesOf, localMachine, observeFleet, paused, plan, startCard, tick } from './dispatch.mjs';
 import { loadWorkflow, requestSessionClose, scopeOf, statusOf, useWorkflow, workflowEntry, workflowFor } from './workflow.mjs';
 import { evaluate } from './expr.mjs';
 
@@ -241,7 +241,7 @@ export async function runWorkflow(argv) {
   // what this command records is the calling session's act (its address, as its subscriptions name it)
   if (sid) setActor(`sc:${localMachine()}:${sid === process.env.CODEX_THREAD_ID ? 'codex' : 'claude-code'}:${sid}`);
   if (sid && !READS.has(verb) && boardExists(root, slug)) {
-    withBoard((b) => { const own = ownCard(b.db, sid); if (own) authorize(b.db, verb, rest, args, own); });
+    withBoard((b) => { reconcileCallerLaunch(b, sid); const own = ownCard(b.db, sid); if (own) authorize(b.db, verb, rest, args, own); });
   }
   // the board's workflow (the IR's): what each verb does, and who may send it, is its
   // every verb reads the board through its workflow (a list settles cards too), so every verb loads it

package/board/dispatch.mjs

@@ -22,7 +22,7 @@ import { basename, dirname, join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { view, boardPath, claimer, event, json, listBoards, logsDir, now, openBoard, setActor, tx } from './store.mjs';
-import { doors, fire, loadWorkflow, resumeOf, runSpec, requestSessionClose, refreshRelationAnswers, transitionsFor, scopeOf, statusOf, templateValue, workflowFor } from './workflow.mjs';
+import { doors, fire, loadWorkflow, resumeOf, runSpec, requestSessionClose, retireSupersededRuns, refreshRelationAnswers, transitionsFor, scopeOf, statusOf, templateValue, workflowFor } from './workflow.mjs';
 import { evaluate, holds, render } from './expr.mjs';
 import {
   cardContext, claimTtl, currentRun, DEFAULT_FAILURE_LIMIT, extendClaim, getTask, lastSession,
@@ -204,6 +204,10 @@ function supervise(board, fleet, settings, report, entry, effects) {
       if (!task || (entry.workflow.run ? !task.current_run_id : task.status !== 'running')) return;
       const runRow = currentRun(db, id);
       let session = runRow?.metadata?.supercode ?? null;
+      if (session?.launch_pending) {
+        extendClaim(db, id, { ttl: settings.ttl, reason: 'launch_receipt_pending' });
+        return; // An uncertain launch owns this run until a machine receipt settles it.
+      }
       if (session?.pane) {
         let found;
         try { found = continuationPane(fleet, session, observed.get(session.machine)); }
@@ -445,6 +449,7 @@ function startCards(board, fleet, lanes, settings, report, entry, effects, { onl
         report.started.push([task.id, session.address ?? `pid ${session.pid}`, session.mode]);
       }
     } catch (error) {
+      if (error.launchPending) { report.queued.push([task.id, error.message]); continue; }
       const payload = { error: String(error.message).slice(-500), ...(error.resumeFailed ? { resume_failed: true, ...error.resumeFailed } : {}) };
       try { const r = tx(board, (db) => fire(db, board, entry, task.id, 'spawn_failed', { roles: ['platform'], payload })); effects.push(...r.effects); } catch { /* no transition for it */ }
       report.failed.push([task.id, String(error.message).slice(-300)]);
@@ -501,10 +506,37 @@ export async function startCard(board, id, { roles = ['manager'], lanes, setting
 export function closeRequested(board, report, { taskId = null, caller = null } = {}) {
   const rows = view(board, (db) => db.prepare(`SELECT id, task_id, 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();
+  for (const row of [...rows].sort((a,b) => b.id-a.id)) {
+    const s = json(row.metadata, {})?.supercode;
+    if (!s) continue;
+    for (const identity of [s.session_id && `sid:${s.session_id}`, s.pane && `pane:${s.pane}`].filter(Boolean)) {
+      const key = `${row.task_id}:${s.machine}:${identity}`;
+      const successor = latest.get(key);
+      if (successor && !row.ended_at) transfers.set(successor.id, successor);
+      else if (!successor) latest.set(key, row);
+    }
+  }
+  if (transfers.size) tx(board, (db) => {
+    for (const row of transfers.values()) retireSupersededRuns(db, row.task_id, row.id, json(row.metadata, {})?.supercode);
+  });
   const panes = new Map();
   for (const row of rows) {
-    const session = json(row.metadata, {})?.supercode;
-    if (!session?.pane || session.close_confirmed_at || (!row.ended_at && !session.close_requested)) continue;
+    let session = json(board.db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(row.id)?.metadata, {})?.supercode;
+    if (session?.launch_key && !session.pane && (row.ended_at || session.close_requested)) {
+      const receipt = launchReceipt(board, session);
+      if (receipt?.pane) { bindLaunch(board, row, session, receipt.pane, session.session_id); session = { ...session, pane: receipt.pane }; }
+      else {
+        const error = `close deferred: awaiting launch receipt ${session.launch_key}`;
+        tx(board, (db) => {
+          setRunSession(db, row.id, { close_error: error, close_requested: session.close_requested ?? now() });
+          if (session.close_error !== error) event(db, row.task_id, 'session_close_failed', { error, retry: true }, row.id);
+        });
+        report.undelivered.push([row.task_id, addressOf(session), error]);
+      }
+    }
+    if (!session?.pane || session.close_transferred_to || session.close_confirmed_at || (!row.ended_at && !session.close_requested)) continue;
     if (caller && session.session_id === caller) continue; // let the command that ended its own run return
     const active = view(board, (db) => db.prepare(`SELECT r.id, r.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());
     // Persist retries even for historical ends that did not have a close_session action.
@@ -520,9 +552,11 @@ export function closeRequested(board, report, { taskId = null, caller = null } =
       const observed = panes.get(machine);
       if (observed.error) throw new Error(observed.error);
       if (observed.live.has(session.pane)) {
+        const pendingNotice = view(board, (db) => db.prepare("SELECT id FROM supercode_effects WHERE json_extract(effect, '$.kind')='session_notice' AND json_extract(effect, '$.runId')=? LIMIT 1").get(row.id));
+        if (pendingNotice || session.lifecycle_notice_pending) throw new Error(`close deferred: lifecycle notice ${session.lifecycle_notice_pending} has not been delivered: ${session.lifecycle_notice_error ?? 'pending'}`);
         const protectedNow = view(board, (db) => db.prepare(`SELECT metadata FROM task_runs r WHERE r.ended_at IS NULL OR EXISTS (SELECT 1 FROM tasks t WHERE t.current_run_id = r.id)`).all())
           .some((r) => { const s = json(r.metadata, {})?.supercode; return s?.pane === session.pane && normalMachine(s.machine) === normalMachine(session.machine); });
-        if (protectedNow) continue;
+        if (protectedNow) throw new Error(`close deferred: pane ${session.pane} is owned by an unended run`);
         stopSession(board, session); observed.live.delete(session.pane);
       }
     } catch (e) { error = String(e.message).slice(-500); }
@@ -579,6 +613,31 @@ function observeIdle(board, fleet, settings, report, entry, effects) {
   }
 }
 
+/** The verb drains this durable notice immediately; the dispatcher retries after a failure. */
+export async function sessionNotice(board, e) {
+  const prior = view(board, (db) => json(db.prepare('SELECT metadata FROM task_runs WHERE id=?').get(e.runId)?.metadata, {})?.supercode);
+  if (prior?.close_confirmed_at) {
+    tx(board, (db) => {
+      event(db, e.id, 'session_notice_failed', { address: e.address, verb: e.verb, notice: e.durableId, error: 'session closure already confirmed; notice cannot be delivered', retry: false }, e.runId);
+      if (prior.lifecycle_notice_pending === e.durableId) setRunSession(db, e.runId, { lifecycle_notice_pending: null });
+    });
+    return true;
+  }
+  e = { ...e, address: e.address ?? addressOf(prior) };
+  let error = null;
+  try {
+    if (!e.address) throw new Error('lifecycle notice awaits the owned launch session identity');
+    await send(boardAddress(board.label), board.label, e.address, e.text, `board-run-notice-${e.id}-${e.durableId}`, { queue: true }); }
+  catch (failure) { error = String(failure.message).slice(-500); }
+  tx(board, (db) => {
+    const session = json(db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(e.runId)?.metadata, {})?.supercode;
+    if (session) setRunSession(db, e.runId, { ...session,
+      ...(error ? { lifecycle_notice_error: error } : { lifecycle_notice_error: null, ...(session.lifecycle_notice_pending === e.durableId ? { lifecycle_notice_pending: null } : {}) }) });
+    if (!error || session?.lifecycle_notice_error !== error) event(db, e.id, error ? 'session_notice_failed' : 'session_notice_delivered', { address: e.address, verb: e.verb, source_event: e.sourceEvent, notice: e.durableId, ...(error ? { error, retry: true } : {}) }, e.runId);
+  });
+  return !error;
+}
+
 /** A session effect a committed move asked for: a message to the card's current actor, or closing a slot's pane. */
 export async function sessionEffect(board, e) {
   if (e.kind === 'send_to_actor') {
@@ -671,6 +730,81 @@ export function paused(root) {
 const getTaskNow = (board, id) => view(board, (db) => getTask(db, id));
 
 
+/** A transport error is not a negative launch receipt. The key remains owned by its run. */
+function launchReceipt(board, session) {
+  const r = sc(['teams', 'rpc', 'launches.get', JSON.stringify({ key: session.launch_key }), '--machine', session.machine],
+    { timeout: 30_000, as: boardAddress(board.label) });
+  return r.code === 0 ? lastJson(r.stdout) : null;
+}
+
+function bindLaunch(board, row, session, pane, sid) {
+  return tx(board, (db) => {
+    const current = db.prepare('SELECT ended_at, metadata FROM task_runs WHERE id=?').get(row.id);
+    const saved = json(current?.metadata, {})?.supercode;
+    if (!saved || saved.launch_key !== session.launch_key || (saved.session_id && sid && saved.session_id !== sid)) return false;
+    const address = sid ? `sc:${session.machine}:${session.harness}:${sid}` : null;
+    setRunSession(db, row.id, { ...saved, pane, session_id: sid ?? saved.session_id,
+      ...(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');
+      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;
+  });
+}
+
+/** A fast worker can reach its first board door before open's reply. Bind only the daemon's keyed pane. */
+export function reconcileCallerLaunch(board, sid) {
+  const rows = view(board, (db) => db.prepare(`SELECT r.id, r.task_id, r.metadata FROM task_runs r
+    JOIN tasks t ON t.current_run_id=r.id WHERE r.ended_at IS NULL
+    AND json_extract(r.metadata, '$.supercode.launch_pending') = 1`).all());
+  const machine = localMachine();
+  const harness = sid === process.env.CODEX_THREAD_ID ? 'codex' : 'claude-code';
+  const candidates = rows.filter((row) => {
+    const s = json(row.metadata, {})?.supercode;
+    return s?.machine === machine && s.harness === harness && (!s.session_id || s.session_id === sid);
+  });
+  if (!candidates.length) return;
+  const pane = process.env.SUPERCODE_TEAMS_PANE || observeFleet().sessions?.find((s) => s.address === `sc:${machine}:${harness}:${sid}`)?.pane;
+  if (!pane) return;
+  for (const row of candidates) {
+    const s = json(row.metadata, {})?.supercode;
+    const receipt = launchReceipt(board, s);
+    if (receipt?.live && receipt.pane === pane) {
+      if (bindLaunch(board, row, s, pane, sid)) return;
+    }
+  }
+}
+
+function reconcileLaunches(board, fleet, report, entry, effects, settings) {
+  const rows = view(board, (db) => db.prepare(`SELECT id, task_id, ended_at, metadata FROM task_runs
+    WHERE json_extract(metadata, '$.supercode.launch_pending') = 1
+    AND json_extract(metadata, '$.supercode.close_confirmed_at') IS NULL`).all());
+  for (const row of rows) {
+    const s = json(row.metadata, {})?.supercode;
+    try {
+    const receipt = launchReceipt(board, s);
+    if (!receipt?.pane) { report.queued.push([row.task_id, s.launch_error ?? `awaiting launch receipt ${s.launch_key}`]); continue; }
+    const sid = s.session_id ?? fleet.sessions?.find((f) => f.pane === receipt.pane && String(f.address).startsWith(`sc:${s.machine}:${s.harness}:`))?.address.split(':')[3];
+    bindLaunch(board, row, s, receipt.pane, receipt.live ? sid : null);
+    if (receipt.live === false && !row.ended_at && now() - s.launched_at > settings.grace) {
+      // A recorded pane absent on its machine is evidence; a closed response stream was not.
+      if (!panePresent(s.machine, receipt.pane)) {
+        const moved = tx(board, (db) => {
+          if (getTask(db, row.task_id)?.current_run_id !== row.id) return null;
+          setRunSession(db, row.id, { launch_pending: false });
+          return fire(db, board, entry, row.task_id, 'spawn_failed', { roles: ['platform'], payload: { error: `launch ${s.launch_key} ended before session binding` } });
+        });
+        if (moved) effects.push(...moved.effects);
+      }
+    } else if (!sid) report.queued.push([row.task_id, `pane ${receipt.pane} is live; awaiting ${s.harness} session identity`]);
+    } catch (error) { report.failed.push([row.task_id, `launch reconciliation retained: ${error.message}`]); }
+  }
+}
+
 function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'worker', meta = {} } = {}) {
   const machine = normalMachine(task.machine);
   if (machine === localMachine() && !(task.workspace_kind === 'dir' && task.workspace_path && existsSync(task.workspace_path))) {
@@ -691,7 +825,7 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
   closeRequested(board, { undelivered: [] }, { taskId: task.id });
   const pending = view(board, (db) => db.prepare('SELECT id, ended_at, metadata FROM task_runs WHERE task_id = ? AND id != ?').all(task.id, runId))
     .map((r) => ({ ...r, session: json(r.metadata, {})?.supercode }))
-    .find((r) => r.session?.pane && (r.session.slot ?? 'worker') === slot && (r.ended_at || r.session.close_requested) && !r.session.close_confirmed_at);
+    .find((r) => (r.session?.pane || r.session?.launch_key) && !r.session.close_transferred_to && (r.session.slot ?? 'worker') === slot && (r.ended_at || r.session.close_requested) && !r.session.close_confirmed_at);
   if (pending) throw new Error(`slot ${slot} still owns pane ${pending.session.pane} from run ${pending.id}; closure must be confirmed before another session starts: ${pending.session.close_error ?? 'close pending'}`);
   let prev = view(board, (db) => lastSession(db, task.id, slot));
   if (prev?.session_id && !prev.forgotten && (prev.harness ?? 'claude-code') === harness && prev.machine === machine) {
@@ -711,15 +845,30 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
     // a pane that could not be closed still holds the session: no second process is started on it
     if (prev?.close_requested && !prev.closed_at) throw new Error(`the slot's session ${prev.session_id} asked to be closed and its pane ${prev.pane} could not be: ${report.undelivered.map((u) => u[2]).join('; ') || 'no reason given'}`);
   }
-  // Record the pane before waiting for the harness to name itself. A failed launch still owns a process.
-  const rememberPane = (pane, sessionId, mode) => {
-    if (!pane) return;
+  const openOwned = (key, sid, mode, args) => {
+    tx(board, (db) => setRunSession(db, runId, { ...meta, surface: 'pane', machine, harness, slot,
+      session_id: sid, mode, launch_key: key, launch_pending: true, launched_at: now() }));
+    const result = sc(args, { timeout: 180_000, as: boardAddress(board.label) });
+    const facts = launchReceipt(board, { machine, launch_key: key });
+    const pane = facts?.pane ?? lastJson(result.stdout)?.pane ?? null;
+    // The daemon's keyed receipt is authoritative even when the stream carrying open's reply closed.
+    if (pane) tx(board, (db) => {
+      const before = json(db.prepare('SELECT metadata FROM task_runs WHERE id=?').get(runId)?.metadata, {})?.supercode ?? {};
+      setRunSession(db, runId, { ...before, pane });
+    });
+    const currentFleet = observeFleet();
+    const discovered = sid ?? currentFleet.sessions?.find((f) => f.pane === pane && String(f.address).startsWith(`sc:${machine}:${harness}:`))?.address.split(':')[3];
+    if (pane && discovered && facts?.live === true) {
+      return { surface: 'pane', session_id: discovered, machine, harness, pane, mode, launch_key: key,
+        launch_pending: false, launch_error: null, launched_at: now() };
+    }
+    const reason = facts?.live === false && pane ? `launch pane ${pane} ended` :
+      `launch ${key} is awaiting its machine receipt or session identity: ${(result.stderr || result.stdout).trim().slice(-300)}`;
     tx(board, (db) => {
-      const row = db.prepare('SELECT metadata, ended_at FROM task_runs WHERE id = ?').get(runId);
-      const before = json(row?.metadata, {})?.supercode ?? {};
-      setRunSession(db, runId, { ...before, ...meta, surface: 'pane', session_id: sessionId, harness, machine, pane, slot, mode, launched_at: now() });
-      if (row?.ended_at) requestSessionClose(db, task.id, { runId });
+      setRunSession(db, runId, { launch_pending: true, launch_error: reason });
+      event(db, task.id, 'session_launch_pending', { key, pane, reason }, runId);
     });
+    throw Object.assign(new Error(reason), { launchPending: true });
   };
   let session = null;
   let replaced = null;
@@ -742,20 +891,27 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
       const { missing_since: _m, goal_turns: _t, goal_nudged_at: _n, close_requested: _q, closed_at: _c, close_confirmed_at: _cc, close_error: _ce, close_attempts: _ca, close_attempted_at: _ct, ...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)
-      if (input) deliverNow(board, addressOf(prev), input, `board-run-${task.id}-r${runId}`);
+      tx(board, (db) => setRunSession(db, runId, { ...session, ...meta }));
+      if (input) {
+        try { deliverNow(board, addressOf(prev), input, `board-run-${task.id}-r${runId}`); }
+        catch (error) {
+          tx(board, (db) => {
+            const effect = { kind: 'session_notice', id: task.id, runId, address: addressOf(prev), text: input, verb: 'start' };
+            const saved = db.prepare('INSERT INTO supercode_effects(effect) VALUES(?)').run(JSON.stringify(effect));
+            setRunSession(db, runId, { lifecycle_notice_pending: Number(saved.lastInsertRowid), lifecycle_notice_error: error.message });
+            event(db, task.id, 'session_notice_failed', { verb: 'start', error: error.message, retry: true }, runId);
+          });
+        }
+      }
     } else if (prev.resumable !== false) {
       // a resumed session is told what this run is for, as a kept one is: the run's own prompt (a reviewer resumed for
       // its next round gets that round's prompt, its arc's context with it), not only that it was resumed
       const told = input ? `The board resumed this session for this run of card ${task.id}.\n\n${input}` : `The board resumed this session after it was lost; you are still on card ${task.id}: ${task.title}. Carry on.`;
       // a session is resumed in its own harness, whatever the lane's is now
       const its = HARNESSES[prev.harness ?? 'claude-code'] ?? HARNESSES['claude-code'];
-      const r = sc(['open', '--new', its.program, ...base.slice(3), '--key', `board-${task.id}-r${runId}-resume`, '--input', told, '--', ...its.resume(prev.session_id), ...tail], { timeout: 180_000, as: boardAddress(board.label) });
-      const pane = r.code === 0 ? lastJson(r.stdout)?.pane ?? null : null;
-      rememberPane(pane, prev.session_id, 'resume');
-      // a resume the harness refuses (its transcript is gone) ends the pane at once; another machine's launch
-      // answers before that shows, so the pane is looked for again a moment later
-      if (pane && paneSurvives(task.machine, pane)) session = { surface: 'pane', session_id: prev.session_id, harness: prev.harness ?? 'claude-code', machine, pane, mode: 'resume', launched_at: now() };
-      else replaced = { session_id: prev.session_id, why: r.code === 0 ? `its resume ended as soon as it started (pane ${pane})` : (r.stderr || r.stdout).trim().slice(-300) };
+      const launchKey = `board-${task.id}-r${runId}-resume`;
+      session = openOwned(launchKey, prev.session_id, 'resume', ['open', '--new', its.program, ...base.slice(3),
+        '--key', launchKey, '--input', told, '--', ...its.resume(prev.session_id), ...tail]);
     } else replaced = { session_id: prev.session_id, why: 'its resume never came up' };
   } else if (prev) replaced = { session_id: prev.session_id, why: `the card moved from ${prev.machine} to ${machine}` };
   // a card keeps its context: a slot's session that cannot be kept or resumed stops the launch, and only a session the
@@ -766,29 +922,11 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
     throw failed;
   }
   if (!session) {
-    let sid = how.namesItself ? null : randomUUID();
-    const launchKey=`board-${task.id}-r${runId}-${(sid ?? randomUUID()).slice(0,8)}`;
-    const r = sc([...base, '--key', launchKey, '--input', input ?? `Card ${task.id}: ${task.title}`, '--', ...(sid ? how.fresh(sid) : how.fresh()), ...tail], { timeout: 180_000, as: boardAddress(board.label) });
-    if (r.code !== 0) throw new Error(`supercode open --on ${task.machine}: ${(r.stderr || r.stdout).trim().slice(-500)}`);
-    const pane = lastJson(r.stdout)?.pane ?? null;
-    rememberPane(pane, sid, 'fresh');
-    const receipt=sc(['teams','rpc','launches.get',JSON.stringify({key:launchKey}),'--machine',task.machine],{timeout:30_000,as:boardAddress(board.label)});
-    const facts=receipt.code===0?lastJson(receipt.stdout):null;
-    if (!pane || facts?.inputDelivered===false || facts?.live===false || (!how.namesItself && !paneSurvives(task.machine,pane))) {
-      // The failed run's durable close queue owns its pane, even if the close door is unavailable.
-      throw new Error(`${harness} launch did not become a working session: ${facts?.inputError??(!pane?'no pane returned':'pane ended or initial input was not delivered')}`);
-    }
-    // a harness that names its own session is found in the fleet by the pane the board opened for it
-    for (let waited = 0; !sid && pane && waited < 90_000; waited += 3000) {
-      pause(3000);
-      sid = observeFleet().sessions?.find((f) => f.pane === pane && String(f.address).split(':')[2] === harness)?.address.split(':')[3] ?? null;
-    }
-    if (!sid) {
-      // a pane whose session the board cannot name is closed, never left working beside the next start's
-      // The run retains its pane for cleanup even though no harness session id arrived.
-      throw new Error(`${harness} in pane ${pane ?? '(none)'} on ${task.machine} named no session within 90 s; the pane is closed`);
-    }
-    session = { surface: 'pane', session_id: sid, machine, pane, mode: 'fresh', launched_at: now(), ...(replaced ? { replaces: replaced.session_id } : {}) };
+    const sid = how.namesItself ? null : randomUUID();
+    const launchKey = `board-${task.id}-r${runId}-${(sid ?? randomUUID()).slice(0,8)}`;
+    session = openOwned(launchKey, sid, 'fresh', [...base, '--key', launchKey,
+      '--input', input ?? `Card ${task.id}: ${task.title}`, '--', ...(sid ? how.fresh(sid) : how.fresh()), ...tail]);
+    if (replaced) session.replaces = replaced.session_id;
   }
   session.harness = session.harness ?? harness;
   session.address = `sc:${machine}:${session.harness}:${session.session_id}`;
@@ -812,7 +950,7 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
     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) throw new Error(`run ${runId} ended while its session launched; its pane is queued for closure`);
+  if (!recorded) return { ...session, mode: 'finished_during_launch' };
   return session;
 }
 
@@ -965,7 +1103,9 @@ export function adoptSession(board, id, who, { workspace = null, ttl, assignee =
 function deliverNow(board, to, body, key) {
   const request = { op: 'send', from: boardAddress(board.label), from_name: `${board.label} board`, to, queue: false, id: key,
     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.)` };
-  sc(['message', 'remote-deliver'], { input: JSON.stringify(request), timeout: 120_000 });
+  const r = sc(['message', 'remote-deliver'], { input: JSON.stringify(request), timeout: 120_000 });
+  const answer = lastJson(r.stdout);
+  if (answer?.code !== 0) throw new Error((answer?.text || r.stderr || `no delivery answer (exit ${r.code})`).trim().slice(-300));
 }
 
 async function send(from, label, to, body, key, { queue = false, ask = false } = {}) {
@@ -1074,12 +1214,14 @@ async function notify(board, fleet, report, entry) {
         if (text) {
           // Hermes's delivery modes: `notify` is passive (read at the session's next turn), `wake`/`notify+wake` start its turn
           await send(from, board.label, sub.chat_id, text, `board-${sub.task_id}-${ev.id}-${sub.chat_id.slice(-12)}`, { queue: sub.delivery_mode === 'notify' });
+          tx(board, (db) => event(db, sub.task_id, 'notice_delivered', { source_event: ev.id, kind: ev.kind, address: sub.chat_id }));
           report.notified.push([sub.task_id, ev.kind, sub.chat_id]);
         }
         cursor = ev.id;
       }
     } catch (error) {
       failed = String(error.message).slice(-200);
+      tx(board, (db) => event(db, sub.task_id, 'notice_failed', { after_event: cursor, address: sub.chat_id, error: failed, retry: true }));
       report.undelivered.push([sub.task_id, sub.chat_id, failed]);
     }
     // the cursor moves past what was delivered (a failed delivery is retried next tick; the mail id dedupes)
@@ -1362,7 +1504,7 @@ export async function tick({ root, lanes, settings, only = null, slugs = null, d
       readMailbox(board, boardAddress(board.label), report); phase('mailbox');
       await refreshRelationAnswers(board); phase('answers');
       const effects = [];
-      supervise(board, fleet, settings, report, entry, effects); closeRequested(board, report); phase('supervise');
+      reconcileLaunches(board, fleet, report, entry, effects, settings); supervise(board, fleet, settings, report, entry, effects); await runEffects(board, effects.splice(0), { retryNotices: true }); closeRequested(board, report); phase('supervise');
       report.unsettled = [];
       report.promoted = recomputeReady(board, effects, report.unsettled);
       await sendBoardMessages(board, report);

package/board/engine.mjs

@@ -12,7 +12,7 @@ import { existsSync, rmSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { view, claimer, event, json, newTaskId, now, tx } from './store.mjs';
-import { addDependency, refreshCardInputs, requestSessionClose, eventTo, fire, loadWorkflow, setStatus, settle, startNew, statusOf, runEvent, workflowFor } from './workflow.mjs';
+import { addDependency, retireSupersededRuns, refreshCardInputs, requestSessionClose, eventTo, fire, loadWorkflow, setStatus, settle, startNew, statusOf, runEvent, workflowFor } from './workflow.mjs';
 
 export const STATUSES = ['triage', 'todo', 'scheduled', 'ready', 'running', 'blocked', 'review', 'done', 'archived'];
 export const WORKSPACE_KINDS = ['scratch', 'dir', 'worktree'];
@@ -106,7 +106,10 @@ export function currentRun(db, taskId) {
 export function setRunSession(db, runId, session) {
   const row = one(db, 'SELECT metadata FROM task_runs WHERE id = ?', runId);
   const whole = json(row?.metadata, {}) ?? {};
-  whole.supercode = { ...whole.supercode, ...session };
+  const before = whole.supercode;
+  whole.supercode = { ...before, ...session };
+  const task = one(db, 'SELECT task_id FROM task_runs WHERE id = ?', runId);
+  if (task && session.session_id && session.pane && (before?.session_id !== session.session_id || before?.pane !== session.pane)) retireSupersededRuns(db, task.task_id, runId, whole.supercode);
   run(db, 'UPDATE task_runs SET metadata = ? WHERE id = ?', JSON.stringify(whole), runId);
   return whole;
 }
@@ -353,10 +356,19 @@ export async function goto(board, id, status, { roles = null, payload = {} } = {
 }
 
 /** The I/O a committed move asked for. */
-export async function runEffects(board, effects = []) {
-  const pending = board.db.prepare('SELECT id, effect FROM supercode_effects ORDER BY id').all();
-  for (const e of [...pending.map((p) => ({ ...json(p.effect, {}), durableId: p.id })), ...effects]) {
-    if (e.kind === 'cleanup_workspace') cleanupWorkspace(board, e.id);
+export async function runEffects(board, effects = [], { retryNotices = false } = {}) {
+  const requested = new Set(effects.map((e) => e.durableId).filter(Boolean));
+  const pending = board.db.prepare('SELECT id, effect FROM supercode_effects ORDER BY id').all()
+    .filter((p) => retryNotices || requested.has(p.id) || json(p.effect, {})?.kind !== 'session_notice');
+  const durable = new Set(pending.map((p) => p.id));
+  const combined = [...pending.map((p) => ({ ...json(p.effect, {}), durableId: p.id })), ...effects.filter((e) => !e.durableId || !durable.has(e.durableId))];
+  combined.sort((a,b) => Number(b.kind === 'session_notice') - Number(a.kind === 'session_notice'));
+  for (const e of combined) {
+    if (e.kind === 'session_notice') {
+      const { sessionNotice } = await import('./dispatch.mjs');
+      if (!await sessionNotice(board, e)) continue;
+    }
+    else if (e.kind === 'cleanup_workspace') cleanupWorkspace(board, e.id);
     else if (e.kind === 'invalidate_descendants') tx(board, (db) => invalidateDescendants(db, board, e.id));
     else if (e.kind === 'stop_run') stopWorker(board, e.runId);
     else if (e.kind === 'close_session' || e.kind === 'send_to_actor' || e.kind === 'run_ended') {

package/board/workflow.mjs

@@ -301,6 +301,31 @@ export function transitionsFor(workflow, status, name) {
   return [...(workflow.verbs?.[name] ?? []).filter((t) => !t.from?.length || t.from.includes(status)), ...(workflow.statuses[status]?.on?.[name] ?? []), ...(workflow.on?.[name] ?? [])];
 }
 
+function noticeRun(db, task) {
+  return task.current_run_id ? one(db, 'SELECT id, metadata FROM task_runs WHERE id = ?', task.current_run_id)
+    : all(db, 'SELECT id, metadata FROM task_runs WHERE task_id = ? ORDER BY id DESC', task.id).find((r) => json(r.metadata, {})?.supercode?.session_id) ?? null;
+}
+
+function queueTransitionNotice(db, board, entry, task, from, name, payload, beforeRun, effects) {
+  const after = cardOf(db, task.id), to = statusOf(db, after);
+  const state = (t, status) => JSON.stringify([status, t.current_run_id, t.paused, t.archived, t.blocked_by]);
+  const beforeState = json(beforeRun?.metadata, {})?.supercode?.state;
+  const afterState = beforeRun && json(one(db, 'SELECT metadata FROM task_runs WHERE id=?', beforeRun.id)?.metadata, {})?.supercode?.state;
+  if (!beforeRun || (state(task, from) === state(after, to) && beforeState === afterState) || effects.some((e) => e.kind === 'session_notice' && e.runId === beforeRun.id)) return;
+  const session = json(beforeRun.metadata, {})?.supercode;
+  const address = session?.address ?? (session?.session_id && session.machine ? `sc:${session.machine}:${session.harness ?? 'claude-code'}:${session.session_id}` : null);
+  if (!address && !session?.launch_key && !session?.pane) return;
+  const scope = scopeOf(db, board, after, { params: entry.params, event: { ...payload, verb: name, from, to }, extra: { run: { id: beforeRun.id } } });
+  const text = render(entry.workflow.notify?.worker?.run_changed ?? '{{card.id}}: {{event.verb}} changed run {{run.id}} ({{event.from}} → {{event.to}}). Stop work under the previous run; follow the board’s current state. {{event.reason ?? ""}}', scope);
+  const source = one(db, 'SELECT MAX(id) AS id FROM task_events WHERE task_id = ?', task.id)?.id;
+  const effect = { kind: 'session_notice', id: task.id, runId: beforeRun.id, address, text, sourceEvent: source, verb: name };
+  const inserted = run(db, 'INSERT INTO supercode_effects (effect) VALUES (?)', JSON.stringify(effect));
+  effects.push({ ...effect, durableId: Number(inserted.lastInsertRowid) });
+  const current = json(one(db, 'SELECT metadata FROM task_runs WHERE id = ?', beforeRun.id)?.metadata, {}) ?? {};
+  current.supercode = { ...current.supercode, lifecycle_notice_pending: Number(inserted.lastInsertRowid) };
+  run(db, 'UPDATE task_runs SET metadata = ? WHERE id = ?', JSON.stringify(current), beforeRun.id);
+}
+
 /**
  * Apply event `name` to card `id` in the caller's transaction. `roles` are who sends it (a transition with `by`
  * takes only a sender in one of its roles; `platform` for the dispatcher's own observations). Answers
@@ -311,6 +336,7 @@ export function fire(db, board, entry, id, name, { roles = [], payload = {}, ext
   const { workflow, params } = entry;
   if (workflow.run && (workflow.run.on?.[name] || Object.values(workflow.run.states ?? {}).some((s) => s.on?.[name]))) return fireRun(db, board, entry, id, name, { roles, payload, extra });
   const task = cardOf(db, id);
+  const beforeRun = noticeRun(db, task);
   const from = statusOf(db, task);
   if (!workflow.statuses[from]) throw new Error(`${id} is ${from}, which the board's workflow does not declare`);
   const candidates = transitionsFor(workflow, from, name);
@@ -328,6 +354,7 @@ export function fire(db, board, entry, id, name, { roles = [], payload = {}, ext
   const to = take(db, board, entry, task, from, taken, scope, effects);
   settle(db, board, entry, id, effects);
   projectStatus(db, board, entry, id);
+  queueTransitionNotice(db, board, entry, task, from, name, payload, beforeRun, effects);
   return { from, to: statusOf(db, cardOf(db, id)), moved: to !== from, effects };
 }
 
@@ -358,7 +385,7 @@ function cardOf(db, id) {
   const row = one(db, 'SELECT * FROM tasks WHERE id = ?', id);
   if (!row) throw new Error(`no card ${id}`);
   const ours = one(db, 'SELECT * FROM supercode_cards WHERE task_id = ?', id);
-  return { ...row, skills: json(row.skills, []) ?? [], machine: ours?.machine ?? null, subtask_of: ours?.subtask_of ?? null };
+  return { ...row, blocked_by: json(ours?.blocked_by, []) ?? [], paused: json(ours?.paused, null), archived: Boolean(ours?.archived), skills: json(row.skills, []) ?? [], machine: ours?.machine ?? null, subtask_of: ours?.subtask_of ?? null };
 }
 
 // one transition: the old status's exit actions, the move, the transition's actions, the new status's entry actions
@@ -367,6 +394,7 @@ function take(db, board, entry, task, from, transition, scope, effects) {
   const target = transition.target ? String(templateValue(transition.target, scope) ?? '') : null;
   if (target && !workflow.statuses[target]) throw new Error(`the workflow moves ${task.id} to ${target}, which it does not declare`);
   const moves = target && target !== from;
+  if (moves && scope.card.paused) throw new Error('a paused card must be resumed before its stage can change');
   const ctx = { db, board, entry, id: task.id, scope: { ...scope, before: scope.card }, from, to: target ?? from, effects, runId: task.current_run_id ?? null };
   if (moves) for (const a of workflow.statuses[from].exit ?? []) act(ctx, a);
   if (moves) setStatus(db, workflow, task.id, target);
@@ -590,6 +618,7 @@ const ACTIONS = {
     const t = now();
     if (row?.current_run_id) {
       const runId = Number(row.current_run_id);
+      retireSupersededRuns(ctx.db, ctx.id, runId, json(one(ctx.db, 'SELECT metadata FROM task_runs WHERE id = ?', runId)?.metadata, {})?.supercode);
       run(ctx.db, `UPDATE task_runs SET status = ?, outcome = ?, summary = COALESCE(?, summary), error = COALESCE(?, error), ended_at = ?, claim_lock = NULL, claim_expires = NULL, worker_pid = NULL
                WHERE id = ? AND ended_at IS NULL`, outcome, outcome, summary, error ?? ctx.scope.event?.error ?? null, t, runId);
       requestSessionClose(ctx.db, ctx.id, { runId });
@@ -715,6 +744,23 @@ const ACTIONS = {
   send_to_actor(ctx, text) { ctx.effects.push({ kind: 'send_to_actor', id: ctx.id, text }); },
 };
 
+/** Binding a newer run transfers ownership; stale run references cannot veto its later stop. */
+export function retireSupersededRuns(db, id, runId, session) {
+  if (!session?.session_id && !session?.pane) return;
+  for (const old of all(db, `SELECT id, task_id, metadata FROM task_runs WHERE id < ? AND ended_at IS NULL
+    AND json_extract(metadata, '$.supercode.machine') IS ?
+    AND ((? IS NOT NULL AND json_extract(metadata, '$.supercode.session_id') = ?)
+      OR (? IS NOT NULL AND json_extract(metadata, '$.supercode.pane') = ?))`,
+    runId, session.machine ?? null, session.session_id ?? null, session.session_id ?? null, session.pane ?? null, session.pane ?? null)) {
+    const whole = json(old.metadata, {}) ?? {}, s = whole.supercode;
+    if (!s || s.machine !== session.machine || !((session.session_id && s.session_id === session.session_id) || (session.pane && s.pane === session.pane))) continue;
+    if (old.task_id !== id && one(db, 'SELECT 1 FROM tasks WHERE current_run_id = ?', old.id)) throw new Error(`session is still owned by active run ${old.id} of ${old.task_id}`);
+    if (s.pane && s.pane === session.pane) whole.supercode = { ...s, close_transferred_to: runId, close_requested: null };
+    run(db, "UPDATE task_runs SET status='superseded', outcome='superseded', ended_at=?, claim_lock=NULL, claim_expires=NULL, worker_pid=NULL, metadata=? WHERE id=?", now(), JSON.stringify(whole), old.id);
+    record(db, old.task_id, 'run_superseded', { successor: runId, session_id: s.session_id, pane: s.pane }, old.id);
+  }
+}
+
 /** The create door uses the instance's canonical dependency representation. */
 export function addDependency(db, entry, id, parent) {
   if (entry.workflow.relations?.blocked_by) ACTIONS.relation({ db, id }, { add: parent, reason: 'declared dependency' });
@@ -727,7 +773,7 @@ export function requestSessionClose(db, id, { runId = null, slot = null, through
     if ((runId != null && row.id !== runId) || (through != null && row.id > through)) continue;
     const whole = json(row.metadata, {}) ?? {};
     const session = whole.supercode;
-    if (!session?.pane || session.close_confirmed_at || (slot != null && (session.slot ?? 'worker') !== slot)) continue;
+    if ((!session?.pane && !session?.launch_key) || session.close_transferred_to || session.close_confirmed_at || (slot != null && (session.slot ?? 'worker') !== slot)) continue;
     if (session.close_requested && !session.closed_at) continue;
     whole.supercode = { ...session, close_requested: session.close_requested ?? now() };
     delete whole.supercode.closed_at; // older versions recorded success without checking the receipt
@@ -828,6 +874,7 @@ export function fireRun(db, board, entry, id, name, { roles = [], payload = {},
     if (outcome) take(db, board, entry, cardOf(db, id), statusOf(db, cardOf(db, id)), outcome, after, effects);
   }
   projectStatus(db, board, entry, id);
+  queueTransitionNotice(db, board, entry, task, status, name, payload, row, effects);
   return { from: status, to: statusOf(db, cardOf(db, id)), effects };
 }
 

package/board/ztrack.mjs

@@ -128,7 +128,11 @@ class ZtrackBoard {
         const changes = this.rows.changes(this.mem, { all: !this.rows.normalized() });
         const canonical = (row, omitted) => row && Object.fromEntries(Object.entries(row).filter(([key])=>!omitted.has(key)));
         const documentChanges = changes.filter(({source})=>{
-          if(source.name==='tasks')return JSON.stringify(canonical(source.row,new Set([...RUNTIME,'status'])))!==JSON.stringify(canonical(this.rows.cachedTasks[JSON.parse(source.key)[0]],new Set([...RUNTIME,'status'])));
+          if(source.name==='tasks') {
+            const before=this.rows.cachedTasks[JSON.parse(source.key)[0]];
+            if(source.row?.workspace_kind!=='scratch' && source.row?.workspace_path!==before?.workspace_path)return true;
+            return JSON.stringify(canonical(source.row,new Set([...RUNTIME,'status'])))!==JSON.stringify(canonical(before,new Set([...RUNTIME,'status'])));
+          }
           if(source.name==='supercode_cards')return JSON.stringify(canonical(source.row,new Set(['since','after_fired','next_run_at'])))!==JSON.stringify(canonical(this.rows.cachedCards[JSON.parse(source.key)[0]],new Set(['since','after_fired','next_run_at'])));
           return false;
         });

package/package.json

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