@volter/supercode-orchestrator 0.4.140 → 0.4.141

package/board/cli.mjs

@@ -385,7 +385,7 @@ export async function runWorkflow(argv) {
       const card = withBoard((b) => {
         const got = engine.showCard(b.db, id);
         got.runs = engine.runs(b.db, id, { stateType: args['state-type'] ?? null, stateName: args['state-name'] ?? null });
-        got.diagnostics = engine.diagnose(b.db, got.task, { failureLimit: settings.failureLimit });
+        got.diagnostics = engine.diagnose(b.db, got.task, { failureLimit: settings.failureLimit, launchWindowSeconds: settings.launchWindow });
         got.stage = statusOf(b.db, got.task);
         got.time = scopeOf(b.db, b, got.task, { params: workflowFor(root).params }).card.time;
         return got;
@@ -644,7 +644,7 @@ export async function runWorkflow(argv) {
       const order = ['warning', 'error', 'critical'];
       const found = withBoard((b) => {
         const cards = args.task ? [engine.getTask(b.db, args.task)].filter(Boolean) : engine.listCards(b.db, {});
-        return cards.flatMap((t) => engine.diagnose(b.db, t, { failureLimit: settings.failureLimit, fleet }).map((d) => ({ task: t.id, title_of_task: t.title, ...d })))
+        return cards.flatMap((t) => engine.diagnose(b.db, t, { failureLimit: settings.failureLimit, fleet, launchWindowSeconds: settings.launchWindow }).map((d) => ({ task: t.id, title_of_task: t.title, ...d })))
           .filter((d) => !args.severity || order.indexOf(d.severity) >= order.indexOf(args.severity));
       });
       if (args.json) { say(args, '', found); return 0; }

package/board/dispatch.mjs

@@ -195,6 +195,7 @@ export function boardSettings(params = {}) {
     failureLimit: pos(params.failure_limit) ?? DEFAULT_FAILURE_LIMIT,
     ttl: claimTtl(params.claim_ttl_seconds),
     grace: pos(params.session_grace_seconds) ?? 120,
+    launchWindow: pos(params.session_launch_window_seconds) ?? 300,
     interval: Math.max(Number(params.dispatch_interval_seconds) || 60, 1),
     idleQuiet: pos(params.session_idle_quiet_seconds) ?? 600,
     logRotateBytes: pos(params.worker_log_rotate_bytes) ?? 2 * 1024 * 1024,
@@ -258,10 +259,6 @@ function supervise(board, fleet, settings, report, entry, effects) {
       if (!task || (entry.workflow.run ? !task.current_run_id : task.status !== 'running')) return;
       const runRow = currentRun(db, id);
       let session = runRow?.metadata?.supercode ?? null;
-      if (session?.launch_pending || session?.launch_deferred) {
-        extendClaim(db, id, { ttl: settings.ttl, reason: 'launch_receipt_pending' });
-        return; // An uncertain launch owns this run until a machine receipt settles it.
-      }
       if (session?.pane) {
         let found;
         try { found = continuationPane(fleet, session, observed.get(session.machine)); }
@@ -286,6 +283,20 @@ function supervise(board, fleet, settings, report, entry, effects) {
         }
       };
       const limits = limitsOf(db, board, entry, task, session);
+      if (runRow && (session?.launch_pending || session?.launch_deferred || (!session?.session_id && !session?.pid))) {
+        const age = t - Number(session?.launched_at ?? runRow.started_at);
+        if (age >= settings.launchWindow) {
+          const reason = session?.launch_deferred_error ?? session?.launch_error ?? 'no session or process was bound to the dispatched run';
+          const error = `launch window ${settings.launchWindow}s expired after ${age}s: ${reason}`;
+          if (!session?.launch_expired_at) {
+            setRunSession(db, runRow.id, { launch_expired_at: t, launch_error: error });
+            event(db, id, 'session_launch_expired', { error, age_seconds: age, window_seconds: settings.launchWindow, key: session?.launch_key ?? null, pane: session?.pane ?? null }, runRow.id);
+          }
+          observe('spawn_failed', { error, launch_window_seconds: settings.launchWindow }, null);
+          report.failed.push([id, error]);
+        } else extendClaim(db, id, { ttl: settings.ttl, reason: 'launch_receipt_pending' });
+        return;
+      }
       // Availability is the same retained linked/unlinked feed subscribers hear.
       // A failed stream is unknown, not evidence that every remote machine left.
       if (session?.session_id && session.surface !== 'headless') {
@@ -681,7 +692,7 @@ export function closeRequested(board, report, { taskId = null, caller = null } =
       if (observed.error) throw new Error(observed.error);
       if (observed.live.has(session.pane)) {
         const pendingNotice = view(board, (db) => db.prepare("SELECT id FROM supercode_effects WHERE json_extract(effect, '$.kind')='session_notice' AND json_extract(effect, '$.runId')=? LIMIT 1").get(row.id));
-        if (pendingNotice || session.lifecycle_notice_pending) throw new Error(`close deferred: lifecycle notice ${session.lifecycle_notice_pending} has not been delivered: ${session.lifecycle_notice_error ?? 'pending'}`);
+        if (pendingNotice || session.lifecycle_notice_pending) throw new Error(`close deferred: lifecycle notice ${pendingNotice?.id ?? session.lifecycle_notice_pending} has not been delivered: ${session.lifecycle_notice_error ?? 'pending'}`);
         const protectedNow = view(board, (db) => db.prepare(`SELECT 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) => { const s = json(r.metadata, {})?.supercode; return s?.pane === session.pane && normalMachine(s.machine) === normalMachine(session.machine); });
         if (protectedNow) throw new Error(`close deferred: pane ${session.pane} is owned by an unended run`);
@@ -951,8 +962,9 @@ export function reconcileCallerLaunch(board, sid) {
 }
 
 function reconcileLaunches(board, fleet, report, entry, effects, settings, lanes) {
-  const deferred=view(board,db=>db.prepare("SELECT t.id FROM tasks t JOIN task_runs r ON r.id=t.current_run_id WHERE r.ended_at IS NULL AND json_extract(r.metadata,'$.supercode.launch_deferred')=1").all());
-  for(const {id} of deferred) {
+  const deferred=view(board,db=>db.prepare("SELECT t.id,r.started_at FROM tasks t JOIN task_runs r ON r.id=t.current_run_id WHERE r.ended_at IS NULL AND json_extract(r.metadata,'$.supercode.launch_deferred')=1").all());
+  for(const {id,started_at} of deferred) {
+    if (now() - started_at >= settings.launchWindow) continue;
     try {
       const task=getTaskNow(board,id),status=view(board,db=>statusOf(db,task)),spec=runSpec(entry,status,task);
       const profile=spec&&view(board,db=>evaluate(entry.workflow.roles?.[spec.role]??'card.assignee',scopeOf(db,board,task,{params:entry.params})));

package/board/engine.mjs

@@ -710,11 +710,21 @@ const hours = (s) => s / 3600;
  * same thing can go wrong, and supercode's own where only its sessions can): each `{ kind, severity, title, data,
  * actions }`, worst first.
  */
-export function diagnose(db, task, { failureLimit = DEFAULT_FAILURE_LIMIT, strandedSeconds = 30 * 60, blockedHours = 24, fleet = null } = {}) {
+export function diagnose(db, task, { failureLimit = DEFAULT_FAILURE_LIMIT, strandedSeconds = 30 * 60, blockedHours = 24, fleet = null, launchWindowSeconds = 300 } = {}) {
   const out = [];
   const t = now();
   const events = all(db, 'SELECT kind, payload, created_at FROM task_events WHERE task_id = ? ORDER BY id', task.id);
   const failures = Number(task.consecutive_failures || 0);
+  const active = task.current_run_id ? one(db, 'SELECT id,started_at,metadata FROM task_runs WHERE id=?', task.current_run_id) : null;
+  const session = json(active?.metadata, {})?.supercode;
+  if (active && (session?.launch_pending || session?.launch_deferred || (!session?.session_id && !session?.pid))) {
+    const age = t - Number(session?.launched_at ?? active.started_at);
+    const reason = session?.launch_deferred_error ?? session?.launch_error ?? 'no session or process has been bound';
+    out.push({ kind: 'session_launch_pending', severity: age >= launchWindowSeconds ? 'error' : 'warning',
+      title: `run ${active.id} has no confirmed session after ${age}s: ${reason}`,
+      data: { run_id: active.id, age_seconds: age, window_seconds: launchWindowSeconds, reason, launch_key: session?.launch_key ?? null, pane: session?.pane ?? null },
+      actions: [`supercode workflow log ${task.id}`] });
+  }
   if (failures >= Math.max(1, (task.max_retries ?? failureLimit) - 1) && task.status !== 'done') {
     out.push({ kind: 'repeated_failures', severity: task.status === 'blocked' ? 'error' : 'warning', title: `${failures} consecutive failures`,
       data: { failures, last_error: task.last_failure_error }, actions: [`supercode workflow reclaim ${task.id}`, `supercode workflow reassign ${task.id} <profile>`] });

package/package.json

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