@volter/supercode-orchestrator 0.4.139 → 0.4.141

package/board/cli.mjs

@@ -9,7 +9,7 @@ import { spawnSync } from 'node:child_process';
 import { basename, join, resolve } from 'node:path';
 import { tmpdir } from 'node:os';
 import { read } from '../orchestration.mjs';
-import { view, backingPaths, layOut, backingOf, boardExists, boardPath, DEFAULT_BOARD, event, json, listBoards, logsDir, now, openBoard, setActor, tx } from './store.mjs';
+import { actorOf, view, backingPaths, layOut, backingOf, boardExists, boardPath, DEFAULT_BOARD, event, json, listBoards, logsDir, now, openBoard, setActor, tx } from './store.mjs';
 import { isLocalWorkspace } from './workspace.mjs';
 import { openZtrackBoard } from './ztrack.mjs';
 import * as engine from './engine.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; }
@@ -1090,7 +1090,8 @@ function rolesFor(db, cardId, sessionId, params = {}) {
   const task = engine.getTask(db, cardId);
   if (!task) return [];
   const roles = [];
-  if (completionOwnerOf(db, cardId)?.endsWith(`:${sessionId}`)) roles.push('creator');
+  const creator = completionOwnerOf(db, cardId);
+  if (creator && creator === actorOf()) roles.push('creator');
   const current = task.current_run_id ? json(db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(task.current_run_id)?.metadata, {})?.supercode : null;
   if (current?.session_id === sessionId) roles.push(current.role ?? 'implementer');
   else if (engine.lastSession(db, cardId)?.session_id === sessionId) roles.push('implementer');
@@ -1111,7 +1112,8 @@ function authorize(db, verb, rest, args, own) {
   if (args.all) refuse(`does not ${verb} every card; only its own`);
   const card = engine.getTask(db, rest[0]);
   if (!card) return; // the verb itself answers "no card"
-  if (completionOwnerOf(db, card.id)?.endsWith(`:${callerSession()}`)) return; // its declared creator doors still govern the act
+  const creator = completionOwnerOf(db, card.id);
+  if (creator && creator === actorOf()) return;
   // a card's session writes its own card and its subtasks; what it may do with them is the workflow's (`by`)
   if (card.id !== own.id && card.subtask_of !== own.id) refuse(`writes only its own card and its subtasks, not ${card.id}`);
   for (const other of args.ids ?? []) if (other !== own.id && engine.getTask(db, other)?.subtask_of !== own.id) refuse(`writes only its own card and its subtasks, not ${other}`);

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

@@ -205,7 +205,7 @@ export function createCard(board, spec) {
                tenant, idempotency_key, max_runtime_seconds, skills, max_retries, model_override, provider_override, reasoning_effort, session_id,
                project_id, goal_mode, goal_max_turns)
              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      id, title, spec.body ?? null, spec.assignee || null, 'todo', Number(spec.priority) || 0, spec.createdBy ?? 'user', t, ws.kind, ws.path,
+      id, title, spec.body ?? null, spec.assignee || null, 'todo', Number(spec.priority) || 0, actorOf() ?? spec.createdBy ?? 'user', t, ws.kind, ws.path,
       spec.branch ?? null, spec.tenant ?? null, spec.idempotencyKey ?? null, spec.maxRuntime ?? null,
       spec.skills?.length ? JSON.stringify(spec.skills) : null, spec.maxRetries ?? null, spec.model ?? null, spec.provider ?? null,
       spec.reasoning ?? null, spec.sessionId ?? null, spec.project ?? null, spec.goal ? 1 : 0, spec.goal?.maxTurns ?? null);
@@ -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/board/workflow.mjs

@@ -66,20 +66,7 @@ export function creatorOf(db, id) {
   return payload.source !== 'document' && /^(?:sc:[^:]+:[^:]+:|hermes-run:)/.test(address ?? '') ? address : null;
 }
 
-/** Open subtasks are the current parent worker's plan. Keep creation history
- * immutable while transferring its creator doors when that worker is replaced. */
 export function completionOwnerOf(db, id) {
-  const task = one(db, 'SELECT t.status,c.subtask_of FROM tasks t LEFT JOIN supercode_cards c ON c.task_id=t.id WHERE t.id=?', id);
-  if (task?.subtask_of && !['done', 'archived'].includes(task.status)) {
-    for (const row of all(db, 'SELECT metadata FROM task_runs WHERE task_id=? ORDER BY id DESC', task.subtask_of)) {
-      const session = json(row.metadata, {})?.supercode;
-      if (!session || (session.slot ?? 'worker') !== 'worker') continue;
-      // An unbound replacement leaves authority with the manager; it never
-      // revives the previous worker's ability to finish the new worker's plan.
-      return session.address ?? (session.machine && session.harness && session.session_id
-        ? `sc:${session.machine}:${session.harness}:${session.session_id}` : null);
-    }
-  }
   return creatorOf(db, id);
 }
 
@@ -377,7 +364,12 @@ export function fire(db, board, entry, id, name, { roles = [], payload = {}, ext
   // `sender`: the roles the event was sent with (a validator can ask who is asking)
   const scope = scopeOf(db, board, task, { params, event: payload, extra: { lanes: lanesIn(entry), ...extra, sender: roles } });
   const allowed = candidates.filter((t) => !t.by?.length || t.by.some((r) => roles.includes(r)));
-  if (!allowed.length) throw new Error(`${id} is ${from}; ${name.replace(/_/g, '-')} there is for ${[...new Set(candidates.flatMap((t) => t.by ?? []))].join(' or ')}. ${candidates.map((t) => t.description).filter(Boolean).join(' ')}`);
+  if (!allowed.length) {
+    const state = name === 'complete' ? 'done' : name === 'cancel' ? 'cancelled' : null;
+    const request = state && candidates.some(transition => transition.by?.includes('creator'))
+      ? ` Ask the manager with workflow request-state ${id} --state ${state} --reason <why> --evidence <verdict-and-pointers>.` : '';
+    throw new Error(`${id} is ${from}; ${name.replace(/_/g, '-')} there is for ${[...new Set(candidates.flatMap((t) => t.by ?? []))].join(' or ')}. ${candidates.map((t) => t.description).filter(Boolean).join(' ')}${request}`);
+  }
   const taken = allowed.find((t) => holds(t.guard ?? null, scope));
   if (!taken) {
     const state = scope.card;

package/package.json

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