@volter/supercode-orchestrator 0.5.136 → 0.5.137

package/board/dispatch.mjs

@@ -390,6 +390,54 @@ function progressedSince(db, task, runRow) {
   return at != null && Number(at) >= started;
 }
 
+/**
+ * What the board had typed for a card that bounced (the recipient's screen showed no input box for the mailbox's bound,
+ * and nothing was typed): a notice it filed, or the first input of a session it launched. Each is recorded on its card
+ * once, as a delivery that did not land, and the card's manager is told; nothing is sent again for it. An idle reminder
+ * that bounced was never read, so it is not counted against its session. Read at most twice a minute.
+ */
+const bouncesRead = new Map(); // board root → when its bounces were last read (ms)
+async function recordBounces(board, fleet, entry, report) {
+  const at = Date.now();
+  if (at - (bouncesRead.get(board.root) ?? 0) < 30_000) return;
+  bouncesRead.set(board.root, at);
+  const managers = [].concat(entry.params.managers ?? []).filter(Boolean);
+  const tell = (db, id, text) => { if (managers[0]) event(db, id, 'board_message', { to: managers[0], text }, null); };
+  try {
+    const answer = await runtimeDoor(null, 'harness.v1.mail.expired', {}, { timeout: 15_000 });
+    const expired = answer.code === 0 ? lastJson(answer.stdout)?.rows ?? [] : [];
+    for (const expiry of expired.filter((row) => row?.bounced === true && row.id && at - Number(row.expired_at_ms) < 24 * 3600_000)) tx(board, (db) => {
+      const filed = db.prepare("SELECT task_id, payload FROM task_events WHERE kind IN ('notice_filed', 'session_notice_filed', 'actor_notice_filed') AND json_extract(payload, '$.message_id') = ? ORDER BY id DESC LIMIT 1").get(expiry.id);
+      if (!filed || db.prepare("SELECT 1 FROM task_events WHERE task_id = ? AND kind = 'notice_bounced' AND json_extract(payload, '$.message_id') = ?").get(filed.task_id, expiry.id)) return;
+      const run = currentRun(db, filed.task_id), session = run?.metadata?.supercode;
+      const uncounted = Boolean(run && !run.ended_at && json(filed.payload, {})?.verb === 'session_idle' && addressOf(session) === expiry.to && Number(session.goal_turns) > 0);
+      if (uncounted) setRunSession(db, run.id, { goal_turns: Number(session.goal_turns) - 1 });
+      event(db, filed.task_id, 'notice_bounced', { message_id: expiry.id, to: expiry.to, reason: expiry.reason, expired_at_ms: expiry.expired_at_ms, idle_turn_uncounted: uncounted }, run?.id ?? null);
+      tell(db, filed.task_id, `${filed.task_id}: the board's notice ${expiry.id} to ${expiry.to} bounced: ${expiry.reason}. It stays unread in that mailbox and is not sent again.`);
+      (report.bounced ??= []).push([filed.task_id, expiry.to, expiry.id]);
+    });
+  } catch (error) { report.undelivered?.push(['mail', 'bounces', String(error.message).slice(-200)]); }
+  // the first input of each session launched in the last ten minutes, until its machine's launch record settles it
+  const running = view(board, (db) => db.prepare('SELECT t.id, r.id run_id, r.metadata FROM tasks t JOIN task_runs r ON r.id = t.current_run_id WHERE r.ended_at IS NULL').all());
+  for (const row of running) {
+    const session = json(row.metadata, {})?.supercode;
+    if (!session?.launch_key || session.first_input || !fleet?.ok || now() - Number(session.launched_at ?? 0) > 600) continue;
+    if (!fleet.capabilities?.get(normalMachine(session.machine ?? localMachine()))?.launches) continue;
+    let receipt; try { receipt = await launchReceipt(board, session); } catch { continue; }
+    const settled = receipt?.inputBounced ? 'bounced' : receipt?.inputDelivered === true ? 'delivered' : receipt?.inputRefused || receipt?.inputError ? 'undelivered' : null;
+    if (!settled) continue;
+    tx(board, (db) => {
+      const run = db.prepare('SELECT ended_at, metadata FROM task_runs WHERE id = ?').get(row.run_id);
+      if (!run || run.ended_at || json(run.metadata, {})?.supercode?.first_input) return;
+      setRunSession(db, row.run_id, { first_input: settled });
+      if (settled !== 'bounced') return;
+      event(db, row.id, 'first_input_bounced', { launch_key: session.launch_key, pane: session.pane ?? null, reason: receipt.inputError ?? null }, row.run_id);
+      tell(db, row.id, `${row.id}: the first input of the session the board launched for it${session.pane ? ` (pane ${session.pane})` : ''} bounced: ${receipt.inputError}. The session runs without its prompt; its quiet is not counted as idleness.`);
+      (report.bounced ??= []).push([row.id, session.pane ?? session.launch_key, 'first input']);
+    });
+  }
+}
+
 async function supervise(board, fleet, settings, report, entry, effects) {
   const rows = 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();
   // Published native observations are the only liveness input. Missing data remains unknown. A launch the
@@ -1432,6 +1480,8 @@ async function observeIdle(board, fleet, settings, report, entry, effects) {
       if (session.idle_since !== interval.since) setRunSession(db, runRow.id, { idle_since: interval.since });
       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; }
+      // a session whose first input bounced was never told its work: its quiet is not idleness (recordBounces told its manager)
+      if (session.first_input === 'bounced') { retain('first_input_bounced'); return; }
       // A reminder says the card shows no progress, and the last of them ends the run for it. With the card's checkout
       // unread that is not known: nothing is said or counted until it is read (the reading's `progress` says why).
       if (read.commit == null) { retain('progress_unread'); return; }
@@ -3131,7 +3181,7 @@ export async function tick({ root, lanes, settings, only = null, slugs = null, d
       await readMailbox(board, boardAddress(board.label), report); phase('mailbox');
       await refreshRelationAnswers(board); phase('answers');
       const effects = [];
-      await completeAdoptions(board, fleet, settings, report, lanes); await reconnectContinuedSessions(board, fleet, entry, report); await reconcileLaunches(board, fleet, report, entry, effects, settings, lanes); await supervise(board, fleet, settings, report, entry, effects); queueEffects(board, effects.splice(0)); await closeRequested(board, report, { ttl: settings.ttl, fleet }); phase('supervise');
+      await completeAdoptions(board, fleet, settings, report, lanes); await reconnectContinuedSessions(board, fleet, entry, report); await reconcileLaunches(board, fleet, report, entry, effects, settings, lanes); await recordBounces(board, fleet, entry, report); await supervise(board, fleet, settings, report, entry, effects); queueEffects(board, effects.splice(0)); await closeRequested(board, report, { ttl: settings.ttl, fleet }); phase('supervise');
       report.unsettled = [];
       report.promoted = recomputeReady(board, effects, report.unsettled);
       tx(board,db=>auditEndedRuns(db,board,entry));

package/package.json

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