@volter/supercode-orchestrator 0.4.106 → 0.4.107

package/board/dispatch.mjs

@@ -63,6 +63,8 @@ function sc(args, { input = null, timeout = 120_000, as = null } = {}) {
 }
 
 const lastJson = (text) => {
+  const whole = json(text.trim(), null);
+  if (whole && typeof whole === 'object') return whole;
   const line = text.split('\n').map((l) => l.trim()).filter((l) => l.startsWith('{') || l.startsWith('[')).pop();
   return line ? json(line, null) : null;
 };
@@ -120,6 +122,16 @@ const pause = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0,
 
 const sessionAlive = (fleet, session) => Boolean(session?.session_id) && [...fleet.alive].some((a) => a.endsWith(`:${session.session_id}`));
 
+/** Match a manual continuation by the same harness identity and an actually live machine pane. */
+function continuationPane(fleet, session, panes) {
+  if (!session?.session_id || !(panes instanceof Set)) return null;
+  const candidates = new Set((fleet.sessions ?? []).filter((s) => s.address === addressOf(session) && s.pane && panes.has(s.pane)).map((s) => s.pane));
+  if (session.pane && panes.has(session.pane)) candidates.add(session.pane);
+  if (candidates.size > 1) throw new Error(`session ${session.session_id} has multiple live panes: ${[...candidates].join(', ')}; close the extra pane before continuing`);
+  return [...candidates][0] ?? null;
+}
+
+
 function pidAlive(pid) {
   if (!pid) return false;
   try { process.kill(pid, 0); return true; } catch (error) { return error.code === 'EPERM'; }
@@ -191,7 +203,17 @@ function supervise(board, fleet, settings, report, entry, effects) {
       const task = getTask(db, id);
       if (!task || (entry.workflow.run ? !task.current_run_id : task.status !== 'running')) return;
       const runRow = currentRun(db, id);
-      const session = runRow?.metadata?.supercode ?? null;
+      let session = runRow?.metadata?.supercode ?? null;
+      if (session?.pane) {
+        let found;
+        try { found = continuationPane(fleet, session, observed.get(session.machine)); }
+        catch (error) { report.failed.push([id, error.message]); return; }
+        if (found && found !== session.pane) {
+          session = { ...session, pane: found, seen_at: now(), missing_since: null, close_requested: null, closed_at: null, close_confirmed_at: null, close_error: null };
+          setRunSession(db, runRow.id, session);
+          event(db, id, 'session_rebound', { session_id: session.session_id, pane: found }, runRow.id);
+        }
+      }
       const t = now();
       // what the dispatcher saw becomes a platform event; the card's workflow says what it does
       const observe = (name, payload, bucket) => {
@@ -485,10 +507,6 @@ export function closeRequested(board, report, { taskId = null, caller = null } =
     if (!session?.pane || session.close_confirmed_at || (!row.ended_at && !session.close_requested)) continue;
     if (caller && session.session_id === caller) continue; // let the command that ended its own run return
     const active = view(board, (db) => db.prepare(`SELECT r.id, r.metadata FROM task_runs r WHERE r.ended_at IS NULL OR EXISTS (SELECT 1 FROM tasks t WHERE t.current_run_id = r.id)`).all());
-    if (active.some((r) => {
-      const s = json(r.metadata, {})?.supercode;
-      return s?.pane === session.pane && normalMachine(s.machine) === normalMachine(session.machine);
-    })) continue;
     // Persist retries even for historical ends that did not have a close_session action.
     tx(board, (db) => requestSessionClose(db, row.task_id, { runId: row.id }));
     let error = null;
@@ -676,6 +694,16 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
     .find((r) => r.session?.pane && (r.session.slot ?? 'worker') === slot && (r.ended_at || r.session.close_requested) && !r.session.close_confirmed_at);
   if (pending) throw new Error(`slot ${slot} still owns pane ${pending.session.pane} from run ${pending.id}; closure must be confirmed before another session starts: ${pending.session.close_error ?? 'close pending'}`);
   let prev = view(board, (db) => lastSession(db, task.id, slot));
+  if (prev?.session_id && !prev.forgotten && (prev.harness ?? 'claude-code') === harness && prev.machine === machine) {
+    const fresh = observeFleet();
+    if (!fresh.ok) throw new Error(`cannot check for a manual continuation of ${prev.session_id}: ${fresh.error}`);
+    const r = sc(['teams', 'panes', 'ls', '--machine', machine], { timeout: 60_000 });
+    const listed = r.code === 0 ? json(r.stdout.trim(), null) : null;
+    if (!Array.isArray(listed)) throw new Error(`cannot read panes before continuing ${prev.session_id}: ${(r.stderr || r.stdout).trim().slice(-300)}`);
+    const pane = continuationPane(fresh, prev, new Set(listed.map((p) => p.pane)));
+    if (pane && pane !== prev.pane) prev = { ...prev, pane, close_requested: null, closed_at: null, close_confirmed_at: null, close_error: null };
+    fleet = fresh;
+  }
   if (prev?.close_requested && !prev.closed_at) {
     const report = { undelivered: [] };
     closeRequested(board, report, { taskId: task.id });
@@ -886,6 +914,12 @@ export function adoptSession(board, id, who, { workspace = null, ttl, assignee =
   if (!found) throw new Error(`the fleet lists no live session ${who}`);
   const [, host, harness, sessionId] = found.address.split(':');
   if (!HARNESSES[harness]) throw new Error(`${found.address} is ${harness}; the board keeps and resumes ${Object.keys(HARNESSES).join(' and ')} sessions`);
+  if (!found.pane || !panePresent(host, found.pane)) throw new Error(`${found.address} has no verified live pane`);
+  const beforeRun = view(board, (db) => currentRun(db, id));
+  const beforeSession = beforeRun?.metadata?.supercode;
+  if (beforeRun && beforeSession?.session_id !== sessionId) throw new Error(`${id} has another active run/session; end it before adopting a different identity`);
+  if (beforeSession?.pane && beforeSession.pane !== found.pane && panePresent(beforeSession.machine, beforeSession.pane)) throw new Error(`${id} still has live pane ${beforeSession.pane}; close the extra pane before rebinding ${sessionId}`);
+
   // the session's own working directory, as discovery records it (where `--resume` finds it), else its pane's
   let dir = workspace;
   if (!dir) {
@@ -899,7 +933,8 @@ export function adoptSession(board, id, who, { workspace = null, ttl, assignee =
   return tx(board, (db) => {
     const task = getTask(db, id);
     if (!task) throw new Error(`no card ${id}`);
-    if (task.status === 'running') throw new Error(`${id} is running already`);
+    if ((task.current_run_id ?? null) !== (beforeRun?.id ?? null)) throw new Error(`${id} changed runs during adoption; retry against its current run`);
+    if (beforeRun && assignee && assignee !== task.assignee) throw new Error('rebinding a session does not reassign its active run');
     if (task.machine && normalMachine(task.machine) !== host) throw new Error(`${id} runs on ${task.machine}, and ${found.address} is on ${host}; move the card first`);
     const was = lastSession(db, id);
     if (was && was.session_id !== sessionId && sessionAlive(fleet, was)) throw new Error(`${id} already has a live session, ${was.address}`);
@@ -910,11 +945,12 @@ export function adoptSession(board, id, who, { workspace = null, ttl, assignee =
       db.prepare("UPDATE tasks SET workspace_kind = 'dir', workspace_path = ? WHERE id = ?").run(dir.replace(/^dir:/, ''), id);
     }
     // the workflow's adopt event: the card is claimed for its implementer, whose session this now is
-    fire(db, board, workflowFor(board.root), id, 'adopt', { roles: ['manager'], payload: { lock: claimer() } });
+    const entry = workflowFor(board.root);
+    if (!beforeRun) fire(db, board, entry, id, entry.workflow.run ? entry.workflow.dispatch.start : 'adopt', { roles: ['manager'], payload: { lock: claimer() } });
     const runId = getTask(db, id).current_run_id;
     if (!runId) throw new Error(`${id} waits on parents that are not done`);
     const session = { surface: 'pane', session_id: sessionId, harness, machine: host, pane: found.pane ?? null, address: found.address, mode: 'adopt', launched_at: now(), seen_at: now() };
-    setRunSession(db, runId, { ...(currentRun(db, id)?.metadata?.supercode ?? {}), ...session, slot: 'worker' });
+    setRunSession(db, runId, { ...(currentRun(db, id)?.metadata?.supercode ?? {}), ...session, slot: beforeSession?.slot ?? 'worker', close_requested: null, closed_at: null, close_confirmed_at: null, close_error: null, missing_since: null });
     event(db, id, 'session_adopted', { session_id: sessionId, machine: host, pane: session.pane, address: found.address, mode: 'adopt' }, runId);
     subscribeIn(db, id, found.address, 'worker');
     for (const p of db.prepare('SELECT parent_id FROM task_links WHERE child_id = ?').all(id)) subscribeIn(db, p.parent_id, found.address, 'dependency');

package/board/ztrack.mjs

@@ -528,12 +528,18 @@ class ZtrackBoard {
       if (!compat.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='supercode_export_events'").get()) {
         compat.exec(`CREATE TABLE supercode_export_events (source_id INTEGER PRIMARY KEY, event_id INTEGER NOT NULL UNIQUE)`);
         compat.exec(`INSERT INTO supercode_export_events SELECT id, id FROM task_events WHERE json_extract(payload, '$.__supercode_export') = 1`);
+        // Repair existing lowered holds on upgrade, once; subsequent exports stay proportional to changes.
+        for (const state of this.mem.prepare('SELECT task_id, paused, blocked_by FROM supercode_cards').all()) {
+          if (!json(state.paused, null) && !json(state.blocked_by, []).some((b) => b.kind === 'message')) continue;
+          projected.add(state.task_id); projectStatus(this.mem, this.board(), entry, state.task_id);
+        }
       }
       // Every import is event-based. Existing unconsumed acts must never be erased by an export race.
       const cursor = this.get('hermes_cursor', 0);
       const unseen = compat.prepare('SELECT payload FROM task_events WHERE id > ?').all(cursor).some((r) => !json(r.payload, {})?.__supercode_export);
       if (unseen) throw new Error('Hermes wrote during board export; retained its events for the next read');
       const sources = new Map(changes.map(c => [`${c.source.name}:${c.source.key}`, c.source]));
+      for (const id of projected) sources.set(`tasks:${JSON.stringify([id])}`, { name: 'tasks', key: JSON.stringify([id]), row: this.mem.prepare('SELECT * FROM tasks WHERE id = ?').get(id) });
       for (const source of [...sources.values()]) {
         const id = source.name === 'tasks' ? source.row?.id : source.name === 'supercode_cards' ? source.row?.task_id : null;
         if (id) sources.set(`tasks:${JSON.stringify([id])}`, {name:'tasks',key:JSON.stringify([id]),row:this.mem.prepare('SELECT * FROM tasks WHERE id=?').get(id)});

package/package.json

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