@volter/supercode-orchestrator 0.4.105 → 0.4.106

package/board/dispatch.mjs

@@ -299,7 +299,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,10 +484,10 @@ 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());
+    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 r.id !== row.id && s?.pane === session.pane && normalMachine(s.machine) === normalMachine(session.machine);
+      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 }));
@@ -501,7 +501,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;

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,6 +523,12 @@ 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`);
+      }
       // 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);
@@ -535,14 +541,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.106",
   "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": {