@volter/supercode-orchestrator 0.5.24 → 0.5.25

package/board/cli.mjs

@@ -1402,7 +1402,10 @@ async function serve(root, args = {}) {
         renameSync(temporary, heartbeat);
       } catch { /* the next round writes it */ }
     }
-    for (const r of reports) {
+    // A whole tick that failed is counted as board '*'; a round in which every board succeeded clears it too, so its
+    // recovery is said and a later failure starts a count of its own.
+    const settled = reports.every((r) => !r.error) && failing.has('*') ? [...reports, { board: '*' }] : reports;
+    for (const r of settled) {
       const run = failing.get(r.board) ?? { count: 0, since: Date.now(), told: 0 };
       if (!r.error) {
         if (run.count >= FAILED_ROUNDS_ALERT) await alertManagers(root, r.board === '*' ? 'default' : r.board, `The dispatcher's rounds on board ${r.board} succeed again after ${run.count} failed rounds since ${new Date(run.since).toISOString()}.`, `dispatcher-recovered-${r.board}-${run.since}`);

package/board/dispatch.mjs

@@ -1074,11 +1074,22 @@ export async function mergeReviewed(board, e) {
     return true;
   }
   const entry = await loadWorkflow(board.root);
-  tx(board, (db) => {
+  // A fault other than the card's refusal keeps the effect for the next round, and the round goes on past it.
+  try { tx(board, (db) => {
     event(db, e.id, 'reviewed_merged', { merges });
-    const r = fire(db, board, entry, e.id, 'reviewed_merged', { roles: ['platform'], payload: { merges, summary: merges.length ? `Merged at the reviewed heads: ${merges.map((m) => `${m.pr} (${m.reviewed.slice(0, 8)} → ${String(m.merge).slice(0, 8)})`).join(', ')}` : 'The pass named no PR to merge.' } });
+    // A card that moved after its pass cannot take the event: that is said to the manager once, never thrown, so the
+    // kept effect does not stop every round after it (as merge_refused, above).
+    let r;
+    try { r = fire(db, board, entry, e.id, 'reviewed_merged', { roles: ['platform'], payload: { merges, summary: merges.length ? `Merged at the reviewed heads: ${merges.map((m) => `${m.pr} (${m.reviewed.slice(0, 8)} → ${String(m.merge).slice(0, 8)})`).join(', ')}` : 'The pass named no PR to merge.' } }); }
+    catch (error) {
+      // only the card's refusal is said and consumed; anything else (a write contention, a fault) is thrown and retried
+      if (!error.noTransition && !error.refusal && !/does not apply|there is for/.test(error.message)) throw error;
+      const to = [].concat(entry.params.managers ?? []).find(Boolean);
+      if (to) event(db, e.id, 'board_message', { to, text: `${e.id}: its reviewed PRs are merged (${merges.map((m) => m.pr).join(', ') || 'none'}), but the card could not take reviewed_merged: ${String(error.message).slice(0, 300)}` }, null);
+      return;
+    }
     for (const eff of r.effects) db.prepare('INSERT INTO supercode_effects (effect) VALUES (?)').run(JSON.stringify(eff));
-  });
+  }); } catch (error) { process.stderr.write(`board: ${e.id}: reviewed_merged kept for the next round: ${String(error.message).slice(0, 300)}\n`); return false; }
   return true;
 }
 

package/board/store.mjs

@@ -9,6 +9,7 @@
 // This module opens a board in its backing and gives its callers one primitive, a write transaction; the transitions
 // are in `engine.mjs`. Hermes's own tools may write a `kanban.db` at the same time: every write there takes SQLite's
 // native transaction boundary and retries an optimistic conflict.
+import { noteStep } from '@volter/supercode-harness-sdk/slow-log';
 import { randomBytes } from 'node:crypto';
 import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import { hostname } from 'node:os';
@@ -200,9 +201,15 @@ export function openBoard(root, slug = DEFAULT_BOARD, { create = false, backing
  * A read inside the transaction is the state it writes over.
  */
 export const tx = (board, fn) => {
-  const result = board.tx(db => {const result=fn(db);recordCardPublications(db,actor);return result;});
-  signalBoardWrite(board.root, actor);
-  return result;
+  // Each transaction is a step named by the function that asked for it, so a round's slow-log line says which of its
+  // steps make its transactions (about a hundred a round, at 150 ms each, on 2026-10-02).
+  const caller = /at (?:async )?([\w.$<>]+) /.exec(String(new Error().stack).split('\n')[2] ?? '')?.[1] ?? 'unknown';
+  const started = performance.now();
+  try {
+    const result = board.tx(db => {const result=fn(db);recordCardPublications(db,actor);return result;});
+    signalBoardWrite(board.root, actor);
+    return result;
+  } finally { noteStep(`board tx from ${caller}`, performance.now() - started); }
 };
 // SQLite's own contention (BUSY, LOCKED, and their extended codes) and nothing else: a refusal whose words happen to
 // say "blocked" or "busy" reaches its caller at once instead of being retried forever.

package/package.json

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