@volter/supercode-orchestrator 0.4.106 → 0.4.108

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/engine.mjs

@@ -204,7 +204,8 @@ export function createCard(board, spec) {
       inheritSubscriptions(db, id, [arc.id], { workers: true });
       event(db, arc.id, 'subtask_added', { subtask: id, title });
     }
-    if (initial === 'running') claimIn(db, id, { ttl: claimTtl() });
+    if (initial === 'running' && arc && entry.workflow.run) setStatus(db, entry.workflow, id, 'running');
+    else if (initial === 'running') claimIn(db, id, { ttl: claimTtl() });
     return { id, existing: false };
   });
 }
@@ -247,6 +248,7 @@ export function claim(board, id, { ttl, lock = claimer(), expectStatus = 'ready'
 
 /** `claim` inside the caller's own transaction (a dispatcher's guard and claim see one state). */
 export function claimIn(db, id, { ttl = claimTtl(), lock = claimer(), expectStatus = null } = {}) {
+  if (getTask(db, id)?.subtask_of) throw new Error('a subtask is worked by its arc and has no run of its own');
   // a triage card is claimed to be specified, which does not wait on its parents
   if (expectStatus !== 'triage' && !parentsDone(db, id)) {
     run(db, "UPDATE tasks SET status = 'todo' WHERE id = ? AND status = 'ready'", id);

package/board/rows.mjs

@@ -2,7 +2,7 @@
 // tables, run fields and small indexing metadata. No application locks or snapshot rewrites.
 import { json } from './store.mjs';
 const quote = s => `"${s.replaceAll('"', '""')}"`;
-const RUNTIME = new Set(['claim_lock','claim_expires','worker_pid','last_heartbeat_at','current_run_id','consecutive_failures','last_failure_error','block_recurrences','session_id']);
+const RUNTIME = new Set(['claim_lock','claim_expires','worker_pid','last_heartbeat_at','current_run_id','consecutive_failures','last_failure_error','block_recurrences','session_id','workspace_path']);
 const OMIT = new Set(['tasks','supercode_cards','task_links','sqlite_sequence']);
 export class RuntimeRows {
   constructor(db) { this.db=db; this.revision=null; this.tables=new Map(); this.runtime={}; this.clocks={}; this.cachedTasks={}; this.cachedCards={}; }

package/board/ztrack.mjs

@@ -14,7 +14,7 @@ const hash = (text) => createHash('sha256').update(text).digest('hex');
 const read = (path) => existsSync(path) ? readFileSync(path, 'utf8') : '';
 const quote = (s) => `"${s.replaceAll('"', '""')}"`;
 const nativeId = (id) => /^t-[a-f0-9]+$/.test(id) ? id.replace('t-', 't_') : id;
-const RUNTIME = new Set(['claim_lock', 'claim_expires', 'worker_pid', 'last_heartbeat_at', 'current_run_id', 'consecutive_failures', 'last_failure_error', 'block_recurrences', 'session_id']);
+const RUNTIME = new Set(['claim_lock', 'claim_expires', 'worker_pid', 'last_heartbeat_at', 'current_run_id', 'consecutive_failures', 'last_failure_error', 'block_recurrences', 'session_id', 'workspace_path']);
 const CARD_MAIN = new Set(['id', 'title', 'body', 'status', 'assignee', 'priority', 'workspace_kind', 'workspace_path', 'branch_name']);
 const EPHEMERAL = new Set(['tasks', 'supercode_cards', 'task_links', 'sqlite_sequence']);
 const atomic = (path, text) => { const tmp = `${path}.${process.pid}.tmp`; writeFileSync(tmp, text, { mode: 0o600 }); renameSync(tmp, path); };
@@ -370,7 +370,7 @@ class ZtrackBoard {
     const workspace = /^(scratch|dir|worktree)(?::(.*))?$/.exec(card.workspace ?? 'scratch');
     this.insert('tasks', { ...meta, ...this.saved.runtime?.[id], id, title: card.title, body: stored.body,
       status: card.status, assignee: card.assignee ?? null, created_at: meta.created_at ?? now(), priority: card.priority ?? 0,
-      workspace_kind: workspace?.[1] ?? 'scratch', workspace_path: workspace?.[2] ?? null, branch_name: card.branch ?? null });
+      workspace_kind: workspace?.[1] ?? 'scratch', workspace_path: workspace?.[1] === 'scratch' ? (this.saved.runtime?.[id]?.workspace_path ?? meta.workspace_path ?? null) : workspace?.[2] ?? null, branch_name: card.branch ?? null });
     this.insert('supercode_cards', { ...this.saved.clocks?.[id], task_id: id, stage: card.status, machine: card.machine ?? null, subtask_of: parent,
       blocked_by: JSON.stringify((card.relations ?? []).map((r) => ({ ...(meta.blocked_by ?? []).find((b) => b.id === nativeId(r.issueId)), id: nativeId(r.issueId), kind: /^[ma]-/.test(r.issueId) ? 'message' : 'card' }))),
       paused: card.paused ? JSON.stringify(card.paused) : null, archived: meta.archived ? 1 : 0, every: card.every ?? null });
@@ -419,7 +419,7 @@ class ZtrackBoard {
       const metadata = Object.fromEntries(Object.entries(row).filter(([k, v]) => !RUNTIME.has(k) && !CARD_MAIN.has(k) && v != null));
       if (c.archived) metadata.archived = true;
       if (json(c.blocked_by, []).length) metadata.blocked_by = json(c.blocked_by, []);
-      cards.set(row.id, { ...parsed, metadata, priority: row.priority ?? 0, workspace: row.workspace_kind + (row.workspace_path ? `:${row.workspace_path}` : ''),
+      cards.set(row.id, { ...parsed, metadata, priority: row.priority ?? 0, workspace: row.workspace_kind + (row.workspace_kind !== 'scratch' && row.workspace_path ? `:${row.workspace_path}` : ''),
         branch: row.branch_name || undefined, machine: c.machine || undefined, paused: json(c.paused, null) ?? undefined, every: c.every || undefined,
         relations: json(c.blocked_by, []).map((b) => ({ type: 'blocked-by', issueId: this.fileIds.get(b.id) ?? b.id })), acceptanceCriteria: [] });
     }
@@ -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.108",
   "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": {