@volter/supercode-orchestrator 0.5.108 → 0.5.110

package/board/dispatch.mjs

@@ -1010,9 +1010,15 @@ export async function closeRequested(board, report, { taskId = null, caller = nu
       (report.closed ??= []).push({ task_id: row.task_id, ...session, released: true });
       continue;
     }
-    // A close that failed for a reason another attempt cannot change is tried once and raised as an incident, not tried
-    // every round (each attempt is a process). A deferred close (an offline machine, a run that still owns the pane) waits.
-    if (session.close_failed_at && session.close_error && !/^close deferred/.test(session.close_error)) continue;
+    // A final refusal stops further close attempts. Only an authorized observation of this exact pane may establish
+    // absence: panes.list can be filtered or carry missing context keys. Unknown/invisible keeps the original failure.
+    const finalFailure = Boolean(session.close_failed_at && session.close_error && !/^close deferred/.test(session.close_error));
+    if (finalFailure) {
+      if (!session.pane) continue;
+      const r = await doorOn(session.machine ?? localMachine(), 'harness.v1.panes.presence', { pane: session.pane }, { timeout: 10_000, as: boardAddress(board.label) });
+      const observed = r.code === 0 ? json(r.stdout.trim(), null) : null;
+      if (observed?.pane !== session.pane || observed.present !== false) continue;
+    }
     const active = view(board, (db) => db.prepare(`SELECT r.id, r.metadata FROM task_runs r WHERE r.ended_at IS NULL OR EXISTS (SELECT 1 FROM tasks t WHERE t.current_run_id = r.id)`).all());
     // Persist retries even for historical ends that did not have a close_session action. The close is claimed in the
     // same transaction, before the pane or process is touched: of two rounds (or a round and a verb) that read one close,
@@ -1039,7 +1045,7 @@ export async function closeRequested(board, report, { taskId = null, caller = nu
           if (row.ended_at) { const inTurn = await turnAtClose(session); if (inTurn) throw new Error(`close deferred: ${inTurn}`); }
           await stopSession(board, session);
         }
-      } else {
+      } else if (!finalFailure) {
       if (!panes.has(machine)) {
         const r = await doorOn(machine, 'harness.v1.panes.list',{}, { timeout: 60_000, as: boardAddress(board.label) });
         const list = r.code === 0 ? json(r.stdout.trim(), null) : null;
@@ -1088,7 +1094,8 @@ export async function closeRequested(board, report, { taskId = null, caller = nu
         const subscribed = db.prepare('SELECT r.id, r.metadata FROM task_runs r WHERE r.ended_at IS NULL OR EXISTS (SELECT 1 FROM tasks t WHERE t.current_run_id = r.id)').all()
           .some((r) => addressOf(json(r.metadata, {})?.supercode) === address && r.id !== row.id);
         const unsubscribed = subscribed ? 0 : db.prepare("DELETE FROM kanban_notify_subs WHERE platform = 'supercode' AND chat_id = ? AND (task_id = ? OR json_extract(delivery_metadata, '$.role') = 'worker')").run(address, row.task_id).changes;
-        event(db, row.task_id, 'session_closed', { session_id: session.session_id, pane: session.pane, machine: session.machine, unsubscribed }, row.id);
+        event(db, row.task_id, 'session_closed', { session_id: session.session_id, pane: session.pane, machine: session.machine, unsubscribed,
+          ...(finalFailure ? { reason: 'authorized pane presence observed absence after an earlier close refusal' } : {}) }, row.id);
       }
     });
     if (error) report.undelivered.push([row.task_id, addressOf(session), error, 'close']);
@@ -1110,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) => {
@@ -1125,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);
@@ -1139,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;
@@ -1147,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.108",
+  "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": {