@volter/supercode-orchestrator 0.4.49 → 0.4.51

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

@@ -580,13 +580,20 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
   const tail = model ? ['--model', model] : [];
   const base = ['open', '--new', 'claude', '--detach', '--on', task.machine, '--cwd', task.workspace_path];
   // the slot's last session: kept when live, resumed when lost, never another slot's (a reviewer's is its own)
-  const prev = tx(board, (db) => lastSession(db, task.id, slot));
+  // a close its session's own command asked for is carried out first, so its pane is gone before the slot's next
+  // session starts (never two processes on one session)
+  let prev = tx(board, (db) => lastSession(db, task.id, slot));
+  if (prev?.close_requested && !prev.closed_at) {
+    closeRequested(board, { undelivered: [] });
+    prev = tx(board, (db) => lastSession(db, task.id, slot));
+  }
   let session = null;
   let replaced = null;
   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)) {
+    // a session the board closed, or one whose close its own command asked for (the next tick's sweep closes that
+    // run's pane), is not kept, whatever a fleet reading taken before the close still lists
+    if (!prev.closed_at && !prev.close_requested && 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, close_requested: _q, closed_at: _c, ...kept } = prev;
       session = { ...kept, mode: 'adopt', launched_at: now(), seen_at: now() };

package/package.json

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