@volter/supercode-orchestrator 0.4.68 → 0.4.70

package/board/dispatch.mjs

@@ -632,7 +632,12 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
   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) {
+  else if (prev && (prev.harness ?? 'claude-code') !== harness) {
+    // the card was reassigned to a lane of another harness: that harness starts it fresh (the card's text and thread
+    // are its context), and the last session, if still open, is closed so two harnesses never work one card
+    if (prev.pane && !prev.closed_at) stopSession(board, prev);
+    replaced = { session_id: prev.session_id, why: `the card's lane runs ${harness}, not ${prev.harness ?? 'claude-code'}`, letGo: true };
+  } else if (prev && prev.machine === machine) {
     // 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)) {
@@ -656,8 +661,8 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
     } 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) {
+  // workflow let go (`forget_session`) or its manager did (a reassignment to another harness's lane) is replaced
+  if (replaced && !prev?.forgotten && !replaced.letGo) {
     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;

package/board.mjs

@@ -1,10 +1,10 @@
 // The home's board, dispatched while the orchestrator serves the home (docs/architecture/orchestrator.md §2.9,
 // docs/plans/hermes-compat.md row 14). The board and its dispatcher are supercode's own (`board/`): Hermes Kanban's
 // format and lifecycle, each profile's lane decided by its `worker` in the IR. Where a Hermes gateway would run
-// its dispatcher, the daemon runs this one the same way: gated by `kanban.dispatch_in_gateway` (and
-// `HERMES_KANBAN_DISPATCH_IN_GATEWAY`), holding the board's one-dispatcher lock (`kanban/.dispatcher.lock`, the
-// lock Hermes's gateways take, so the two never dispatch one board together), one tick every
-// `kanban.dispatch_interval_seconds` (60, at least 1), the first after five seconds. Each tick runs as
+// its dispatcher, the daemon runs this one the same way: when the board's workflow says so (its `dispatch.serve`),
+// holding the board's one-dispatcher lock (`kanban/.dispatcher.lock`, the
+// lock Hermes's gateways take, so the two never dispatch one board together), one tick every `dispatch.tick` seconds
+// of the workflow (at least 1), the first after five seconds. Each tick runs as
 // `workflow dispatch` in a child process: a tick waits on supercode (the fleet, launches, mail), and the daemon's
 // own loop never does.
 import { spawn } from 'node:child_process';
@@ -34,8 +34,6 @@ function dispatchOnce(root) {
 
 /** Start the board's dispatcher for the home at `root`; answers `{ tick, stop }`, or null when it does not dispatch. */
 export async function startBoard({ root, orchestration = null, log = () => {}, adapters = {}, wake = null }) {
-  const off = String(process.env.HERMES_KANBAN_DISPATCH_IN_GATEWAY ?? '').trim().toLowerCase();
-  if (['0', 'false', 'no', 'off'].includes(off)) { log('info', 'board: not dispatched (HERMES_KANBAN_DISPATCH_IN_GATEWAY)'); return null; }
   // whether and how often the served home dispatches is the board workflow's (`dispatch.serve`, `dispatch.tick`)
   let entry;
   try { entry = workflowEntry(orchestration); } catch (error) { log('warn', `board: not dispatched: ${error.message}`); return null; }

package/package.json

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