@volter/supercode-orchestrator 0.4.70 → 0.4.72

package/board/cli.mjs

@@ -13,7 +13,7 @@ import { holdDispatcherLock } from '../hermes-locks.mjs';
 import { backingOf, boardExists, boardPath, DEFAULT_BOARD, event, json, listBoards, logsDir, now, openBoard, setActor, tx } from './store.mjs';
 import * as engine from './engine.mjs';
 import { adoptSession, boardAddress, boardLabel, boardSettings, callerSession, lanesOf, localMachine, observeFleet, paused, plan, startCard, tick } from './dispatch.mjs';
-import { loadWorkflow, statusOf, useWorkflow, workflowEntry, workflowFor } from './workflow.mjs';
+import { loadWorkflow, scopeOf, statusOf, useWorkflow, workflowEntry, workflowFor } from './workflow.mjs';
 import { evaluate } from './expr.mjs';
 
 const HELP = `supercode workflow <verb> [--root <home>] [--board <slug>] [--json]
@@ -356,16 +356,20 @@ export async function runWorkflow(argv) {
         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.stage = statusOf(b.db, got.task);
+        got.time = scopeOf(b.db, b, got.task, { params: workflowFor(root).params }).card.time;
         return got;
       });
       const t = card.task;
       const latest = [...card.runs].reverse().find((r) => r.summary)?.summary ?? null;
       if (args.json) {
-        say(args, '', { task: cardDict(t), latest_summary: latest, parents: card.parents.map((p) => p.id), children: card.children, subtasks: card.subtasks, comments: card.comments, events: card.events, runs: card.runs, subscriptions: card.subscriptions, diagnostics: card.diagnostics });
+        say(args, '', { task: cardDict(t), latest_summary: latest, parents: card.parents.map((p) => p.id), children: card.children, subtasks: card.subtasks, comments: card.comments, events: card.events, runs: card.runs, time: card.time, subscriptions: card.subscriptions, diagnostics: card.diagnostics });
         return 0;
       }
       const out = [`Task ${t.id}: ${t.title}`, `  status:    ${card.stage}${card.stage !== t.status ? ` (${t.status} in kanban.db)` : ''}`, `  assignee:  ${t.assignee || '-'}`];
       if (t.machine) out.push(`  machine:   ${t.machine}`);
+      // where the card's time went: each role's runs, and the rest waiting
+      const mins = (sec) => `${Math.round(sec / 60)}m`;
+      out.push(`  time:      ${Object.entries(card.time).filter(([, v]) => v > 0).map(([k, v]) => `${k} ${mins(v)}`).join(', ') || '-'}`);
       if (t.subtask_of) out.push(`  subtask of: ${t.subtask_of}`);
       if (t.tenant) out.push(`  tenant:    ${t.tenant}`);
       out.push(`  workspace: ${t.workspace_kind}${t.workspace_path ? ` @ ${t.workspace_path}` : ''}`);

package/board/workflow.mjs

@@ -108,6 +108,22 @@ function onlyTicks(was, body) {
   });
 }
 
+/** Seconds a card's runs spent by role, and the rest of its life as `waiting`. */
+function timeOf(db, task) {
+  const t = now();
+  const out = { coding: 0, reviewing: 0, auditing: 0, triaging: 0 };
+  const key = { implementer: 'coding', reviewer: 'reviewing', auditor: 'auditing', triager: 'triaging' };
+  for (const r of all(db, 'SELECT started_at, ended_at, metadata FROM task_runs WHERE task_id = ?', task.id)) {
+    const role = json(r.metadata, {})?.supercode?.role ?? 'implementer';
+    const spent = Math.max(0, Number(r.ended_at ?? t) - Number(r.started_at ?? t));
+    const k = key[role] ?? role;
+    out[k] = (out[k] ?? 0) + spent;
+  }
+  const worked = Object.values(out).reduce((a, b) => a + b, 0);
+  out.waiting = Math.max(0, t - Number(task.created_at ?? t) - worked);
+  return out;
+}
+
 /** The session message `id` was filed for (`supercode message show`): who was asked; or null. */
 function askedOf(id) {
   if (!id) return null;
@@ -155,6 +171,9 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {} } = {}
     // the message whose answer the standing block waits for (`block --waiting-on`), and that answer's id once it has landed
     waiting_on: waitingOn,
     answer: () => answerTo(waitingOn),
+    // the seconds its runs spent, by the role each run was for (implementer: coding, reviewer: reviewing, …), an open
+    // run counted to now; `waiting` is the rest of its life since it was filed
+    time: timeOf(db, task),
     // whether an edit of its text only ticks outcome lines (the card's own session's door to its acceptance)
     only_ticks: (body) => onlyTicks(task.body, body),
     asked_of: () => askedOf(waitingOn),
@@ -534,6 +553,15 @@ const ACTIONS = {
       return;
     }
   },
+  // an event sent to other cards (`to`: an expression naming their ids, e.g. a card's open subtasks), as `as` sends it;
+  // a card it does not apply to now is passed over
+  send(ctx, { event: name, to, as = 'manager', payload = {} }, scope) {
+    const ids = [].concat(evaluate(String(to), scope) ?? []).map(String).filter((other) => other && other !== ctx.id);
+    for (const other of ids) {
+      try { ctx.effects.push(...(fire(ctx.db, ctx.board, ctx.entry, other, name, { roles: [as], payload }).effects ?? [])); }
+      catch (error) { if (!error.noTransition && !error.refusal && !/does not apply|there is for/.test(error.message)) throw error; }
+    }
+  },
   // a message from the board to a session (`to`: its address), kept on the card as a board_message event until the
   // dispatcher has sent it: a move settled by any verb (a list settles too) is never lost with its effects
   tell(ctx, { to, text }) { if (to) record(ctx.db, ctx.id, 'board_message', { to: String(to), text: String(text ?? '') }, null); },

package/package.json

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