@volter/supercode-orchestrator 0.4.91 → 0.4.93

package/board/cli.mjs

@@ -9,7 +9,7 @@ import { spawnSync } from 'node:child_process';
 import { basename, join, resolve } from 'node:path';
 import { tmpdir } from 'node:os';
 import { read } from '../orchestration.mjs';
-import { backingPaths, layOut, backingOf, boardExists, boardPath, DEFAULT_BOARD, event, json, listBoards, logsDir, now, openBoard, setActor, tx } from './store.mjs';
+import { view, backingPaths, layOut, backingOf, boardExists, boardPath, DEFAULT_BOARD, event, json, listBoards, logsDir, now, openBoard, setActor, tx } from './store.mjs';
 import { openZtrackBoard } from './ztrack.mjs';
 import * as engine from './engine.mjs';
 import { adoptSession, boardAddress, boardLabel, boardSettings, callerSession, lanesOf, localMachine, observeFleet, paused, plan, startCard, tick } from './dispatch.mjs';
@@ -304,7 +304,7 @@ export async function runWorkflow(argv) {
       // the creator hears what happens from here on; a start answered above is not told twice
       const address = args['no-notify'] ? null : args.notify ?? callerAddress();
       if (address) withBoard((b) => engine.subscribe(b, created.id, address, 'creator'));
-      const task = withBoard((b) => tx(b, (db) => engine.getTask(db, created.id)));
+      const task = withBoard((b) => view(b, (db) => engine.getTask(db, created.id)));
       if (args.json) { say(args, '', { ...cardDict(task), ...answer, notify: address ?? null }); return answer.failed ? 1 : 0; }
       const said = answer.started ? `; started session ${answer.session} (${answer.mode})` : answer.failed ? `; did not start: ${answer.failed}` : answer.waits ? `; waits: ${answer.waits}` : '';
       say(args, `${created.existing ? 'Existing' : 'Created'} ${created.id}  (${task.status}, assignee=${task.assignee || '-'})${said}${address ? `; notices go to ${address}` : ''}`, null);
@@ -435,7 +435,7 @@ export async function runWorkflow(argv) {
       return 0;
     }
 
-    case 'context': need(1, 'a card id'); process.stdout.write(`${withBoard((b) => tx(b, (db) => engine.cardContext(db, id)))}\n`); return 0;
+    case 'context': need(1, 'a card id'); process.stdout.write(`${withBoard((b) => view(b, (db) => engine.cardContext(db, id)))}\n`); return 0;
 
     case 'runs': {
       need(1, 'a card id');
@@ -471,7 +471,7 @@ export async function runWorkflow(argv) {
       const ttl = args.ttl ? duration(args.ttl) : engine.claimTtl();
       const runId = withBoard((b) => engine.claim(b, id, { ttl }));
       if (!runId) throw new Error(`cannot claim ${id} (not ready, already claimed, or waiting on parents)`);
-      const task = withBoard((b) => tx(b, (db) => engine.getTask(db, id)));
+      const task = withBoard((b) => view(b, (db) => engine.getTask(db, id)));
       // Hermes's claim resolves the workspace and prints it; a scratch one is made under the board's workspaces
       let workspace = task.workspace_path;
       if (!workspace && task.workspace_kind === 'scratch') {
@@ -658,7 +658,7 @@ export async function runWorkflow(argv) {
       const file = join(logsDir(root, slug), `${id}.log`);
       if (!existsSync(file)) {
         // a pane session keeps no log file: its transcript is the harness's own, named by the run
-        const s = withBoard((b) => tx(b, (db) => engine.lastSession(db, id)));
+        const s = withBoard((b) => view(b, (db) => engine.lastSession(db, id)));
         process.stdout.write(s ? `(${id} runs as session ${s.address}; its transcript is that session's: \`supercode sessions show ${s.session_id}\`)\n` : `(no log for ${id})\n`);
         return 0;
       }

package/board/dispatch.mjs

@@ -21,7 +21,7 @@ import { hostname, tmpdir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
-import { boardPath, claimer, event, json, listBoards, logsDir, now, openBoard, setActor, tx } from './store.mjs';
+import { view, boardPath, claimer, event, json, listBoards, logsDir, now, openBoard, setActor, tx } from './store.mjs';
 import { doors, fire, loadWorkflow, resumeOf, runSpec, refreshRelationAnswers, transitionsFor, scopeOf, statusOf, templateValue, workflowFor } from './workflow.mjs';
 import { evaluate, holds, render } from './expr.mjs';
 import {
@@ -417,22 +417,22 @@ function startCards(board, fleet, lanes, settings, report, entry, effects, { onl
 /** Launch what the card's status runs: its role's lane, in the run's session slot, told the run's prompt and doors. */
 export function launchRun(board, entry, id, lane, fleet, settings) {
   const task = getTaskNow(board, id);
-  const status = tx(board, (db) => statusOf(db, task));
+  const status = view(board, (db) => statusOf(db, task));
   const spec = runSpec(entry, status, task);
   if (!spec) return null;
   const runId = task.current_run_id;
   const surface = lane.surface === 'pane' ? 'pane' : 'headless';
-  const scope = tx(board, (db) => scopeOf(db, board, task, { params: entry.params }));
+  const scope = view(board, (db) => scopeOf(db, board, task, { params: entry.params }));
   const where = whereOf(board, task);
   // a subtask's run also sees its arc: the arc's text, tasks and thread (where its owner's rulings are)
-  const arcContext = task.subtask_of ? tx(board, (db) => cardContext(db, task.subtask_of)) : '';
-  const prompt = render(spec.prompt, { ...scope, where, context: tx(board, (db) => cardContext(db, id)), arc_context: arcContext, doors: doors(entry.workflow, status, spec.role, id, where, surface) });
+  const arcContext = task.subtask_of ? view(board, (db) => cardContext(db, task.subtask_of)) : '';
+  const prompt = render(spec.prompt, { ...scope, where, context: view(board, (db) => cardContext(db, id)), arc_context: arcContext, doors: doors(entry.workflow, status, spec.role, id, where, surface) });
   // the run's session record knows its status, role and slot (a reviewer's slot is never the implementer's); the slot
   // is a template, so a step can ask for isolation by naming a new one
   const slot = String(templateValue(spec.session ?? 'worker', scope) ?? 'worker');
   if (spec.role === 'reviewer') {
-    const worker = tx(board, (db) => lastSession(db, id, 'worker'));
-    const reviewer = tx(board, (db) => lastSession(db, id, slot));
+    const worker = view(board, (db) => lastSession(db, id, 'worker'));
+    const reviewer = view(board, (db) => lastSession(db, id, slot));
     if (slot === 'worker' || (worker?.session_id && worker.session_id === reviewer?.session_id)) throw new Error('a reviewer must have a different session from the implementer');
   }
   const meta = { status, role: spec.role, slot };
@@ -448,7 +448,7 @@ export async function startCard(board, id, { roles = ['manager'], lanes, setting
   const moved = tx(board, (db) => fire(db, board, entry, id, entry.workflow.dispatch.start, { roles, payload: { lock: claimer() } }));
   const task = getTaskNow(board, id);
   const spec = runSpec(entry, moved.to, task);
-  const profile = spec ? tx(board, (db) => evaluate(entry.workflow.roles?.[spec.role] ?? 'card.assignee', scopeOf(db, board, task, { params: entry.params }))) : null;
+  const profile = spec ? view(board, (db) => evaluate(entry.workflow.roles?.[spec.role] ?? 'card.assignee', scopeOf(db, board, task, { params: entry.params }))) : null;
   const lane = profile ? lanes[profile] : null;
   if (spec && !lane) throw new Error(`${id} is ${moved.to}, run by ${spec.role} (${profile ?? 'nobody'}), which is no lane of this home`);
   return lane ? launchRun(board, entry, id, lane, fleet, settings) : null;
@@ -507,7 +507,7 @@ function observeIdle(board, fleet, settings, report, entry, effects) {
 /** A session effect a committed move asked for: a message to the card's current actor, or closing a slot's pane. */
 export async function sessionEffect(board, e) {
   if (e.kind === 'send_to_actor') {
-    const run = tx(board, (db) => currentRun(db, e.id));
+    const run = view(board, (db) => currentRun(db, e.id));
     const session = run?.metadata?.supercode;
     const address = addressOf(session);
     if (!address) return;
@@ -515,7 +515,7 @@ export async function sessionEffect(board, e) {
     return;
   }
   if (e.kind === 'close_session') {
-    const rows = tx(board, (db) => db.prepare('SELECT id, metadata FROM task_runs WHERE task_id = ? ORDER BY id DESC').all(e.id));
+    const rows = view(board, (db) => db.prepare('SELECT id, metadata FROM task_runs WHERE task_id = ? ORDER BY id DESC').all(e.id));
     for (const row of rows) {
       // a run newer than the one that left the status is its successor, already started in this tick: not closed
       if (e.runId && row.id > e.runId) continue;
@@ -609,7 +609,7 @@ export function paused(root) {
 
 
 
-const getTaskNow = (board, id) => tx(board, (db) => getTask(db, id));
+const getTaskNow = (board, id) => view(board, (db) => getTask(db, id));
 
 
 function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'worker', meta = {} } = {}) {
@@ -628,11 +628,11 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
   // the slot's last session: kept when live, resumed when lost, never another slot's (a reviewer's is its own)
   // a close its session's own command asked for is carried out first, so its pane is gone before the slot's next
   // session starts (never two processes on one session)
-  let prev = tx(board, (db) => lastSession(db, task.id, slot));
+  let prev = view(board, (db) => lastSession(db, task.id, slot));
   if (prev?.close_requested && !prev.closed_at) {
     const report = { undelivered: [] };
     closeRequested(board, report);
-    prev = tx(board, (db) => lastSession(db, task.id, slot));
+    prev = view(board, (db) => lastSession(db, task.id, slot));
     // a pane that could not be closed still holds the session: no second process is started on it
     if (prev?.close_requested && !prev.closed_at) throw new Error(`the slot's session ${prev.session_id} asked to be closed and its pane ${prev.pane} could not be: ${report.undelivered.map((u) => u[2]).join('; ') || 'no reason given'}`);
   }
@@ -867,7 +867,7 @@ async function send(from, label, to, body, key, { queue = false, ask = false } =
  * (the id is the send's idempotency key). One that fails is tried again next tick.
  */
 async function sendBoardMessages(board, report) {
-  const rows = tx(board, (db) => db.prepare(`SELECT id, task_id, payload FROM task_events e WHERE kind = 'board_message' AND NOT EXISTS
+  const rows = view(board, (db) => db.prepare(`SELECT id, task_id, payload FROM task_events e WHERE kind = 'board_message' AND NOT EXISTS
     (SELECT 1 FROM task_events s WHERE s.kind = 'board_message_sent' AND s.task_id = e.task_id AND json_extract(s.payload, '$.event') = e.id) ORDER BY id`).all());
   for (const row of rows) {
     const m = json(row.payload, {}) ?? {};
@@ -937,7 +937,7 @@ async function notify(board, fleet, report, entry) {
       .all(sub.task_id, sub.last_event_id, ...kinds);
     if (!events.length) return;
     // the card as the workflow names it (its status the workflow's: triaging, reviewing, stopped; `stored_as` kanban.db's)
-    const task = tx(board, (db) => { const t = getTask(db, sub.task_id); return t ? { ...t, status: statusOf(db, t), stored_as: t.status } : t; });
+    const task = view(board, (db) => { const t = getTask(db, sub.task_id); return t ? { ...t, status: statusOf(db, t), stored_as: t.status } : t; });
     let cursor = Number(sub.last_event_id);
     let failed = null;
     try {
@@ -995,7 +995,7 @@ export async function notifyChats(root, adapters, log = () => {}, wake = null) {
         if (sub.platform === 'supercode' || !adapter) continue;
         const events = board.db.prepare(`SELECT id, kind, payload FROM task_events WHERE task_id = ? AND id > ? AND kind IN (${kinds.map(() => '?').join(', ')}) ORDER BY id`).all(sub.task_id, sub.last_event_id, ...kinds);
         if (!events.length) continue;
-        const task = tx(board, (db) => getTask(db, sub.task_id));
+        const task = view(board, (db) => getTask(db, sub.task_id));
         let cursor = Number(sub.last_event_id);
         let failed = false;
         for (const ev of events) {

package/board/engine.mjs

@@ -11,7 +11,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import { existsSync, rmSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
-import { claimer, event, json, newTaskId, now, tx } from './store.mjs';
+import { view, claimer, event, json, newTaskId, now, tx } from './store.mjs';
 import { refreshCardInputs, eventTo, fire, loadWorkflow, setStatus, settle, startNew, statusOf, runEvent, workflowFor } from './workflow.mjs';
 
 export const STATUSES = ['triage', 'todo', 'scheduled', 'ready', 'running', 'blocked', 'review', 'done', 'archived'];
@@ -80,7 +80,7 @@ export function endRun(db, taskId, { outcome, status = null, summary = null, err
   // terminates a reclaimed worker (a board's one-shot workers run where the board is); a pane session is a person-visible session and is never killed from the board
   const worker = outcome === 'reclaimed' ? json(was, {})?.supercode : null;
   const lock = one(db, 'SELECT claim_lock FROM task_runs WHERE id = ?', runId)?.claim_lock ?? one(db, 'SELECT claim_lock FROM tasks WHERE id = ?', taskId)?.claim_lock;
-  if (worker?.surface === 'headless' && worker.pid && String(lock ?? '').startsWith(`${claimer().split(':')[0]}:`)) terminate(Number(worker.pid));
+  if (worker?.surface === 'headless' && worker.pid && String(lock ?? '').startsWith(`${claimer().split(':')[0]}:`)) run(db, 'INSERT INTO supercode_effects(effect) VALUES(?)', JSON.stringify({kind:'stop_run',id:taskId,runId}));
   run(db, `UPDATE task_runs SET status = ?, outcome = ?, summary = ?, error = ?, metadata = ?, ended_at = ?, claim_lock = NULL, claim_expires = NULL, worker_pid = NULL
            WHERE id = ? AND ended_at IS NULL`, status ?? outcome, outcome, summary, error, keep, now(), runId);
   run(db, 'UPDATE tasks SET current_run_id = NULL WHERE id = ?', taskId);
@@ -285,9 +285,9 @@ export function extendClaim(db, id, { ttl, reason, extra = {} }) {
  * workspaces, or a worktree (its branch stays); never while a child still waits on it, never a `dir`.
  */
 function cleanupWorkspace(board, id) {
-  const task = tx(board, (db) => getTask(db, id));
+  const task = view(board, (db) => getTask(db, id));
   if (!task?.workspace_path || !['scratch', 'worktree'].includes(task.workspace_kind)) return;
-  const waiting = tx(board, (db) => one(db, "SELECT 1 FROM task_links l JOIN tasks t ON t.id = l.child_id WHERE l.parent_id = ? AND t.status NOT IN ('done', 'archived') LIMIT 1", id));
+  const waiting = view(board, (db) => one(db, "SELECT 1 FROM task_links l JOIN tasks t ON t.id = l.child_id WHERE l.parent_id = ? AND t.status NOT IN ('done', 'archived') LIMIT 1", id));
   if (waiting || !existsSync(task.workspace_path)) return;
   if (task.workspace_kind === 'worktree') { spawnSync('git', ['-C', task.workspace_path, 'worktree', 'remove', '--force', task.workspace_path], { encoding: 'utf8' }); return; }
   const managed = resolve(board.slug === 'default' ? join(board.root, 'kanban', 'workspaces') : join(board.root, 'kanban', 'boards', board.slug, 'workspaces'));
@@ -368,7 +368,7 @@ export async function runEffects(board, effects = []) {
 // a person-visible session and is never killed from the board
 function stopWorker(board, runId) {
   if (!runId) return;
-  const row = tx(board, (db) => one(db, 'SELECT metadata, claim_lock FROM task_runs WHERE id = ?', runId));
+  const row = view(board, (db) => one(db, 'SELECT metadata, claim_lock FROM task_runs WHERE id = ?', runId));
   const worker = json(row?.metadata, {})?.supercode;
   if (worker?.surface === 'headless' && worker.pid) terminate(Number(worker.pid));
 }
@@ -443,7 +443,7 @@ export const assign = (board, id, profile, { roles } = {}) => act(board, id, 'as
 /** A triage card fans out into children it waits on (Hermes's decomposer); answers their ids. */
 export async function decompose(board, id, children, { author = 'user', roles } = {}) {
   if (!children.length) throw new Error('decompose names at least one child (--child "<title>[@<assignee>]")');
-  const task = tx(board, (db) => must(db, id));
+  const task = view(board, (db) => must(db, id));
   const ids = children.map((c) => createCard(board, {
     title: c.title, body: c.body ?? null, assignee: c.assignee ?? task.assignee, machine: task.machine,
     workspace: task.workspace_path ? `${task.workspace_kind}:${task.workspace_path}` : task.workspace_kind, tenant: task.tenant, createdBy: author,
@@ -464,7 +464,7 @@ export function link(board, parent, child, { roles } = {}) {
 }
 
 export async function unlink(board, parent, child, { roles } = {}) {
-  const linked = tx(board, (db) => one(db, 'SELECT 1 FROM task_links WHERE parent_id = ? AND child_id = ?', parent, child));
+  const linked = view(board, (db) => one(db, 'SELECT 1 FROM task_links WHERE parent_id = ? AND child_id = ?', parent, child));
   if (!linked) return false;
   await act(board, child, 'unlink', { roles, payload: { parent, child } });
   return true;

package/board/store.mjs

@@ -8,7 +8,7 @@
 //
 // This module opens a board in its backing and gives its callers one primitive, a write transaction; the transitions
 // are in `engine.mjs`. Hermes's own tools may write a `kanban.db` at the same time: every write there takes SQLite's
-// writer lock (`BEGIN IMMEDIATE`) and retries while the other holds it.
+// native transaction boundary and retries an optimistic conflict.
 import { randomBytes } from 'node:crypto';
 import { existsSync, mkdirSync, readdirSync, readFileSync } from 'node:fs';
 import { hostname } from 'node:os';
@@ -152,7 +152,6 @@ export function openBoard(root, slug = DEFAULT_BOARD, { create = false, backing
   if (use === 'files') return { ...openFilesBoard(path, { create, init: layOut }), root, slug, path, backing: use };
   if (!kept) mkdirSync(dirname(path), { recursive: true });
   const db = new DatabaseSync(path);
-  db.exec('PRAGMA busy_timeout = 10000');
   db.exec('PRAGMA foreign_keys = OFF');
   const fresh = !db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'tasks'").get();
   if (fresh && !create) { db.close(); throw new Error(`${path} is not a board`); }
@@ -165,26 +164,22 @@ export function openBoard(root, slug = DEFAULT_BOARD, { create = false, backing
  * A read inside the transaction is the state it writes over.
  */
 export const tx = (board, fn) => board.tx(fn);
+export const view = (board, fn) => fn(board.db);
 
-// SQLite's own: `BEGIN IMMEDIATE` takes the writer lock up front, retried while Hermes's writers hold it
+// A deferred native transaction, with the whole operation retried on an optimistic conflict.
+// There is no separate application writer lock or contention timeout.
 function sqliteTx(db, fn) {
-  for (let attempt = 0; ; attempt += 1) {
+  for (;;) {
     try {
-      db.exec('BEGIN IMMEDIATE');
-      break;
-    } catch (error) {
-      if (!/locked|busy/i.test(error.message) || attempt >= 50) throw error;
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+      db.exec('BEGIN');
+      const out=fn(db);
+      db.exec('COMMIT');
+      return out;
+    } catch(error) {
+      try {db.exec('ROLLBACK');} catch {}
+      if (!/locked|busy/i.test(error.message))throw error;
     }
   }
-  try {
-    const out = fn(db);
-    db.exec('COMMIT');
-    return out;
-  } catch (error) {
-    try { db.exec('ROLLBACK'); } catch { /* already rolled back */ }
-    throw error;
-  }
 }
 
 export const now = () => Math.floor(Date.now() / 1000);

package/board/workflow.mjs

@@ -116,7 +116,9 @@ export function refreshCardInputs(board, id, { commits = false } = {}) {
   if (commits) {
     const own=task.workspace_kind!=='scratch'?task.workspace_path:null;
     const parent=!own && task.subtask_of?board.db.prepare('SELECT workspace_path FROM tasks WHERE id=?').get(task.subtask_of)?.workspace_path:null;
-    observeLastCommit(own??parent??null,id);
+    const path=own??parent??null;
+    if(path)commitTimes.delete(`${path}:${id}`);
+    observeLastCommit(path,id);
   }
 }
 

package/board/ztrack.mjs

@@ -39,7 +39,7 @@ class ZtrackBoard {
     this.codec = require('@volter/ztrack/board-document');
     this.preset = require('@volter/ztrack/kanban-preset');
     this.runtime = new DatabaseSync(`${marker}.runtime.db`);
-    if (!this.runtime.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='state'").get()) this.runtime.exec('CREATE TABLE state (key TEXT PRIMARY KEY, value TEXT NOT NULL)');
+    this.readOnly(()=>{ if (!this.runtime.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='state'").get()) this.runtime.exec('CREATE TABLE IF NOT EXISTS state (key TEXT PRIMARY KEY, value TEXT NOT NULL)'); });
     this.errors = new Map(); this.preserve = new Map();
     this.mem = null; this.active = false; this.rows = new RuntimeRows(this.runtime);
     mkdirSync(dirname(this.path), { recursive: true });
@@ -169,7 +169,7 @@ class ZtrackBoard {
         try { this.runtime.exec('ROLLBACK'); } catch { /* intent already durable */ }
         this.invalidate();
         if (/busy|locked|Hermes wrote|document changed during recovery/i.test(error.message)) continue;
-        if (committed) error.message += ' (the runtime journal retains any unfinished document write)';
+        if (committed) error.message += ' (the operation reached its durable intent; inspect its recorded outcome before retrying)';
         throw error;
       } finally { this.active = false; this.computing = false; this.pendingValues = null; }
     }

package/package.json

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