@volter/supercode-orchestrator 0.4.116 → 0.4.117

package/board/dispatch.mjs

@@ -525,10 +525,6 @@ export async function startCard(board, id, { roles = ['manager'], lanes, setting
   return lane ? launchRun(board, entry, id, lane, fleet, settings) : null;
 }
 
-/**
- * The heartbeat, observed: a running pane session whose last message is a whole tick old is sent `session_idle` with
- * how many times it has been asked this run and whether it worked since the last ask; the workflow decides the rest.
- */
 /** Reconcile durable close intent and ended runs, including old unverified closed_at records.
  * Reads and process I/O stay outside the writer. An active successor owns its pane until it ends. */
 export function closeRequested(board, report, { taskId = null, caller = null } = {}) {
@@ -611,6 +607,8 @@ export function closeRequested(board, report, { taskId = null, caller = null } =
   }
 }
 
+/** Quiet time is independent of dispatch cadence and the harness's busy label.
+ * Keep bounded readings on the run so an ordinary quiet stretch can be reviewed later. */
 function observeIdle(board, fleet, settings, report, entry, effects) {
   if (!fleet.ok) return;
   for (const { id } of board.db.prepare(entry.workflow.run ? "SELECT id FROM tasks WHERE current_run_id IS NOT NULL" : "SELECT id FROM tasks WHERE status = 'running'").all()) {
@@ -622,22 +620,44 @@ function observeIdle(board, fleet, settings, report, entry, effects) {
       const session = runRow?.metadata?.supercode;
       if (!session?.session_id || session.surface !== 'pane') return;
       const live = fleet.sessions.find((x) => x.address?.endsWith(`:${session.session_id}`));
-      // a supercode that reports no last message time gives no reading, and no reading gives no verdict
+      const observedAt = now();
       const lastAt = Math.floor(Number(live?.last_message_at_ms) / 1000);
-      if (!(lastAt > 0)) return;
-      if (now() - lastAt < settings.idleQuiet) return;
-      if (session.goal_nudged_at && now() - session.goal_nudged_at < settings.idleQuiet) return;
+      const reading = {
+        session_id: session.session_id, observed_at: observedAt,
+        last_message_at: lastAt > 0 ? lastAt : null,
+        last_message_at_ms: lastAt > 0 ? Number(live.last_message_at_ms) : null,
+        status: live?.status ?? null, quiet_seconds: lastAt > 0 ? observedAt - lastAt : null,
+        threshold_seconds: settings.idleQuiet, turns_before: Number(session.goal_turns ?? 0),
+      };
+      const retain = (decision, extra = {}) => {
+        const observation = { ...reading, decision, turns_after: reading.turns_before, ...extra };
+        const patch = { idle_observation: observation };
+        if (decision === 'below_threshold') patch.idle_below_threshold = observation;
+        if (decision === 'dispatched' || decision === 'dispatch_failed') patch.idle_eligible = observation;
+        setRunSession(db, runRow.id, patch);
+        return observation;
+      };
+      // No timestamp is no reading, and no reading gives no verdict.
+      if (!(lastAt > 0)) { retain('no_timestamp'); return; }
+      if (reading.quiet_seconds < settings.idleQuiet) { retain('below_threshold'); return; }
+      if (session.goal_nudged_at && observedAt - session.goal_nudged_at < settings.idleQuiet) { retain('nudge_cooldown'); return; }
       const worked = Boolean(session.goal_nudged_at) && lastAt > session.goal_nudged_at;
       try {
         const where = whereOf(board, task);
         // the ask names what the session may do, as its run's prompt did
         const said = doors(entry.workflow, status, session.role ?? runSpec(entry, status)?.role ?? 'implementer', id, where, session.surface === 'pane' ? 'pane' : 'headless');
-        const r = fire(db, board, entry, id, 'session_idle', { roles: ['platform'], payload: { turns: Number(session.goal_turns ?? 0), worked }, extra: { where, doors: said } });
+        const r = fire(db, board, entry, id, 'session_idle', { roles: ['platform'], payload: { ...reading, turns: reading.turns_before, worked }, extra: { where, doors: said } });
         effects.push(...r.effects);
         const after = currentRun(db, id);
-        if (after?.id === runRow.id) setRunSession(db, runRow.id, { ...(after.metadata?.supercode ?? session), goal_nudged_at: now() });
+        const stored = json(db.prepare('SELECT metadata FROM task_runs WHERE id=?').get(runRow.id)?.metadata, {})?.supercode;
+        const observation = retain('dispatched', { turns_after: Number(stored?.goal_turns ?? 0), nudge_queued: r.effects.some(e => e.kind === 'send_to_actor'), run_ended: after?.id !== runRow.id });
+        event(db, id, 'session_idle_observed', observation, runRow.id);
+        if (after?.id === runRow.id) setRunSession(db, runRow.id, { goal_nudged_at: observedAt });
         report.notified.push([id, 'session_idle', live.address]);
-      } catch (error) { report.failed.push([id, `session_idle: ${String(error.message).slice(-200)}`]); }
+      } catch (error) {
+        retain('dispatch_failed', { error: String(error.message).slice(-200) });
+        report.failed.push([id, `session_idle: ${String(error.message).slice(-200)}`]);
+      }
     });
   }
 }
@@ -927,7 +947,7 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
     if (paneLive && (prev.closed_at || prev.close_requested || prev.forgotten)) throw new Error(`session ${prev.session_id} still has live pane ${prev.pane}; cannot resume or replace it`);
     if (!prev.closed_at && !prev.close_requested && (prev.pane ? paneLive : 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, close_requested: _q, closed_at: _c, close_confirmed_at: _cc, close_error: _ce, close_attempts: _ca, close_attempted_at: _ct, ...kept } = prev;
+      const { missing_since: _m, goal_turns: _t, goal_nudged_at: _n, idle_observation: _io, idle_below_threshold: _ib, idle_eligible: _ie, close_requested: _q, closed_at: _c, close_confirmed_at: _cc, close_error: _ce, close_attempts: _ca, close_attempted_at: _ct, ...kept } = prev;
       session = { ...kept, mode: 'adopt', launched_at: now(), seen_at: now() };
       // a kept session is told what this run is for (its card came back to it, with what happened since)
       tx(board, (db) => setRunSession(db, runId, { ...session, ...meta }));

package/board/store.mjs

@@ -205,7 +205,7 @@ export function setActor(address) { actor = address || null; }
 export function event(db, taskId, kind, payload = null, runId = null) {
   // Session observations belong to the run machine. Legacy runs without a machine state retain
   // their Hermes event stream; a new instance never sends supervision as card notices.
-  if (runId && ['claimed', 'spawned', 'session_started', 'session_resumed', 'session_replaced', 'session_adopted', 'claim_extended'].includes(kind)) {
+  if (runId && ['claimed', 'spawned', 'session_started', 'session_resumed', 'session_replaced', 'session_adopted', 'claim_extended', 'session_idle_observed'].includes(kind)) {
     const row = db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(runId);
     const meta = json(row?.metadata, {}) ?? {};
     if (meta.supercode?.state) {

package/package.json

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