@volter/supercode-orchestrator 0.4.27 → 0.4.28

package/board/dispatch.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,23 +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) {
         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/package.json

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