@volter/supercode-orchestrator 0.5.109 → 0.5.110

package/board/dispatch.mjs

@@ -1117,7 +1117,12 @@ async function observeIdle(board, fleet, settings, report, entry, effects) {
   };
   const managers = [].concat(entry.params.managers ?? []).filter(Boolean);
   const running = 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();
-  for (const { id } of running) { const session = currentRun(board.db, id)?.metadata?.supercode; await readBefore(fleet, session); if (session?.session_id) updatedAt(session); }
+  // every running card a session is on: a session waiting on its user is told once, naming them all
+  const cardsOf = new Map();
+  for (const { id } of running) {
+    const session = currentRun(board.db, id)?.metadata?.supercode; await readBefore(fleet, session); if (session?.session_id) updatedAt(session);
+    if (addressOf(session)) cardsOf.set(addressOf(session), [...(cardsOf.get(addressOf(session)) ?? []), id]);
+  }
   for (const { id } of running) {
     let staged = [];
     txRead(board, (db) => {
@@ -1132,7 +1137,8 @@ async function observeIdle(board, fleet, settings, report, entry, effects) {
       // a session in no pane has its turn on its machine's discovery row, which sessionAlive just read
       let nativeRow = null;
       if (session.surface === 'native') try { nativeRow = nativeReading(nativeSessions(session.machine, session.harness ?? 'claude-code', session.session_id), session).row; } catch { /* unread: no turn */ }
-      const live = fleet.sessions.find((x) => x.address === addressOf(session)) ?? (nativeRow ? { address: addressOf(session), turn: nativeRow.activity?.turn ?? null } : undefined);
+      const live = fleet.sessions.find((x) => x.address === addressOf(session)) ?? (nativeRow ? { address: addressOf(session), turn: nativeRow.activity?.turn ?? null, waiting_for: nativeRow.activity?.evidence?.waiting_for ?? null,
+        turn_source: nativeRow.activity?.evidence?.source ?? null, turn_since_ms: nativeRow.activity?.evidence?.native_state_since_ms ?? null } : undefined);
       const observedAt = now();
       const lastAtMs = Number(live?.last_message_at_ms) || updatedAt(session);
       const lastAt = Math.floor(Number(lastAtMs) / 1000);
@@ -1146,7 +1152,7 @@ async function observeIdle(board, fleet, settings, report, entry, effects) {
       const retain = (decision, extra = {}) => {
         // A reading that decides nothing is kept once per state: rewriting it each pass would wake the next pass.
         const prior = session.idle_observation;
-        if (!['dispatched', 'dispatch_failed'].includes(decision) && prior?.decision === decision && prior.last_message_at_ms === reading.last_message_at_ms && prior.status === reading.status) return prior;
+        if (!['dispatched', 'dispatch_failed', 'waiting_on_user'].includes(decision) && prior?.decision === decision && prior.last_message_at_ms === reading.last_message_at_ms && prior.status === reading.status) return prior;
         const observation = { ...reading, decision, turns_after: reading.turns_before, ...extra };
         const patch = { idle_observation: observation };
         if (decision === 'below_threshold') patch.idle_below_threshold = observation;
@@ -1154,21 +1160,39 @@ async function observeIdle(board, fleet, settings, report, entry, effects) {
         setRunSession(db, runRow.id, patch);
         return observation;
       };
-      // A session its harness holds (a question or permission prompt, a dialog such as the usage limit, a hang) is told to
-      // the manager with what its screen shows, once per state: a reminder typed into a dialog goes nowhere. Waiting on
-      // its user is known at once; working without writing past the quiet threshold is held.
-      const held = live?.turn === 'needs_input' ? 'waiting_on_user' : live?.turn === 'working' && lastAt > 0 && observedAt - lastAt >= settings.idleQuiet ? 'working_silent' : null;
-      if (held) {
-        if (session.idle_observation?.decision === held && session.idle_observation.last_message_at_ms === reading.last_message_at_ms) return;
-        // (its screen is not read: the call here named `panes.capture`, no machine door, and never answered)
-        const screen = null;
-        const observation = retain(held, { screen });
-        const why = held === 'waiting_on_user' ? 'is waiting on its user (a question or a permission prompt)' : `has reported working without writing anything for ${Math.round((observedAt - lastAt) / 60)} min`;
-        const text = `${id}: its session ${addressOf(session)} ${why}; nothing it is sent reaches it until that is answered.${screen ? `\nIts screen:\n${screen}` : ''}`;
+      // A session waiting on its user (a question, a permission prompt) or working without writing past the quiet
+      // threshold is told to the manager, with only what was read of it. Whether a harness's own state is a question
+      // put to its user is its harness's to say (`needs_input`); what it waits for is carried as it was read.
+      const address = addressOf(session);
+      const asked = live?.turn === 'needs_input';
+      // a reading that shows the session no longer waiting ends the prompt; a round that did not read it does not
+      if (session.held_notice && live && !asked) setRunSession(db, runRow.id, { held_notice: null });
+      if (asked) {
+        // One prompt is one notice: the same wait (what it waits for, since when its harness says) on the same
+        // session, whichever of its cards a round reads first and however long it stands.
+        const key = [address, live.waiting_for ?? '', live.turn_since_ms ?? ''].join('|');
+        if (session.held_notice?.key === key) return;
+        // every run a card works under: an ended run can still be its card's current one
+        const told = db.prepare('SELECT r.metadata FROM task_runs r WHERE r.id != ? AND (r.ended_at IS NULL OR EXISTS (SELECT 1 FROM tasks t WHERE t.current_run_id = r.id))').all(runRow.id).some((r) => json(r.metadata, {})?.supercode?.held_notice?.key === key);
+        setRunSession(db, runRow.id, { held_notice: { key, at: observedAt } });
+        if (told) return;
+        const observation = retain('waiting_on_user', { waiting_for: live.waiting_for ?? null, since_ms: live.turn_since_ms ?? null });
+        const others = (cardsOf.get(address) ?? []).filter((card) => card !== id);
+        const what = live.turn_source === 'pane_prompt' ? 'shows a prompt on its pane that waits for an answer'
+          : `reports that it is waiting on its user${live.waiting_for ? ` (${live.waiting_for})` : ''}${live.turn_since_ms ? ` since ${new Date(Number(live.turn_since_ms)).toISOString().slice(0, 19)}Z` : ''}`;
+        event(db, id, 'session_held', observation, runRow.id);
+        const to = managers[0] ?? null;
+        if (to) event(db, id, 'board_message', { to, text: `${id}: its session ${address} ${what}.${others.length ? ` It is also on ${others.join(', ')}.` : ''}` }, null);
+        (report.held ??= []).push([id, 'waiting_on_user', address]);
+        return;
+      }
+      if (live?.turn === 'working' && lastAt > 0 && observedAt - lastAt >= settings.idleQuiet) {
+        if (session.idle_observation?.decision === 'working_silent' && session.idle_observation.last_message_at_ms === reading.last_message_at_ms) return;
+        const observation = retain('working_silent');
         event(db, id, 'session_held', observation, runRow.id);
         const to = managers[0] ?? null;
-        if (to) event(db, id, 'board_message', { to, text }, null);
-        (report.held ??= []).push([id, held, addressOf(session)]);
+        if (to) event(db, id, 'board_message', { to, text: `${id}: its session ${address} has reported working without writing anything for ${Math.round((observedAt - lastAt) / 60)} min.` }, null);
+        (report.held ??= []).push([id, 'working_silent', address]);
         return;
       }
       // No timestamp is no reading, and no reading gives no verdict.

package/board/machine-fleet.mjs

@@ -66,7 +66,9 @@ export async function readMachineFleet(machines, local) {
       native.set(address, { alive: running ? true : null, states: [running ? true : null] });
       if (running) alive.add(address);
       sessions.push({ address, machine: row.machine, harness: activity.harness, session_id: activity.session_id, pane: pane.pane, name: pane.title ?? pane.label ?? null,
-        state: running ? 'running' : 'unknown', turn: activity.turn ?? null, native_state: activity.evidence?.native_state ?? null });
+        state: running ? 'running' : 'unknown', turn: activity.turn ?? null, native_state: activity.evidence?.native_state ?? null,
+        // what a session that needs input says it waits for and since when, where its harness publishes them
+        waiting_for: activity.evidence?.waiting_for ?? null, turn_source: activity.evidence?.source ?? null, turn_since_ms: activity.evidence?.native_state_since_ms ?? null });
     }
   }
   const ok = online.has(local);

package/package.json

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