@volter/supercode-orchestrator 0.4.48 → 0.4.50

package/board/cli.mjs

@@ -1085,7 +1085,11 @@ async function serve(root, args = {}) {
   process.on('SIGTERM', stop);
   process.on('SIGINT', stop);
   const log = (text) => process.stdout.write(`${new Date().toISOString()} ${text}\n`);
-  log(`dispatching the boards of ${root} from ${localMachine()}`);
+  // the orchestrator this serve runs, as installed: a newer install ends the serve after its tick, so whatever keeps it
+  // running starts it again on the new code (a fix reaches the board with no hand relaunch)
+  const installed = () => { try { return JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version ?? null; } catch { return null; } };
+  const running = installed();
+  log(`dispatching the boards of ${root} from ${localMachine()} (orchestrator ${running ?? 'unknown'})`);
   const stuck = {};
   const warned = {};
   let pausedSaid = false;
@@ -1113,6 +1117,8 @@ async function serve(root, args = {}) {
       } catch (error) {
         log(`tick failed: ${error.message}`);
       }
+      const now = installed();
+      if (running && now && now !== running) { log(`orchestrator ${now} is installed (this serve runs ${running}); stopping, for its keeper to start the new one`); break; }
       // the next tick is due an interval after this one began (a long tick is not followed by a full interval's wait)
       const rest = Math.max(1, interval - Math.floor((Date.now() - began) / 1000));
       for (let waited = 0; waited < rest && !stopped; waited += 1) await new Promise((done) => setTimeout(done, 1000));

package/board/dispatch.mjs

@@ -474,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
@@ -583,9 +585,10 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
   let replaced = null;
   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)) {
+    // 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}`);

package/board/workflow.mjs

@@ -462,7 +462,8 @@ 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) {

package/package.json

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