@volter/supercode-orchestrator 0.4.26 → 0.4.28

package/board/dispatch.mjs

@@ -23,7 +23,7 @@ import { fileURLToPath } from 'node:url';
 import { boardPath, event, json, listBoards, now, openBoard, tx } from './store.mjs';
 import { holdBoardTickLock } from '../hermes-locks.mjs';
 import {
-  cardContext, claimIn, claimTtl, currentRun, DEFAULT_FAILURE_LIMIT, extendClaim, getTask, lastSession,
+  blockIn, cardContext, claimIn, claimTtl, currentRun, DEFAULT_FAILURE_LIMIT, extendClaim, getTask, lastSession,
   recomputeReady, recordFailure, release, setRunSession, subscribeIn, subscriptions,
 } from './engine.mjs';
 
@@ -475,7 +475,7 @@ function launchPane(board, task, runId, lane, fleet, { input = null } = {}) {
   if (prev && prev.machine === machine) {
     if (sessionAlive(fleet, prev)) {
       // the session is kept; the heartbeat's count belongs to the run that ended, so the new run starts it again
-      const { missing_since: _m, goal_turns: _t, goal_nudged_at: _n, idle_since: _i, worked_since_ask: _w, ...kept } = prev;
+      const { missing_since: _m, goal_turns: _t, goal_nudged_at: _n, ...kept } = prev;
       session = { ...kept, mode: 'adopt', launched_at: now(), seen_at: now() };
     } else if (prev.resumable !== false) {
       const r = sc([...base, '--key', `board-${task.id}-r${runId}-resume`, '--input',
@@ -915,8 +915,10 @@ function readMailbox(board, address, report) {
  * The board's heartbeat for a pane session: a running card's session never sits idle without deciding. Each tick, a
  * session that is idle while its card is still running is asked to decide: `request-review` when the work is done,
  * `block` with its kind when it cannot go on (waiting on a person, a capability, another card), or keep working. A
- * goal card (Hermes's goal loop) is told to keep going. A session is asked once it has been idle a whole tick; one
- * seen working since the last ask answered it, and its count starts again. After the turn budget (`goal_max_turns`, else
+ * goal card (Hermes's goal loop) is told to keep going. Idle is judged by the session's last message time (supercode
+ * reads it from the transcript), never by its status label: a session is asked once its last message is a whole tick
+ * old; one whose messages ran on a whole tick past the last ask answered it by working, and its count starts again
+ * (a reply to the ask alone is not work). After the turn budget (`goal_max_turns`, else
  * `kanban.goal_max_turns`) of asks in a row with no work and no decision (a goal card: of turns), the card is blocked `needs_input` and its creator is told.
  * Whether the work is done is the session's call through its card, not an auxiliary judge's.
  */
@@ -930,25 +932,22 @@ function pursueGoals(board, fleet, settings, report) {
       const session = runRow?.metadata?.supercode;
       if (!session?.session_id || session.surface !== 'pane') return null;
       const live = fleet.sessions.find((x) => x.address?.endsWith(`:${session.session_id}`));
-      if (!live) return null;
-      // a session seen working since the last ask answered it by working: its count starts again (a goal card keeps
-      // Hermes's budget of turns); one idle for less than a whole tick is between turns, not idle
-      if (live.status !== 'idle') {
-        if (session.idle_since || (session.goal_nudged_at && !session.worked_since_ask)) setRunSession(db, runRow.id, { ...session, idle_since: null, worked_since_ask: true });
-        return null;
-      }
-      if (!session.idle_since) { setRunSession(db, runRow.id, { ...session, idle_since: now() }); return null; }
-      if (now() - session.idle_since < settings.interval) return null;
+      // a supercode that reports no last message time gives no reading, and no reading gives no verdict
+      const lastAt = Math.floor(Number(live.last_message_at_ms) / 1000);
+      if (!(lastAt > 0)) return null;
+      // a message within the last tick is a session working or between turns, not idle
+      if (now() - lastAt < settings.interval) return null;
       if (session.goal_nudged_at && now() - session.goal_nudged_at < settings.interval * 2) return null;
-      const turns = session.worked_since_ask && !task.goal_mode ? 0 : Number(session.goal_turns ?? 0);
+      // messages that ran on a whole tick past the last ask answered it by working: the count starts again (a goal
+      // card keeps Hermes's budget of turns)
+      const worked = Boolean(session.goal_nudged_at) && lastAt >= session.goal_nudged_at + settings.interval;
+      const turns = worked && !task.goal_mode ? 0 : Number(session.goal_turns ?? 0);
       const budget = task.goal_max_turns ?? settings.goalMaxTurns;
       if (turns >= budget) {
-        db.prepare("UPDATE tasks SET status = 'blocked', claim_lock = NULL, claim_expires = NULL WHERE id = ?").run(id);
-        const ended = endRun(db, id, { outcome: 'blocked', summary: `idle ${budget} times without deciding done or blocked` });
-        event(db, id, 'blocked', { reason: `its session went idle ${budget} times without deciding done or blocked; review it`, kind: 'needs_input', source_status: 'running' }, ended);
+        blockIn(db, id, { reason: `its session went idle ${budget} times without deciding done or blocked; review it`, kind: 'needs_input' });
         return null;
       }
-      setRunSession(db, runRow.id, { ...session, goal_turns: turns + 1, goal_nudged_at: now(), worked_since_ask: false });
+      setRunSession(db, runRow.id, { ...session, goal_turns: turns + 1, goal_nudged_at: now() });
       event(db, id, task.goal_mode ? 'goal_continued' : 'decision_asked', { turn: turns + 1, budget }, runRow.id);
       const local = normalMachine(task.machine) === localMachine();
       const where = local ? `--root ${board.root}${board.slug !== 'default' ? ` --board ${board.slug}` : ''}` : `--at ${boardAddress(board.label)}`;

package/board/engine.mjs

@@ -396,25 +396,28 @@ function completeIn(board, id, { result = null, summary = null, metadata = null
 }
 
 export function block(board, id, { reason = null, kind = null } = {}) {
+  return tx(board, (db) => blockIn(db, id, { reason, kind }));
+}
+
+/** `block` inside the caller's transaction (the dispatcher's own blocks keep the same recurrence accounting). */
+export function blockIn(db, id, { reason = null, kind = null } = {}) {
   if (kind && !BLOCK_KINDS.includes(kind)) throw new Error(`block kind is one of ${BLOCK_KINDS.join(', ')}`);
-  return tx(board, (db) => {
-    const task = must(db, id);
-    if (!['running', 'ready'].includes(task.status)) throw new Error(`${id} is ${task.status}; only a running or ready card blocks`);
-    const source = task.status === 'running' ? retryStatus(db, id) : 'ready';
-    if (kind === 'dependency') {
-      run(db, "UPDATE tasks SET status = 'todo', claim_lock = NULL, claim_expires = NULL, worker_pid = NULL, block_kind = ? WHERE id = ?", kind, id);
-      const runId = endRun(db, id, { outcome: 'blocked', summary: reason }) ?? (reason ? synthesizeRun(db, id, { outcome: 'blocked', summary: reason }) : null);
-      event(db, id, 'dependency_wait', { reason, kind, source_status: source }, runId);
-      return 'todo';
-    }
-    const recurrences = task.block_kind === kind ? Number(task.block_recurrences || 0) + 1 : 1;
-    const loop = recurrences >= BLOCK_RECURRENCE_LIMIT;
-    const status = loop ? 'triage' : 'blocked';
-    run(db, 'UPDATE tasks SET status = ?, claim_lock = NULL, claim_expires = NULL, worker_pid = NULL, block_kind = ?, block_recurrences = ? WHERE id = ?', status, kind, recurrences, id);
+  const task = must(db, id);
+  if (!['running', 'ready'].includes(task.status)) throw new Error(`${id} is ${task.status}; only a running or ready card blocks`);
+  const source = task.status === 'running' ? retryStatus(db, id) : 'ready';
+  if (kind === 'dependency') {
+    run(db, "UPDATE tasks SET status = 'todo', claim_lock = NULL, claim_expires = NULL, worker_pid = NULL, block_kind = ? WHERE id = ?", kind, id);
     const runId = endRun(db, id, { outcome: 'blocked', summary: reason }) ?? (reason ? synthesizeRun(db, id, { outcome: 'blocked', summary: reason }) : null);
-    event(db, id, loop ? 'block_loop_detected' : 'blocked', { reason, kind, recurrences, ...(loop ? { limit: BLOCK_RECURRENCE_LIMIT } : {}), source_status: source }, runId);
-    return status;
-  });
+    event(db, id, 'dependency_wait', { reason, kind, source_status: source }, runId);
+    return 'todo';
+  }
+  const recurrences = task.block_kind === kind ? Number(task.block_recurrences || 0) + 1 : 1;
+  const loop = recurrences >= BLOCK_RECURRENCE_LIMIT;
+  const status = loop ? 'triage' : 'blocked';
+  run(db, 'UPDATE tasks SET status = ?, claim_lock = NULL, claim_expires = NULL, worker_pid = NULL, block_kind = ?, block_recurrences = ? WHERE id = ?', status, kind, recurrences, id);
+  const runId = endRun(db, id, { outcome: 'blocked', summary: reason }) ?? (reason ? synthesizeRun(db, id, { outcome: 'blocked', summary: reason }) : null);
+  event(db, id, loop ? 'block_loop_detected' : 'blocked', { reason, kind, recurrences, ...(loop ? { limit: BLOCK_RECURRENCE_LIMIT } : {}), source_status: source }, runId);
+  return status;
 }
 
 export function unblock(board, id) {

package/package.json

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