@volter/supercode-orchestrator 0.4.35 → 0.4.37

package/board/cli.mjs

@@ -46,6 +46,7 @@ supercode's own:
   notify-subscribe <id> --address sc:<machine>:<harness>:<id> [--role creator|worker|dependency]
   Any verb … --at sc:<machine>:board:<home>: sent as mail to a board kept on another machine.
   <event> <id>... [reason] [--<field> value]: any other event the board's workflow declares, its flags the event's fields.
+  goto <id> <status> [reason] [--<field> value]: the event the workflow says takes the card to that status, sent.
 
   specify/decompose with no spec start a session on the triage card to write it. A card's own session may comment on,
   block (with --kind), heartbeat and request review of its card, specify or decompose it in triage, and file, complete,
@@ -315,7 +316,21 @@ export async function runWorkflow(argv) {
         updated: (a, b) => (b.completed_at ?? b.started_at ?? b.created_at) - (a.completed_at ?? a.started_at ?? a.created_at),
       };
       if (args.sort) { if (!sorters[args.sort]) throw new Error(`--sort is one of ${Object.keys(sorters).join(', ')}`); cards.sort(sorters[args.sort]); }
-      if (args.json) { say(args, '', cards.map(cardDict)); return 0; }
+      if (args.json) {
+        // beyond Hermes's fields: the workflow's own status, the cards it waits on and its open run, so a reader of the
+        // whole board (a board file's sync) needs no `show` per card
+        const extra = withBoard((b) => new Map(cards.map((t) => {
+          const run = t.current_run_id ? b.db.prepare('SELECT id, status, started_at, metadata FROM task_runs WHERE id = ?').get(t.current_run_id) : null;
+          const session = run ? json(run.metadata, {})?.supercode ?? {} : {};
+          return [t.id, {
+            workflow_status: t.stage ?? t.status,
+            parents: b.db.prepare('SELECT parent_id FROM task_links WHERE child_id = ? ORDER BY parent_id').all(t.id).map((r) => r.parent_id),
+            run: run ? { id: run.id, status: run.status, started_at: run.started_at, session: session.address ?? session.session_id ?? null } : null,
+          }];
+        })));
+        say(args, '', cards.map((t) => ({ ...cardDict(t), ...extra.get(t.id) })));
+        return 0;
+      }
       const others = boardsOf(root, { includeArchived: false }).length - 1;
       if (others > 0) process.stdout.write(`Board: ${slug} (${others} other board${others === 1 ? '' : 's'} — \`supercode workflow boards list\`)\n\n`);
       process.stdout.write(cards.length ? `${cards.map(line).join('\n')}\n` : '(no matching tasks)\n');
@@ -740,6 +755,12 @@ export async function runWorkflow(argv) {
       say(args, `${id} is worked by ${got.address} (pane ${got.pane ?? '?'} in ${got.workspace ?? 'its card\'s directory'})`, { ok: true, ...got });
       return 0;
     }
+    case 'goto': {
+      need(2, 'a card id and the status to take it to');
+      const { _: _words, root: _r, board: _b, json: _j, at: _a, ...fields } = args;
+      const moved = await withBoardAsync((b) => engine.goto(b, id, rest[1], { payload: { ...fields, reason: args.reason ?? (rest.slice(2).join(' ') || null) } }));
+      say(args, moved.event ? `${id} → ${moved.to} (${moved.event.replace(/_/g, '-')})` : `${id} is already ${moved.to}`, { ok: true, ...moved }); return 0;
+    }
     case 'close': {
       need(1, 'a card id');
       const closed = withBoard((b) => closeSession(b, id));

package/board/engine.mjs

@@ -12,7 +12,7 @@ import { existsSync, rmSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { claimer, event, json, newTaskId, now, tx } from './store.mjs';
-import { fire, loadWorkflow, setStatus, settle, startNew, statusOf, workflowFor } from './workflow.mjs';
+import { eventTo, fire, loadWorkflow, setStatus, settle, startNew, statusOf, workflowFor } from './workflow.mjs';
 
 export const STATUSES = ['triage', 'todo', 'scheduled', 'ready', 'running', 'blocked', 'review', 'done', 'archived'];
 export const BLOCK_KINDS = ['dependency', 'needs_input', 'capability', 'transient'];
@@ -334,6 +334,18 @@ export async function act(board, id, name, { roles = null, payload = {}, extra =
   return { from: result.from, to: result.to, moved: result.moved };
 }
 
+/** Take card `id` to `status` by the event the workflow says goes there for this caller (`goto`). */
+export async function goto(board, id, status, { roles = null, payload = {} } = {}) {
+  const entry = await loadWorkflow(board.root);
+  const { name, from } = tx(board, (db) => {
+    roles ??= callerRoles(db, id);
+    return { name: eventTo(db, board, entry, id, status, { roles, payload }), from: statusOf(db, getTask(db, id)) };
+  });
+  if (from === status) return { from, to: status, moved: false, event: null };
+  if (!name) throw new Error(`${id} is ${from}; no event you may send takes it to ${status}`);
+  return { ...(await act(board, id, name, { roles, payload })), event: name };
+}
+
 /** The I/O a committed move asked for. */
 export async function runEffects(board, effects = []) {
   for (const e of effects) {

package/board/workflow.mjs

@@ -168,6 +168,24 @@ export function fire(db, board, entry, id, name, { roles = [], payload = {}, ext
   return { from, to: statusOf(db, cardOf(db, id)), moved: to !== from, effects };
 }
 
+/**
+ * The event that takes card `id` to `status` for a sender in `roles`: the first the card's status (then the workflow)
+ * declares whose transition for that sender, with `payload`, goes there. Null when none does. Its validators are
+ * the event's own, checked when it is sent.
+ */
+export function eventTo(db, board, entry, id, status, { roles = [], payload = {} } = {}) {
+  const { workflow, params } = entry;
+  if (!workflow.statuses[status]) throw new Error(`the board's workflow declares no status ${status}`);
+  const task = cardOf(db, id);
+  const from = statusOf(db, task);
+  const scope = scopeOf(db, board, task, { params, event: payload, extra: { lanes: lanesIn(entry), sender: roles } });
+  for (const name of new Set([...Object.keys(workflow.statuses[from]?.on ?? {}), ...Object.keys(workflow.on ?? {})])) {
+    const taken = transitionsFor(workflow, from, name).filter((t) => !t.by?.length || t.by.some((r) => roles.includes(r))).find((t) => holds(t.guard ?? null, scope));
+    if (taken?.target && String(templateValue(taken.target, scope) ?? '') === status) return name;
+  }
+  return null;
+}
+
 function cardOf(db, id) {
   const row = one(db, 'SELECT * FROM tasks WHERE id = ?', id);
   if (!row) throw new Error(`no card ${id}`);

package/package.json

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