@volter/supercode-orchestrator 0.4.47 → 0.4.49

package/board/dispatch.mjs

@@ -369,7 +369,8 @@ function startCards(board, fleet, lanes, settings, report, entry, effects, { onl
         report.started.push([task.id, session.address ?? `pid ${session.pid}`, session.mode]);
       }
     } catch (error) {
-      try { const r = tx(board, (db) => fire(db, board, entry, task.id, 'spawn_failed', { roles: ['platform'], payload: { error: String(error.message).slice(-500) } })); effects.push(...r.effects); } catch { /* no transition for it */ }
+      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)]);
     }
   }
@@ -388,10 +389,12 @@ export function launchRun(board, entry, id, lane, fleet, settings) {
   // a subtask's run also sees its arc: the arc's text, tasks and thread (where its owner's rulings are)
   const arcContext = task.subtask_of ? tx(board, (db) => cardContext(db, task.subtask_of)) : '';
   const prompt = render(spec.prompt, { ...scope, where, context: tx(board, (db) => cardContext(db, id)), arc_context: arcContext, doors: doors(entry.workflow, status, spec.role, id, where, surface) });
-  // the run's session record knows its status, role and slot (a reviewer's slot is never the implementer's)
-  const meta = { status, role: spec.role, slot: spec.session };
+  // the run's session record knows its status, role and slot (a reviewer's slot is never the implementer's); the slot
+  // is a template, so a step can ask for isolation by naming a new one
+  const slot = String(templateValue(spec.session ?? 'worker', scope) ?? 'worker');
+  const meta = { status, role: spec.role, slot };
   return surface === 'pane'
-    ? launchPane(board, task, runId, lane, fleet, { input: prompt, slot: spec.session, meta })
+    ? launchPane(board, task, runId, lane, fleet, { input: prompt, slot, meta })
     : launchHeadless(board, task, runId, lane, settings, { prompt, skills: spec.skills ?? [], meta });
 }
 
@@ -471,6 +474,8 @@ export async function sessionEffect(board, e) {
   if (e.kind === 'close_session') {
     const rows = tx(board, (db) => db.prepare('SELECT id, metadata FROM task_runs WHERE task_id = ? ORDER BY id DESC').all(e.id));
     for (const row of rows) {
+      // a run newer than the one that left the status is its successor, already started in this tick: not closed
+      if (e.runId && row.id > e.runId) continue;
       const session = json(row.metadata, {})?.supercode;
       if ((session?.slot ?? 'worker') !== e.slot || !session?.pane || session.closed_at) continue;
       // the session that sent the event is not closed under its own command: the dispatcher closes it next tick
@@ -578,10 +583,12 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
   const prev = tx(board, (db) => lastSession(db, task.id, slot));
   let session = null;
   let replaced = null;
-  if (prev && prev.machine === machine) {
-    if (sessionAlive(fleet, prev)) {
+  if (prev?.forgotten) replaced = { session_id: prev.session_id, why: 'the workflow let it go' };
+  else if (prev && prev.machine === machine) {
+    // a session the board closed is not kept, whatever a fleet reading taken before the close still lists
+    if (!prev.closed_at && 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, ...kept } = prev;
+      const { missing_since: _m, goal_turns: _t, goal_nudged_at: _n, close_requested: _q, closed_at: _c, ...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, prev.address ?? `sc:${prev.machine}:claude-code:${prev.session_id}`, input, `board-run-${task.id}-r${runId}`);
@@ -597,6 +604,13 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
       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) };
     } 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
+  // workflow let go (`forget_session`) is replaced by a new one
+  if (replaced && !prev?.forgotten) {
+    const failed = new Error(`session ${replaced.session_id} (${slot}) could not be continued: ${replaced.why}. The board keeps a card's context and starts a new session only when the workflow lets this one go`);
+    failed.resumeFailed = { session_id: replaced.session_id, slot, why: replaced.why };
+    throw failed;
+  }
   if (!session) {
     const sid = randomUUID();
     const r = sc([...base, '--key', `board-${task.id}-r${runId}-${sid.slice(0, 8)}`, '--input', input ?? `Card ${task.id}: ${task.title}`, '--', '--session-id', sid, ...tail], { timeout: 180_000, as: boardAddress(board.label) });

package/board/workflow.mjs

@@ -414,9 +414,10 @@ const ACTIONS = {
     }
     const expires = t + ttl;
     const profile = evaluate(ctx.entry.workflow.roles?.[role] ?? 'card.assignee', scope) ?? task.assignee;
+    const slot = String(templateValue(ctx.entry.workflow.statuses[ctx.to]?.run?.session ?? 'worker', scope) ?? 'worker');
     run(ctx.db, 'UPDATE tasks SET claim_lock = ?, claim_expires = ?, started_at = COALESCE(started_at, ?) WHERE id = ?', lock, expires, t, ctx.id);
     const r = run(ctx.db, "INSERT INTO task_runs (task_id, profile, step_key, status, claim_lock, claim_expires, max_runtime_seconds, started_at, metadata) VALUES (?, ?, ?, 'running', ?, ?, ?, ?, ?)",
-      ctx.id, profile, ctx.to, lock, expires, task.max_runtime_seconds, t, JSON.stringify({ supercode: { role, status: ctx.to, slot: ctx.entry.workflow.statuses[ctx.to]?.run?.session ?? 'worker' } }));
+      ctx.id, profile, ctx.to, lock, expires, task.max_runtime_seconds, t, JSON.stringify({ supercode: { role, status: ctx.to, slot } }));
     ctx.runId = Number(r.lastInsertRowid);
     run(ctx.db, 'UPDATE tasks SET current_run_id = ? WHERE id = ?', ctx.runId, ctx.id);
     record(ctx.db, ctx.id, 'claimed', { lock, expires, run_id: ctx.runId, source_status: resumeOf(ctx.entry.workflow, ctx.to) }, ctx.runId);
@@ -461,7 +462,20 @@ const ACTIONS = {
   },
   cleanup_workspace(ctx) { ctx.effects.push({ kind: 'cleanup_workspace', id: ctx.id }); },
   stop_run(ctx) { ctx.effects.push({ kind: 'stop_run', id: ctx.id, runId: ctx.runId }); },
-  close_session(ctx, slot) { ctx.effects.push({ kind: 'close_session', id: ctx.id, slot }); },
+  // the run leaving the status is the one whose session closes, never a run started after it (a reclaim's successor)
+  close_session(ctx, slot) { ctx.effects.push({ kind: 'close_session', id: ctx.id, slot, runId: ctx.runId }); },
+  // the slot's last session is let go: its next run starts a new session (a card's context is otherwise kept: a
+  // session that cannot be resumed stops the card, it is never replaced on the board's own account)
+  forget_session(ctx, slot) {
+    const name = String(slot ?? 'worker');
+    for (const row of all(ctx.db, 'SELECT id, metadata FROM task_runs WHERE task_id = ? AND metadata IS NOT NULL ORDER BY id DESC', ctx.id)) {
+      const whole = json(row.metadata, {}) ?? {};
+      if (!whole.supercode?.session_id || (whole.supercode.slot ?? 'worker') !== name) continue;
+      whole.supercode = { ...whole.supercode, forgotten: now() };
+      run(ctx.db, 'UPDATE task_runs SET metadata = ? WHERE id = ?', JSON.stringify(whole), row.id);
+      return;
+    }
+  },
   send_to_actor(ctx, text) { ctx.effects.push({ kind: 'send_to_actor', id: ctx.id, text }); },
 };
 

package/package.json

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