@volter/supercode-orchestrator 0.5.228 → 0.5.230

package/board/capacity.mjs

@@ -2,11 +2,12 @@
 // caps; each names where it keeps one count (`scope`), what it counts (`counts`), which cards and sessions it is about
 // (`where`, less `unless`) and its `max`. This module counts what a home holds now and answers whether one more card may start.
 
-import { json } from './store.mjs';
-import { detachedSession } from './custody.mjs';
-import { statusOf } from './workflow.mjs';
+import { json, RUN_SLOT, runField } from './store.mjs';
+import { currentRecordChanges, currentRecordConnection } from './current-records.mjs';
+import { sessionAddress } from './custody.mjs';
 import { setImmediate as yieldToOwner } from 'node:timers/promises';
-import { listRevision } from './listing.mjs';
+import { listRevision, readBoundary } from './listing.mjs';
+import { backlogQualification } from './resting-state.mjs';
 
 /** The scope's group a counted thing or a card falls in. */
 const GROUP = {
@@ -38,26 +39,49 @@ export function matches(filter, thing) {
 /** Whether a cap is about `thing`: its `where` matches and its `unless` (when it names anything) does not. */
 const applies = (cap, thing) => matches(cap.where, thing) && !(Object.keys(cap.unless ?? {}).length && matches(cap.unless, thing));
 
-/** Each slot's latest recorded session on a card (implementer `worker`, `reviewer`, …), newest run first. */
-async function sessionsOf(db, taskId, unchanged) {
-  const out = new Map();
-  let cursor = null;
-  for (;;) {
-    if (!unchanged()) return null;
-    // Page by the indexed run id, not an offset. Include null metadata so even a long empty history
-    // reads only 64 records per statement. Every page is visited: an older, distinct slot still counts.
-    const rows = db.prepare(`SELECT id, metadata FROM task_runs WHERE task_id = ?${cursor === null ? '' : ' AND id < ?'} ORDER BY id DESC LIMIT 64`)
-      .all(taskId, ...(cursor === null ? [] : [cursor]));
-    for (const row of rows) {
-      const s = json(row.metadata, {})?.supercode;
-      const slot = s?.slot ?? 'worker';
-      if (s?.session_id && !out.has(slot)) out.set(slot, detachedSession(db, s) ? null : { ...s, run: row.id });
+// Held card rows and latest retained role slots, never a cached fleet/capacity verdict.
+const projections = new WeakMap();
+const CARD_ROWS = `SELECT t.id,t.status,COALESCE(c.stage,t.status) AS stage,t.assignee,t.current_run_id,t.model_override,
+  c.machine,c.subtask_of,c.paused,c.backlog,c.blocked_by,c.archived,c.detached FROM tasks t LEFT JOIN supercode_cards c ON c.task_id=t.id`;
+async function currentHoldings(db, unchanged) {
+  const projection = projections.get(currentRecordConnection(db)) ?? { token: null, cards: new Map() };
+  projections.set(currentRecordConnection(db), projection);
+  const change = currentRecordChanges(db, projection.token);
+  const refresh = (row) => {
+    if (!row || row.status === 'archived' || row.detached != null) return;
+    // A flag cannot erase unresolved work, even if an external SQLite writer bypassed import admission.
+    if (json(row.backlog, null) && backlogQualification(db, row.id).qualified) return;
+    // The index groups a card's slot names; only their newest session-bearing run is decoded.
+    const slots = db.prepare(`SELECT id,metadata FROM task_runs WHERE id IN (
+      SELECT MAX(id) FROM task_runs WHERE task_id=? AND ${runField('session_id')} IS NOT NULL
+        AND ${runField('session_id')} NOT IN ('',0) GROUP BY ${RUN_SLOT}) ORDER BY id DESC`).all(row.id)
+      .map(run => ({ ...json(run.metadata, {})?.supercode, run: run.id }));
+    const current = row.current_run_id ? { ...json(db.prepare('SELECT metadata FROM task_runs WHERE id=?').get(row.current_run_id)?.metadata, {})?.supercode, run: row.current_run_id } : null;
+    projection.cards.set(row.id, { row, slots, current });
+  };
+  if (change.reset) {
+    projection.cards.clear();
+    let cursor = '';
+    for (;;) {
+      await yieldToOwner(); if (!unchanged()) return null;
+      const rows = readBoundary(db, () => db.prepare(`${CARD_ROWS} WHERE t.id>? ORDER BY t.id LIMIT 32`).all(cursor));
+      if (!rows.length) break;
+      readBoundary(db, () => { for (const row of rows) refresh(row); });
+      cursor = rows.at(-1).id;
+      if (rows.length < 32) break;
+    }
+  } else {
+    for (let at = 0; at < change.cards.length; at += 32) {
+      await yieldToOwner(); if (!unchanged()) return null;
+      readBoundary(db, () => { for (const id of change.cards.slice(at, at + 32)) {
+        projection.cards.delete(id);
+        refresh(db.prepare(`${CARD_ROWS} WHERE t.id=?`).get(id));
+      } });
     }
-    if (rows.length < 64) break;
-    cursor = rows.at(-1).id;
-    await yieldToOwner();
   }
-  return new Map([...out].filter(([, s]) => s));
+  if (change.reset || change.cards.length) projection.cards = new Map([...projection.cards].sort(([a],[b]) => a < b ? -1 : a > b ? 1 : 0));
+  projection.token = change.token;
+  return projection.cards;
 }
 
 const sameRevision = (a, b) => Object.keys(a).every(key => a[key] === b[key]);
@@ -89,28 +113,18 @@ export async function holdings(board, options) {
  */
 async function readHoldings(board, { lanes, fleetOk, alive, liveRecord, modelOf = () => null, storedOf = null, machineOf, home = null, runLaneOf = null }, unchanged) {
   const out = [];
-  let cursor = '';
-  const high = board.db.prepare('SELECT MAX(id) AS id FROM tasks').get()?.id ?? '';
-  for (;;) {
-    await yieldToOwner();
-    if (!unchanged()) return null;
-    // Limit candidates before filtering or joining: even a page containing only archived/detached cards is bounded.
-    const candidates = board.db.prepare('SELECT id FROM tasks WHERE id>? AND id<=? ORDER BY id LIMIT 32').all(cursor, high);
-    if (!candidates.length) break;
-    cursor = candidates.at(-1).id;
-    const rows = board.db.prepare(`SELECT t.id,t.status,t.assignee,t.current_run_id,t.model_override,c.machine,c.subtask_of
-      FROM tasks t LEFT JOIN supercode_cards c ON c.task_id=t.id
-      WHERE t.id IN (SELECT value FROM json_each(?)) AND t.status!='archived' AND c.detached IS NULL`)
-      .all(JSON.stringify(candidates.map(row => row.id)));
-    for (const row of rows) {
-      await yieldToOwner();
-      if (!unchanged()) return null;
+  const rows = await currentHoldings(board.db, unchanged);
+  if (rows === null) return null;
+  const custody = new Set(board.db.prepare('SELECT address FROM supercode_session_custody').all().map(row => row.address));
+  let at = 0;
+  for (const { row, slots, current: retainedCurrent } of rows.values()) {
+      if (at++ % 32 === 0) { await yieldToOwner(); if (!unchanged()) return null; }
       const lane = lanes[row.assignee] ?? {};
       const card = {
-        card: row.id, board: board.slug, assignee: row.assignee ?? null, status: statusOf(board.db, row),
+        card: row.id, board: board.slug, assignee: row.assignee ?? null, status: row.stage,
         // what the board stores for an arc is read through its workflow's stored_as rules now, never the column a write has
         // not yet brought up to date (a paused card counted as running until its row caught up)
-        stored: !row.subtask_of && storedOf ? storedOf(row.id) : row.status,
+        stored: json(row.backlog, null) ? row.stage : !row.subtask_of && storedOf ? storedOf(row.id, row) : row.status,
         // a card that names no machine runs on this home's: a cap on this machine counts it
         machine: row.machine ? machineOf(row.machine) : home,
         model: row.model_override ?? lane.model ?? null, harness: lane.harness ?? null,
@@ -124,15 +138,16 @@ async function readHoldings(board, { lanes, fleetOk, alive, liveRecord, modelOf
             : executionHost(runLaneOf ? runLaneOf(row) : lane, row.machine, home, machineOf), harness: s.harness ?? card.harness ?? 'claude-code',
           model: (s.session_id ? modelOf(s) : null) ?? configured };
       };
-      const sessions = fleetOk ? await sessionsOf(board.db, row.id, unchanged) : new Map();
-      if (sessions === null) return null;
+      const sessions = fleetOk ? slots : [];
       const held = [];
       let current = null;
       if (row.current_run_id) {
-        current = { ...json(board.db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(row.current_run_id)?.metadata, {})?.supercode, run: row.current_run_id };
+        current = retainedCurrent;
         out.push({ ...sessionOf(current, current.slot ?? 'worker'), session: undefined, slot: undefined, counts: 'runs' });
       }
-      for (const [slot, s] of sessions) {
+      for (const s of sessions) {
+        const slot = s.slot ?? 'worker';
+        if (s.detached_at || s.close_confirmed_at || s.released || custody.has(sessionAddress(s))) continue;
         if (!alive(s)) continue;
         const session = sessionOf(s, slot);
         held.push(session);
@@ -145,7 +160,6 @@ async function readHoldings(board, { lanes, fleetOk, alive, liveRecord, modelOf
       // until it is done); its model and harness are its run's session's, else its newest live session's, else its own
       // a subtask is a task of its arc: it never runs or holds a slot of its own
       if (!row.subtask_of) out.push({ ...(held[0] ?? { ...card, unconfigured: !card.model }), session: undefined, slot: undefined, counts: 'cards' });
-    }
   }
   return out;
 }

package/board/card-state.mjs

@@ -11,19 +11,28 @@ export const cardStateSql = ({ nativeHolds = false } = {}) => nativeHolds ? `CAS
   WHEN COALESCE(c.stage,t.status) IN ('done','cancelled','archived') OR t.status = 'archived' THEN t.status
   WHEN c.paused IS NOT NULL AND c.paused != 'null' THEN 'paused'
   WHEN CASE WHEN json_valid(c.blocked_by) THEN json_array_length(c.blocked_by) ELSE 0 END > 0 THEN 'blocked'
+  WHEN c.backlog IS NOT NULL AND c.backlog != 'null' THEN 'todo'
   WHEN t.status IN ('paused','blocked') THEN CASE WHEN COALESCE(c.stage,t.status) IN ('paused','blocked') THEN 'todo' ELSE COALESCE(c.stage,t.status) END
   ELSE t.status END` : 't.status';
 
 export function cardState(task, { nativeHolds = false } = {}) {
   const paused = parse(task.paused, null);
+  const backlog = parse(task.backlog, null);
   const blocked_by = parse(task.blocked_by, []);
   const lane = task.stage ?? task.workflow_status ?? task.status;
   const ended = ['done', 'cancelled', 'archived'].includes(lane) || task.status === 'archived';
   const status = !nativeHolds ? task.status : ended ? task.status : paused ? 'paused' : blocked_by.length ? 'blocked'
-    : task.status === 'blocked' || task.status === 'paused' ? (['blocked', 'paused'].includes(lane) ? 'todo' : lane) : task.status;
-  return { ...task, status, paused, blocked_by };
+    : backlog ? 'todo' : task.status === 'blocked' || task.status === 'paused' ? (['blocked', 'paused'].includes(lane) ? 'todo' : lane) : task.status;
+  return { ...task, status, paused, backlog, blocked_by };
 }
 
-export const holdDescription = (task) => task.status === 'paused' && task.paused
-  ? `paused by ${task.paused.by ?? 'unknown'}: ${task.paused.reason ?? 'reason not recorded'}`
-  : task.status === 'blocked' && task.blocked_by?.length ? `blocked by ${task.blocked_by.map(b => `${b.id}${b.reason ? `: ${b.reason}` : ''}`).join(', ')}` : null;
+const deadlineText = (until) => {
+  const date = new Date(Number.isFinite(until) ? until * 1000 : NaN);
+  return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+};
+
+export const holdDescription = (task) => [
+  task.backlog && `backlog by ${task.backlog.by ?? 'unknown'}: ${task.backlog.reason ?? 'reason not recorded'}`,
+  task.status === 'paused' && task.paused && `paused by ${task.paused.by ?? 'unknown'}${deadlineText(task.paused.until) ? ` until ${deadlineText(task.paused.until)}` : ' (deadline not recorded)'}: ${task.paused.reason ?? 'reason not recorded'}`,
+  task.status === 'blocked' && task.blocked_by?.length && `blocked by ${task.blocked_by.map(b => `${b.id}${b.reason ? `: ${b.reason}` : ''}`).join(', ')}`,
+].filter(Boolean).join('; ') || null;