@volter/supercode-orchestrator 0.4.34 → 0.4.36

package/board/cli.mjs

@@ -45,6 +45,8 @@ supercode's own:
   move <id> <machine|none>   adopt <id> <session> [--assignee P]   close <id>   serve (= daemon)   list --machine M
   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,
@@ -555,8 +557,8 @@ export async function runWorkflow(argv) {
       const results = [];
       for (const t of targets) {
         if (verb === 'specify' && (args.title !== undefined || args.body !== undefined)) {
-          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 });
+          const moved = 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, status: moved.to });
         } 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: await withBoardAsync((b) => engine.decompose(b, t, children, { author: args.author ?? callerAddress() ?? callerName() })) });
@@ -565,7 +567,7 @@ export async function runWorkflow(argv) {
           results.push({ id: t, session: session.address, mode: session.mode });
         }
       }
-      say(args, results.map((r) => (r.specified ? `Specified ${r.id} → todo` : r.children ? `Decomposed ${r.id} into ${r.children.join(', ')}` : `${r.id}: session ${r.session} (${r.mode}) is writing its ${verb === 'specify' ? 'spec' : 'breakdown'}`)).join('\n'), results);
+      say(args, results.map((r) => (r.specified ? `Specified ${r.id} → ${r.status}` : r.children ? `Decomposed ${r.id} into ${r.children.join(', ')}` : `${r.id}: session ${r.session} (${r.mode}) is writing its ${verb === 'specify' ? 'spec' : 'breakdown'}`)).join('\n'), results);
       return 0;
     }
 
@@ -739,6 +741,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));
@@ -746,7 +754,20 @@ export async function runWorkflow(argv) {
       return 0;
     }
 
-    default: throw new Error(`no workflow verb ${verb}; \`supercode workflow help\` lists them`);
+    default: {
+      // any other event the board's workflow declares is a verb of its own: `<event> <id>... [reason] [--<field> value]`,
+      // the flags its payload (the doors a session is told name these)
+      const name = verb.replace(/-/g, '_');
+      const { workflow } = workflowFor(root);
+      const declared = Object.values(workflow.statuses).some((s) => s.on?.[name]) || Boolean(workflow.on?.[name]);
+      if (!declared) throw new Error(`no workflow verb ${verb}; \`supercode workflow help\` lists them`);
+      need(1, 'a card id');
+      const { _: _words, root: _r, board: _b, json: _j, at: _a, ids: _i, ...fields } = args;
+      const payload = { ...fields, reason: args.reason ?? (rest.slice(1).join(' ') || null) };
+      const results = [];
+      for (const t of [id, ...(args.ids ?? [])]) results.push([t, (await withBoardAsync((b) => engine.act(b, t, name, { payload }))).to]);
+      say(args, results.map(([t, s]) => `${t} → ${s}`).join('\n'), { ok: true, results }); return 0;
+    }
   }
 }
 

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

@@ -94,7 +94,9 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {} } = {}
     goal_mode: Boolean(task.goal_mode),
     implementer: asked.implementer ?? task.assignee,
     last_reviewer: changes.reviewer ?? null,
-    arc: task.subtask_of ? one(db, 'SELECT id, status, title FROM tasks WHERE id = ?', task.subtask_of) ?? null : null,
+    arc: task.subtask_of ? one(db, 'SELECT id, status, title, assignee FROM tasks WHERE id = ?', task.subtask_of) ?? null : null,
+    // the cards filed as its subtasks (`create --subtask-of`), in the order they were filed
+    subtasks: all(db, 'SELECT t.id, t.status, t.title, t.assignee FROM tasks t JOIN supercode_cards c ON c.task_id = t.id WHERE c.subtask_of = ? ORDER BY t.created_at', task.id),
     queue_reason: json(one(db, "SELECT payload FROM task_events WHERE task_id = ? AND kind = 'respawn_guarded' AND created_at >= ? ORDER BY id DESC LIMIT 1",
       task.id, Number(one(db, 'SELECT since FROM supercode_cards WHERE task_id = ?', task.id)?.since ?? 0))?.payload, {})?.reason ?? null,
     last_block_event: one(db, "SELECT kind FROM task_events WHERE task_id = ? AND kind IN ('blocked', 'unblocked') ORDER BY id DESC LIMIT 1", task.id)?.kind ?? null,
@@ -166,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.34",
+  "version": "0.4.36",
   "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": {