@volter/supercode-orchestrator 0.4.28 → 0.4.30

package/board/cli.mjs

@@ -12,7 +12,9 @@ import { read } from '../orchestration.mjs';
 import { holdDispatcherLock } from '../hermes-locks.mjs';
 import { boardPath, DEFAULT_BOARD, event, json, listBoards, now, openBoard, tx } from './store.mjs';
 import * as engine from './engine.mjs';
-import { adoptSession, boardLabel, boardSettings, lanesOf, localMachine, observeFleet, paused, startTriageSession, tick } from './dispatch.mjs';
+import { adoptSession, boardLabel, boardSettings, lanesOf, localMachine, observeFleet, paused, startCard, tick } from './dispatch.mjs';
+import { loadWorkflow, useWorkflow, workflowEntry } from './workflow.mjs';
+import { evaluate } from './expr.mjs';
 
 const HELP = `supercode workflow <verb> [--root <home>] [--board <slug>] [--json]
 
@@ -148,8 +150,12 @@ function counts(root, slug) {
 /** The home's lanes (profiles' workers) and board settings (the root config's `kanban:` block), as the IR reads them. */
 async function laneState(root) {
   const orchestration = await read(root);
-  const kanban = orchestration.profiles?.default?.residue?.config?.kanban ?? {};
-  return { lanes: lanesOf(orchestration.profiles), settings: boardSettings(kanban), kanban, profiles: Object.keys(orchestration.profiles ?? {}) };
+  // the board's settings are its workflow's params (the instance's, under the home's own `kanban:` keys)
+  const entry = useWorkflow(root, workflowEntry(orchestration));
+  const settings = boardSettings(entry.params);
+  const tick = Number(evaluate(entry.workflow.dispatch.tick, { params: entry.params }));
+  if (tick > 0) settings.interval = tick;
+  return { lanes: lanesOf(orchestration.profiles), settings, kanban: entry.params, profiles: Object.keys(orchestration.profiles ?? {}) };
 }
 
 /** The caller's own supercode address, when it is a session supercode can reach (for its card's notices). */
@@ -207,6 +213,7 @@ export async function runWorkflow(argv) {
   const slug = boardOf(root, args);
   const open = (create = false) => { const b = openBoard(root, slug, { create }); b.label = boardLabel(root, slug); return b; };
   const withBoard = (fn, create = false) => { const b = open(create); try { return fn(b); } finally { b.close(); } };
+  const withBoardAsync = async (fn) => { const b = open(); try { return await fn(b); } finally { b.close(); } };
   const id = rest[0];
   const need = (n, what) => { if (rest.length < n) throw new Error(`${verb} needs ${what}`); };
   const ids = (first = rest) => [...first, ...(args.ids ?? [])];
@@ -216,6 +223,9 @@ export async function runWorkflow(argv) {
   if (sid && !READS.has(verb) && existsSync(boardPath(root, slug))) {
     withBoard((b) => { const own = ownCard(b.db, sid); if (own) authorize(b.db, verb, rest, args, own); });
   }
+  // the board's workflow (the IR's): what each verb does, and who may send it, is its
+  if (!READS.has(verb) && verb !== 'help') await loadWorkflow(root).catch((error) => { if (verb !== 'init' && verb !== 'boards') throw error; });
+  engine.setCaller((db, cardId) => rolesFor(db, cardId, sid));
 
   switch (verb) {
     case 'init': {
@@ -368,23 +378,23 @@ export async function runWorkflow(argv) {
       return 0;
     }
 
-    case 'assign': need(2, 'a card id and a profile (or none)'); withBoard((b) => engine.assign(b, id, rest[1] === 'none' ? null : rest[1])); say(args, `Assigned ${id} to ${rest[1] === 'none' ? '(nobody)' : rest[1]}`, { ok: true }); return 0;
+    case 'assign': need(2, 'a card id and a profile (or none)'); await withBoardAsync((b) => engine.assign(b, id, rest[1] === 'none' ? null : rest[1])); say(args, `Assigned ${id} to ${rest[1] === 'none' ? '(nobody)' : rest[1]}`, { ok: true }); return 0;
     case 'reassign': {
       need(2, 'a card id and a profile');
-      withBoard((b) => {
+      await withBoardAsync(async (b) => {
         const task = tx(b, (db) => engine.getTask(db, id));
-        if (task?.status === 'running' && args.reclaim) engine.reclaim(b, id, args.reason ?? 'reassign');
-        engine.assign(b, id, rest[1] === 'none' ? null : rest[1]);
+        if (task?.status === 'running' && args.reclaim) await engine.reclaim(b, id, args.reason ?? 'reassign');
+        await engine.assign(b, id, rest[1] === 'none' ? null : rest[1]);
       });
       say(args, `Reassigned ${id} to ${rest[1]}`, { ok: true }); return 0;
     }
-    case 'set-model': need(1, 'a card id'); withBoard((b) => engine.setModel(b, id, rest[1] ?? null, args.provider ?? null)); say(args, rest[1] ? `${id} runs on model ${rest[1]}${args.provider ? ` (${args.provider})` : ''} from its next start` : `${id} uses its profile's model`, { ok: true }); return 0;
+    case 'set-model': need(1, 'a card id'); await withBoardAsync((b) => engine.setModel(b, id, rest[1] ?? null, args.provider ?? null)); say(args, rest[1] ? `${id} runs on model ${rest[1]}${args.provider ? ` (${args.provider})` : ''} from its next start` : `${id} uses its profile's model`, { ok: true }); return 0;
     case 'set-goal': {
       // a card into goal mode (or out of it with --off) from its next idle turn: the heartbeat keeps its session going
       need(1, 'a card id');
       const maxTurns = args['goal-max-turns'] ? Number(args['goal-max-turns']) : null;
       if (maxTurns !== null && !(Number.isInteger(maxTurns) && maxTurns >= 1)) throw new Error('--goal-max-turns is a whole number of turns, at least 1');
-      for (const t of ids()) withBoard((b) => engine.setGoal(b, t, { on: !args.off, maxTurns }));
+      for (const t of ids()) await withBoardAsync((b) => engine.setGoal(b, t, { on: !args.off, maxTurns }));
       say(args, ids().map((t) => args.off ? `${t} is no longer a goal card` : `${t} is a goal card${maxTurns ? ` (${maxTurns} turns)` : ''}`).join('\n'), { ok: true }); return 0;
     }
     case 'move': need(2, 'a card id and a machine (or none)'); withBoard((b) => engine.setMachine(b, id, rest[1] === 'none' ? null : rest[1])); say(args, `${id} runs on ${rest[1]}`, { ok: true }); return 0;
@@ -405,17 +415,17 @@ export async function runWorkflow(argv) {
       say(args, workspace ?? `(claimed ${id}; its ${task.workspace_kind} workspace is made where it starts)`, { ok: true, run_id: runId, workspace });
       return 0;
     }
-    case 'reclaim': need(1, 'a card id'); withBoard((b) => engine.reclaim(b, id, args.reason ?? (rest.slice(1).join(' ') || null))); say(args, `Reclaimed ${id}`, { ok: true }); return 0;
-    case 'heartbeat': need(1, 'a card id'); withBoard((b) => engine.heartbeat(b, id, args.note ?? null)); say(args, `Heartbeat recorded for ${id}`, { ok: true }); return 0;
+    case 'reclaim': need(1, 'a card id'); await withBoardAsync((b) => engine.reclaim(b, id, args.reason ?? (rest.slice(1).join(' ') || null))); say(args, `Reclaimed ${id}`, { ok: true }); return 0;
+    case 'heartbeat': need(1, 'a card id'); await withBoardAsync((b) => engine.heartbeat(b, id, args.note ?? null)); say(args, `Heartbeat recorded for ${id}`, { ok: true }); return 0;
 
-    case 'link': need(2, 'a parent and a child'); withBoard((b) => engine.link(b, rest[0], rest[1])); say(args, `Linked ${rest[0]} -> ${rest[1]}`, { ok: true }); return 0;
-    case 'unlink': { need(2, 'a parent and a child'); const gone = withBoard((b) => engine.unlink(b, rest[0], rest[1])); say(args, gone ? `Unlinked ${rest[0]} -> ${rest[1]}` : `no link ${rest[0]} -> ${rest[1]}`, { ok: gone }); return gone ? 0 : 1; }
+    case 'link': need(2, 'a parent and a child'); await withBoardAsync((b) => engine.link(b, rest[0], rest[1])); say(args, `Linked ${rest[0]} -> ${rest[1]}`, { ok: true }); return 0;
+    case 'unlink': { need(2, 'a parent and a child'); const gone = await withBoardAsync((b) => engine.unlink(b, rest[0], rest[1])); say(args, gone ? `Unlinked ${rest[0]} -> ${rest[1]}` : `no link ${rest[0]} -> ${rest[1]}`, { ok: gone }); return gone ? 0 : 1; }
 
     case 'comment': {
       need(2, 'a card id and the text');
       let text = rest.slice(1).join(' ');
       if (args['max-len']) text = text.slice(0, Number(args['max-len']));
-      const n = withBoard((b) => engine.comment(b, id, args.author ?? callerAddress() ?? callerName(), text));
+      const n = await withBoardAsync((b) => engine.comment(b, id, args.author ?? callerAddress() ?? callerName(), text));
       say(args, `Comment added to ${id}`, { ok: true, comment: n }); return 0;
     }
     case 'attach': {
@@ -448,45 +458,49 @@ export async function runWorkflow(argv) {
     case 'complete': {
       need(1, 'a card id');
       const metadata = metadataOf(args.metadata);
-      for (const t of rest) withBoard((b) => engine.complete(b, t, { summary: args.summary ?? null, result: args.result ?? null, metadata: metadata ?? null }));
+      for (const t of rest) await withBoardAsync((b) => engine.complete(b, t, { summary: args.summary ?? null, result: args.result ?? null, metadata: metadata ?? null }));
       say(args, rest.map((t) => `Completed ${t}`).join('\n'), { ok: true, completed: rest }); return 0;
     }
     case 'edit': {
       need(1, 'a card id');
       if (args.result === undefined) throw new Error('edit needs --result');
-      withBoard((b) => engine.editResult(b, id, { result: args.result, summary: args.summary ?? null, metadata: metadataOf(args.metadata) }));
+      await withBoardAsync((b) => engine.editResult(b, id, { result: args.result, summary: args.summary ?? null, metadata: metadataOf(args.metadata) }));
       say(args, `Edited ${id}`, { ok: true }); return 0;
     }
     case 'block': {
       need(1, 'a card id');
       const reason = rest.slice(1).join(' ') || null;
-      const results = [id, ...(args.ids ?? [])].map((t) => [t, withBoard((b) => engine.block(b, t, { reason, kind: args.kind ?? null }))]);
+      const results = [];
+      for (const t of [id, ...(args.ids ?? [])]) results.push([t, (await withBoardAsync((b) => engine.block(b, t, { reason, kind: args.kind ?? null }))).to]);
       say(args, results.map(([t, s]) => `${s === 'todo' ? 'Waiting on dependencies' : s === 'triage' ? 'Routed to triage' : 'Blocked'} ${t}`).join('\n'), { ok: true, results }); return 0;
     }
     case 'schedule': {
       need(1, 'a card id');
       const reason = rest.slice(1).join(' ') || null;
-      for (const t of [id, ...(args.ids ?? [])]) withBoard((b) => engine.schedule(b, t, reason));
+      for (const t of [id, ...(args.ids ?? [])]) await withBoardAsync((b) => engine.schedule(b, t, reason));
       say(args, [id, ...(args.ids ?? [])].map((t) => `Scheduled ${t}`).join('\n'), { ok: true }); return 0;
     }
     case 'unblock': {
       need(1, 'a card id');
-      const results = ids().map((t) => [t, withBoard((b) => engine.unblock(b, t))]);
+      const results = [];
+      for (const t of ids()) results.push([t, (await withBoardAsync((b) => engine.unblock(b, t, { reason: args.reason ?? null }))).to]);
       // Hermes records the reason as a comment on each card it unblocks
-      if (args.reason) for (const [t] of results) withBoard((b) => engine.comment(b, t, callerName(), `UNBLOCK: ${args.reason}`));
+      if (args.reason) for (const [t] of results) await withBoardAsync((b) => engine.comment(b, t, callerName(), `UNBLOCK: ${args.reason}`));
       say(args, results.map(([t, s]) => `Unblocked ${t} → ${s}`).join('\n'), { ok: true, results }); return 0;
     }
-    case 'request-review': need(1, 'a card id'); withBoard((b) => engine.requestReview(b, id, { summary: args.summary ?? null, reviewer: args.reviewer ?? null, metadata: metadataOf(args.metadata) ?? null, force: Boolean(args.force), expectedRunId: workerRun(b.db, id, sid) })); say(args, `${id} → review`, { ok: true }); return 0;
-    case 'request-changes': need(2, 'a card id and the reason'); withBoard((b) => engine.requestChanges(b, id, { reason: rest.slice(1).join(' '), reviewer: args.reviewer ?? callerName() })); say(args, `${id} sent back for changes`, { ok: true }); return 0;
+    case 'request-review': need(1, 'a card id'); await withBoardAsync((b) => engine.requestReview(b, id, { summary: args.summary ?? null, reviewer: args.reviewer ?? null, metadata: metadataOf(args.metadata) ?? null, force: Boolean(args.force), expectedRunId: workerRun(b.db, id, sid) })); say(args, `${id} → review`, { ok: true }); return 0;
+    case 'request-changes': need(2, 'a card id and the reason'); await withBoardAsync((b) => engine.requestChanges(b, id, { reason: rest.slice(1).join(' '), reviewer: args.reviewer ?? callerName() })); say(args, `${id} sent back for changes`, { ok: true }); return 0;
     case 'reopen': {
       // a done card back to work; the cards that built on it are invalidated with it (Hermes's reopen)
       need(1, 'a card id');
-      const results = ids().map((t) => [t, withBoard((b) => engine.reopen(b, t, { author: callerName(), reason: args.reason ?? null }))]);
-      say(args, results.map(([t, r]) => `Reopened ${t} → ${r.status}${r.invalidated?.length ? ` (invalidated ${r.invalidated.map((d) => d.id).join(', ')})` : ''}`).join('\n'), { ok: true, results }); return 0;
+      const results = [];
+      for (const t of ids()) results.push([t, (await withBoardAsync((b) => engine.reopen(b, t, { author: callerName(), reason: args.reason ?? null }))).to]);
+      say(args, results.map(([t, s]) => `Reopened ${t} → ${s}`).join('\n'), { ok: true, results }); return 0;
     }
     case 'reopen-review': {
       need(1, 'a card id');
-      const results = ids().map((t) => [t, withBoard((b) => engine.reopenReview(b, t))]);
+      const results = [];
+      for (const t of ids()) results.push([t, (await withBoardAsync((b) => engine.reopenReview(b, t))).to]);
       say(args, results.map(([t, s]) => `Reopened ${t} → ${s}`).join('\n'), { ok: true, results }); return 0;
     }
     case 'promote': {
@@ -503,11 +517,11 @@ export async function runWorkflow(argv) {
         say(args, verdicts.map((v) => `${v.ok ? 'would promote' : 'would refuse'} ${v.id}${v.reason ? `: ${v.reason}` : ''}`).join('\n'), verdicts);
         return 0;
       }
-      for (const t of targets) withBoard((b) => engine.promote(b, t, { actor: callerName(), reason, force: args.force }));
+      for (const t of targets) await withBoardAsync((b) => engine.promote(b, t, { actor: callerName(), reason, force: args.force }));
       say(args, targets.map((t) => `Promoted ${t} → ready`).join('\n'), { ok: true }); return 0;
     }
     case 'archive': {
-      for (const t of rest) withBoard((b) => engine.archive(b, t));
+      for (const t of rest) await withBoardAsync((b) => engine.archive(b, t));
       const purged = [];
       for (const t of args.rm ?? []) {
         withBoard((b) => tx(b, (db) => {
@@ -530,13 +544,13 @@ export async function runWorkflow(argv) {
       const results = [];
       for (const t of targets) {
         if (verb === 'specify' && (args.title !== undefined || args.body !== undefined)) {
-          withBoard((b) => engine.specify(b, t, { title: args.title ?? null, body: args.body ?? null, author: args.author ?? callerAddress() ?? callerName() }));
+          await withBoardAsync((b) => engine.specify(b, t, { title: args.title ?? null, body: args.body ?? null, author: args.author ?? callerAddress() ?? callerName() }));
           results.push({ id: t, specified: true });
         } else if (verb === 'decompose' && args.child?.length) {
           const children = args.child.map((c) => { const [title, assignee] = c.split(/@(?=[^@]*$)/); return { title: title.trim(), assignee: assignee?.trim() || undefined }; });
-          results.push({ id: t, children: withBoard((b) => engine.decompose(b, t, children, { author: args.author ?? callerAddress() ?? callerName() })) });
+          results.push({ id: t, children: await withBoardAsync((b) => engine.decompose(b, t, children, { author: args.author ?? callerAddress() ?? callerName() })) });
         } else {
-          const session = withBoard((b) => startTriageSession(b, t, lanes, settings, verb));
+          const session = await withBoardAsync((b) => startCard(b, t, { lanes, settings }));
           results.push({ id: t, session: session.address, mode: session.mode });
         }
       }
@@ -944,6 +958,23 @@ const READS = new Set(['list', 'ls', 'show', 'context', 'runs', 'log', 'tail', '
  * comment and attach. Never its arc's completion, and never another arc's card: anything across arcs goes through the
  * fleet's manager.
  */
+/**
+ * Who a caller is on card `cardId`, in the workflow's roles: a person or the fleet's manager at the CLI (no session)
+ * is `manager`; the session of the card's current run has that run's role; the card's working session between runs
+ * is its `implementer`; the session working a subtask's arc is `arc`; any other session is nobody on it.
+ */
+function rolesFor(db, cardId, sessionId) {
+  if (!sessionId) return ['manager'];
+  const task = engine.getTask(db, cardId);
+  if (!task) return [];
+  const roles = [];
+  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');
+  if (task.subtask_of && engine.lastSession(db, task.subtask_of)?.session_id === sessionId) roles.push('arc');
+  return roles;
+}
+
 function authorize(db, verb, rest, args, own) {
   const refuse = (why) => { throw new Error(`the session working ${own.id} ${why}`); };
   if (verb === 'create') {
@@ -952,21 +983,13 @@ function authorize(db, verb, rest, args, own) {
   }
   if (verb === 'boards') { if (!['list', 'ls', 'show', 'current', undefined].includes(rest[0])) refuse('does not change the home\'s boards'); return; }
   // verbs that act on the board rather than on a card are the manager's and the board's, never a card's session's
-  if (['pause', 'resume', 'swarm', 'dispatch', 'daemon', 'serve', 'gc', 'repair', 'adopt', 'close', 'move', 'reassign', 'assign', 'set-model', 'set-goal', 'claim', 'reclaim', 'archive', 'promote', 'schedule', 'link', 'unlink', 'edit', 'reopen-review', 'reopen', 'attach-rm'].includes(verb)) refuse(`does not ${verb}; the fleet's manager does`);
+  // (what a session may do to a card is its workflow's: each transition's `by`)
+  if (['pause', 'resume', 'swarm', 'dispatch', 'daemon', 'serve', 'gc', 'repair', 'adopt', 'close', 'move', 'claim', 'attach-rm'].includes(verb)) refuse(`does not ${verb}; the fleet's manager does`);
   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"
-  const mine = card.id === own.id;
-  const sub = card.subtask_of === own.id;
-  // a session started from the review lane is the card's reviewer: its verdict is its to give
-  const reviewing = mine && json(db.prepare("SELECT payload FROM task_events WHERE task_id = ? AND kind = 'claimed' ORDER BY id DESC LIMIT 1").get(card.id)?.payload, {})?.source_status === 'review';
-  if (reviewing && ['complete', 'request-changes'].includes(verb)) return;
-  const allowed = {
-    comment: mine || sub, block: mine || sub, heartbeat: mine, 'request-review': mine || sub, attach: mine || sub,
-    specify: mine, decompose: mine, complete: sub, unblock: sub, 'notify-subscribe': mine || sub, 'notify-unsubscribe': mine || sub,
-  }[verb];
-  if (!allowed) refuse(mine ? `cannot ${verb} its own card; its reviewers and the fleet's manager do` : `writes only its own card and its subtasks, not ${card.id}`);
-  if (verb === 'block' && mine && !args.kind) refuse('blocks its card with a typed reason (--kind needs_input|capability|transient|dependency)');
+  // 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}`);
 }
 
@@ -1020,6 +1043,7 @@ async function serve(root, args = {}) {
     while (!stopped) {
       pausedSaid = Boolean(paused(root)) && pausedSaid;
       let interval = 60;
+      const began = Date.now();
       try {
         const state = await laneState(root);
         const settings = { ...state.settings, ...override };
@@ -1027,6 +1051,7 @@ async function serve(root, args = {}) {
         for (const r of await tick({ root, lanes: state.lanes, settings })) {
           const said = summary(r);
           if (!said.endsWith('nothing to do') || args.verbose) log(said);
+          if (args.verbose && r.ms) log(`  took ${Object.entries(r.ms).map(([k, v]) => `${k} ${(v / 1000).toFixed(1)}s`).join(', ')}`);
           if (r.paused && !pausedSaid) { log(`new starts paused by ${r.paused} (\`supercode workflow resume\` lifts it)`); pausedSaid = true; }
           // Hermes's stuck warning: ready work for six ticks running and nothing started
           stuck[r.board] = r.ready_waiting && !r.started.length && !r.paused ? (stuck[r.board] ?? 0) + 1 : 0;
@@ -1038,7 +1063,9 @@ async function serve(root, args = {}) {
       } catch (error) {
         log(`tick failed: ${error.message}`);
       }
-      for (let waited = 0; waited < interval && !stopped; waited += 1) await new Promise((done) => setTimeout(done, 1000));
+      // the next tick is due an interval after this one began (a long tick is not followed by a full interval's wait)
+      const rest = Math.max(1, interval - Math.floor((Date.now() - began) / 1000));
+      for (let waited = 0; waited < rest && !stopped; waited += 1) await new Promise((done) => setTimeout(done, 1000));
     }
   } finally {
     lock.release();