@volter/supercode-orchestrator 0.4.46 → 0.4.48

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 });
 }
 
@@ -419,7 +422,11 @@ function closeRequested(board, report) {
     const session = json(row.metadata, {})?.supercode;
     if (!session?.pane) continue;
     try { stopSession(board, session); } catch (error) { report.undelivered.push([row.task_id, session.address, `closing it: ${String(error.message).slice(-200)}`]); continue; }
-    tx(board, (db) => setRunSession(db, row.id, { ...session, closed_at: now() }));
+    const address = session.address ?? `sc:${session.machine}:claude-code:${session.session_id}`;
+    tx(board, (db) => {
+      setRunSession(db, row.id, { ...session, closed_at: now() });
+      db.prepare("DELETE FROM kanban_notify_subs WHERE task_id = ? AND platform = 'supercode' AND chat_id = ?").run(row.task_id, address);
+    });
   }
 }
 
@@ -473,7 +480,12 @@ export async function sessionEffect(board, e) {
       const caller = process.env.CLAUDE_CODE_SESSION_ID || process.env.CODEX_THREAD_ID;
       if (caller && caller === session.session_id) { tx(board, (db) => setRunSession(db, row.id, { ...session, close_requested: now() })); return; }
       stopSession(board, session);
-      tx(board, (db) => setRunSession(db, row.id, { ...session, closed_at: now() }));
+      // a closed session hears nothing more of the card
+      const address = session.address ?? `sc:${session.machine}:claude-code:${session.session_id}`;
+      tx(board, (db) => {
+        setRunSession(db, row.id, { ...session, closed_at: now() });
+        db.prepare("DELETE FROM kanban_notify_subs WHERE task_id = ? AND platform = 'supercode' AND chat_id = ?").run(e.id, address);
+      });
       return;
     }
   }
@@ -569,7 +581,8 @@ 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 (prev?.forgotten) replaced = { session_id: prev.session_id, why: 'the workflow let it go' };
+  else if (prev && prev.machine === machine) {
     if (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;
@@ -588,6 +601,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) });
@@ -798,7 +818,8 @@ async function notify(board, fleet, report, entry) {
     const events = board.db.prepare(`SELECT id, kind, payload, created_at FROM task_events WHERE task_id = ? AND id > ? AND kind IN (${kinds.map(() => '?').join(', ')}) ORDER BY id`)
       .all(sub.task_id, sub.last_event_id, ...kinds);
     if (!events.length) return;
-    const task = tx(board, (db) => getTask(db, sub.task_id));
+    // the card as the workflow names it (its status the workflow's: triaging, reviewing, stopped; `stored_as` kanban.db's)
+    const task = tx(board, (db) => { const t = getTask(db, sub.task_id); return t ? { ...t, status: statusOf(db, t), stored_as: t.status } : t; });
     let cursor = Number(sub.last_event_id);
     let failed = null;
     try {

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);
@@ -462,6 +463,18 @@ 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 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.46",
+  "version": "0.4.48",
   "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": {