@volter/supercode-orchestrator 0.4.105 → 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) => {
@@ -299,7 +321,7 @@ function stopSession(board, session) {
   }
   if (session.pane) {
     const r = sc(['teams', 'panes', 'close', session.pane, ...(session.machine ? ['--machine', session.machine] : [])], { timeout: 60_000, as: boardAddress(board.label) });
-    if (r.code !== 0 || lastJson(r.stdout)?.closed !== session.pane) throw new Error(`closing pane ${session.pane}: ${(r.stderr || r.stdout || `exit ${r.code}`).trim().slice(-500)}`);
+    if (r.code !== 0 || json(r.stdout.trim(), null)?.closed !== session.pane) throw new Error(`closing pane ${session.pane}: ${(r.stderr || r.stdout || `exit ${r.code}`).trim().slice(-500)}`);
   }
 }
 
@@ -484,11 +506,7 @@ export function closeRequested(board, report, { taskId = null, caller = null } =
     const session = json(row.metadata, {})?.supercode;
     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 tasks t JOIN task_runs r ON r.id = t.current_run_id`).all());
-    if (active.some((r) => {
-      const s = json(r.metadata, {})?.supercode;
-      return r.id !== row.id && s?.pane === session.pane && normalMachine(s.machine) === normalMachine(session.machine);
-    })) continue;
+    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());
     // 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;
@@ -501,7 +519,12 @@ export function closeRequested(board, report, { taskId = null, caller = null } =
       }
       const observed = panes.get(machine);
       if (observed.error) throw new Error(observed.error);
-      if (observed.live.has(session.pane)) { stopSession(board, session); observed.live.delete(session.pane); }
+      if (observed.live.has(session.pane)) {
+        const protectedNow = view(board, (db) => db.prepare(`SELECT 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())
+          .some((r) => { const s = json(r.metadata, {})?.supercode; return s?.pane === session.pane && normalMachine(s.machine) === normalMachine(session.machine); });
+        if (protectedNow) continue;
+        stopSession(board, session); observed.live.delete(session.pane);
+      }
     } catch (e) { error = String(e.message).slice(-500); }
     tx(board, (db) => {
       const current = json(db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(row.id)?.metadata, {})?.supercode;
@@ -671,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 });
@@ -881,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) {
@@ -894,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}`);
@@ -905,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

@@ -12,7 +12,7 @@ import { existsSync, rmSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { view, claimer, event, json, newTaskId, now, tx } from './store.mjs';
-import { refreshCardInputs, requestSessionClose, eventTo, fire, loadWorkflow, setStatus, settle, startNew, statusOf, runEvent, workflowFor } from './workflow.mjs';
+import { addDependency, refreshCardInputs, requestSessionClose, eventTo, fire, loadWorkflow, setStatus, settle, startNew, statusOf, runEvent, workflowFor } from './workflow.mjs';
 
 export const STATUSES = ['triage', 'todo', 'scheduled', 'ready', 'running', 'blocked', 'review', 'done', 'archived'];
 export const WORKSPACE_KINDS = ['scratch', 'dir', 'worktree'];
@@ -191,9 +191,9 @@ export function createCard(board, spec) {
       spec.reasoning ?? null, spec.sessionId ?? null, spec.project ?? null, spec.goal ? 1 : 0, spec.goal?.maxTurns ?? null);
     const machine = spec.machine ?? arc?.machine ?? null;
     if (machine || arc) run(db, 'INSERT OR REPLACE INTO supercode_cards (task_id, machine, subtask_of) VALUES (?, ?, ?)', id, machine, arc?.id ?? null);
-    for (const p of parents) run(db, 'INSERT OR IGNORE INTO task_links (parent_id, child_id) VALUES (?, ?)', p, id);
-    // where it starts is the workflow's `initial` (Hermes: triage, blocked, todo behind open parents, else ready)
     const entry = workflowFor(board.root);
+    for (const p of parents) addDependency(db, entry, id, p);
+    // where it starts is the workflow's `initial` (Hermes: triage, blocked, todo behind open parents, else ready)
     // the create's own words: whether it asked to be a goal card (null: the workflow decides), triage, its arc
     const status = startNew(db, board, entry, getTask(db, id), { triage: Boolean(spec.triage), initial_status: initial,
       every: spec.every ?? null, goal: spec.goal === undefined || spec.goal === null ? null : spec.goal !== false, subtask_of: arc?.id ?? null });

package/board/workflow.mjs

@@ -521,6 +521,9 @@ const ACTIONS = {
       blocks = blocks.filter((b) => remove === 'messages' ? b.kind !== 'message' : remove !== '*' && b.id !== remove);
     }
     cardField(ctx, 'blocked_by', JSON.stringify(blocks));
+    // task_links is the Hermes projection of the canonical card relations, including within this transaction.
+    run(ctx.db, 'DELETE FROM task_links WHERE child_id = ?', ctx.id);
+    for (const block of blocks.filter((b) => b.kind === 'card')) run(ctx.db, 'INSERT OR IGNORE INTO task_links (parent_id, child_id) VALUES (?, ?)', block.id, ctx.id);
   },
   flag(ctx, { name, value, reason = null }) {
     if (!['paused', 'archived'].includes(name)) throw new Error(`unknown flag ${name}`);
@@ -712,6 +715,12 @@ const ACTIONS = {
   send_to_actor(ctx, text) { ctx.effects.push({ kind: 'send_to_actor', id: ctx.id, text }); },
 };
 
+/** The create door uses the instance's canonical dependency representation. */
+export function addDependency(db, entry, id, parent) {
+  if (entry.workflow.relations?.blocked_by) ACTIONS.relation({ db, id }, { add: parent, reason: 'declared dependency' });
+  else run(db, 'INSERT OR IGNORE INTO task_links (parent_id, child_id) VALUES (?, ?)', parent, id);
+}
+
 /** Persist close intent in the same transaction as the transition; I/O can fail or never run. */
 export function requestSessionClose(db, id, { runId = null, slot = null, through = null } = {}) {
   for (const row of all(db, 'SELECT id, metadata FROM task_runs WHERE task_id = ?', id)) {

package/board/ztrack.mjs

@@ -523,11 +523,23 @@ class ZtrackBoard {
     const compat = new DatabaseSync(this.compatPath);
     try {
       compat.exec('BEGIN'); this.init(compat, { fresh: true });
+      // Native events and Hermes events share an export database, not an id sequence.
+      // Bootstrap the old identity mapping once; new exports allocate independent Hermes ids.
+      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)});
@@ -535,14 +547,49 @@ class ZtrackBoard {
       for (const {name,key,row:source} of sources.values()) {
         if (!compat.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(name)) continue;
         const table = this.rows.tables.get(name);
+        if (name === 'task_events') {
+          const sourceId = JSON.parse(key)[0];
+          const mapped = compat.prepare('SELECT event_id FROM supercode_export_events WHERE source_id = ?').get(sourceId);
+          if (!source) {
+            if (mapped) compat.prepare('DELETE FROM task_events WHERE id = ?').run(mapped.event_id);
+            compat.prepare('DELETE FROM supercode_export_events WHERE source_id = ?').run(sourceId);
+            continue;
+          }
+          const row = { ...source, payload: JSON.stringify({ ...json(source.payload, {}), __supercode_export: true }) };
+          delete row.id;
+          const keys = Object.keys(row);
+          if (mapped) {
+            const previous = compat.prepare('SELECT * FROM task_events WHERE id = ?').get(mapped.event_id);
+            if (previous && keys.every((k) => previous[k] === row[k])) continue;
+            compat.prepare(`UPDATE task_events SET ${keys.map((k) => `${quote(k)} = ?`).join(',')} WHERE id = ?`).run(...keys.map((k) => row[k]), mapped.event_id);
+          } else {
+            const inserted = compat.prepare(`INSERT INTO task_events (${keys.map(quote)}) VALUES (${keys.map(() => '?')})`).run(...keys.map((k) => row[k]));
+            compat.prepare('INSERT INTO supercode_export_events (source_id, event_id) VALUES (?, ?)').run(sourceId, inserted.lastInsertRowid);
+          }
+          continue;
+        }
         if (!source) { compat.prepare(`DELETE FROM ${quote(name)} WHERE ${table.keys.map(k=>`${quote(k)} IS ?`).join(' AND ')}`).run(...JSON.parse(key)); continue; }
         const row = {...source};
-        if (name === 'task_events') row.payload = JSON.stringify({...json(row.payload,{}),__supercode_export:true});
         const keys=Object.keys(row);
         const previous=compat.prepare(`SELECT * FROM ${quote(name)} WHERE ${table.keys.map(k=>`${quote(k)} IS ?`).join(' AND ')}`).get(...JSON.parse(key));
         if (previous && keys.every(k=>previous[k]===row[k]))continue;
         compat.prepare(`INSERT OR REPLACE INTO ${quote(name)} (${keys.map(quote)}) VALUES (${keys.map(()=>'?')})`).run(...keys.map(k=>row[k]));
       }
+      // Hermes recomputes ready on read. Its sticky block is the last blocked/unblocked event,
+      // so lowering the status alone cannot preserve a pause (including one made by a document edit).
+      for (const id of projected) {
+        const state = compat.prepare('SELECT t.status, c.stage, c.paused, c.blocked_by FROM tasks t JOIN supercode_cards c ON c.task_id = t.id WHERE t.id = ?').get(id);
+        if (!state) continue;
+        const sticky = state.status === 'blocked' && (json(state.paused, null) || json(state.blocked_by, []).some((b) => b.kind === 'message'));
+        const last = compat.prepare("SELECT kind, payload FROM task_events WHERE task_id = ? AND kind IN ('blocked','unblocked') ORDER BY id DESC LIMIT 1").get(id);
+        if (sticky) compat.prepare("UPDATE tasks SET block_kind = 'needs_input' WHERE id = ?").run(id);
+        const cleared = !sticky && json(last?.payload, {})?.__supercode_sticky;
+        if ((sticky && last?.kind !== 'blocked') || (cleared && last?.kind === 'blocked')) {
+          const payload = { __supercode_export: true, __supercode_sticky: true, block_kind: 'needs_input', source_status: state.stage,
+            reason: json(state.paused, null)?.reason ?? (sticky ? 'waiting on a message' : 'lowered hold cleared') };
+          compat.prepare('INSERT INTO task_events (task_id, kind, payload, created_at) VALUES (?, ?, ?, ?)').run(id, sticky ? 'blocked' : 'unblocked', JSON.stringify(payload), now());
+        }
+      }
       compat.exec('COMMIT');
       // Exported events carry an origin marker and never advance the Hermes input cursor.
     } catch (error) { try { compat.exec('ROLLBACK'); } catch {} throw error; }

package/package.json

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