@volter/supercode-orchestrator 0.4.147 → 0.4.149

package/board/workflow.mjs

@@ -11,8 +11,9 @@ import { resolve, relative, isAbsolute } from 'node:path';
 import { randomBytes } from 'node:crypto';
 import { actorOf, appendRunObservation, event as record, json, now } from './store.mjs';
 import { evaluate, holds, render } from './expr.mjs';
-import { completionEvidence } from './ci.mjs';
+import { completionEvidence, reviewCandidate } from './ci.mjs';
 import { isWorkspacePath } from './workspace.mjs';
+import { identifyNotice } from './notices.mjs';
 
 const loaded = new Map();
 
@@ -103,7 +104,8 @@ function pattern(p) {
 }
 
 // the time of the latest commit that names `id` in its message, on any ref of the repository at `path` (a worktree's
-// pushes land on the shared remote-tracking refs), or null (asked only when an expression does)
+// pushes land on the shared remote-tracking refs), or null (asked only when an expression does). Merge commits are
+// not the card's work: merging its reviewed PR, or main into its branch, is not a newer change to review.
 const commitTimes = new Map();
 function observeLastCommit(path, id) {
   if (!path) return null;
@@ -111,7 +113,7 @@ function observeLastCommit(path, id) {
   const cached = commitTimes.get(key);
   if (cached && now() - cached.at < 15) return cached.value;
   const readCommit = (repo) => {
-    const r = spawnSync('git', ['-C', repo, 'log', '--all', '-1', '--format=%ct', '--fixed-strings', `--grep=${id}`], { encoding: 'utf8', timeout: 10_000 });
+    const r = spawnSync('git', ['-C', repo, 'log', '--all', '--no-merges', '-1', '--format=%ct', '--fixed-strings', `--grep=${id}`], { encoding: 'utf8', timeout: 10_000 });
     const value = Number(r.stdout?.trim());
     return { repo: r.status === 0, value: Number.isFinite(value) && value > 0 ? value : null };
   };
@@ -200,11 +202,8 @@ function onlyTicks(was, body) {
 
 /** Seconds a card's runs spent by role, and the rest of its life as `waiting`. */
 export function runWorkingSeconds(row, at = now()) {
-  const metadata = typeof row.metadata === 'string' ? json(row.metadata, {}) : row.metadata;
-  const session = metadata?.supercode ?? {};
   const end = Number(row.ended_at ?? at);
-  const waiting = Number(session.wait_seconds ?? 0) + (session.wait_started_at != null ? Math.max(0, end - Number(session.wait_started_at)) : 0);
-  return Math.max(0, end - Number(row.started_at ?? end) - waiting);
+  return Math.max(0, end - Number(row.started_at ?? end));
 }
 
 function timeOf(db, task) {
@@ -249,8 +248,8 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {} } = {}
     ...task,
     creator_address: creatorOf(db, task.id),
     completion_owner_address: completionOwnerOf(db, task.id),
-    review_only: Boolean(state.review_only),
     latest_review: latestReview(db, task.id) ?? {},
+    review_candidate: reviewCandidate(board, task.id) ?? {},
     ci: completionEvidence(board, task.id),
     dispatch_hold: one(db, "SELECT kind FROM task_events WHERE task_id=? AND kind IN ('dispatch_held','dispatch_released','session_adopted') ORDER BY id DESC LIMIT 1", task.id)?.kind === 'dispatch_held',
     status,
@@ -356,11 +355,20 @@ function queueTransitionNotice(db, board, entry, task, from, name, payload, befo
   const afterState = beforeRun && json(one(db, 'SELECT metadata FROM task_runs WHERE id=?', beforeRun.id)?.metadata, {})?.supercode?.state;
   if (!beforeRun || (state(task, from) === state(after, to) && beforeState === afterState) || effects.some((e) => e.kind === 'session_notice' && e.runId === beforeRun.id)) return;
   const session = json(beforeRun.metadata, {})?.supercode;
+  const cancellation = session?.launch_cancellation;
+  if (cancellation?.key === session?.launch_key && cancellation?.status === 'cancelled' && cancellation?.cancelled === true &&
+      cancellation?.outcome === 'not_issued' && cancellation?.live === false && cancellation?.pane === null) return;
   const address = session?.address ?? (session?.session_id && session.machine ? `sc:${session.machine}:${session.harness ?? 'claude-code'}:${session.session_id}` : null);
   if (!address && !session?.launch_key && !session?.pane) return;
+  // The session that made this change learns it from its own command's answer; a notice about
+  // its own act would only hold its close until the notice is confirmed. A session whose close is
+  // confirmed is not told either: its next run resumes it with the card's state in its prompt.
+  if (address && address === actorOf()) return;
+  if (session?.close_confirmed_at) return;
   const scope = scopeOf(db, board, after, { params: entry.params, event: { ...payload, verb: name, from, to }, extra: { run: { id: beforeRun.id } } });
-  const text = render(entry.workflow.notify?.worker?.run_changed ?? '{{card.id}}: {{event.verb}} changed run {{run.id}} ({{event.from}} → {{event.to}}). Stop work under the previous run; follow the board’s current state. {{event.reason ?? ""}}', scope);
+  const body = render(entry.workflow.notify?.worker?.run_changed ?? '{{card.id}}: {{event.verb}} changed run {{run.id}} ({{event.from}} → {{event.to}}). Stop work under the previous run; follow the board’s current state. {{event.reason ?? ""}}', scope);
   const source = one(db, 'SELECT MAX(id) AS id FROM task_events WHERE task_id = ?', task.id)?.id;
+  const text = identifyNotice({ id: source, kind: name, run_id: beforeRun.id, created_at: now() }, body);
   const effect = { kind: 'session_notice', id: task.id, runId: beforeRun.id, address, text, sourceEvent: source, verb: name, messageKey: `board-run-notice-${randomBytes(16).toString('hex')}` };
   const inserted = run(db, 'INSERT INTO supercode_effects (effect) VALUES (?)', JSON.stringify(effect));
   effects.push({ ...effect, durableId: Number(inserted.lastInsertRowid) });
@@ -385,7 +393,7 @@ export function fire(db, board, entry, id, name, { roles = [], payload = {}, ext
   const candidates = transitionsFor(workflow, from, name);
   if (!candidates.length) throw new Error(`${id} is ${from}; ${name.replace(/_/g, '-')} does not apply there`);
   // `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 scope = scopeOf(db, board, task, { params, event: payload, extra: { lanes: lanesIn(entry), ...extra, sender: roles, verb: name } });
   const allowed = candidates.filter((t) => !t.by?.length || t.by.some((r) => roles.includes(r)));
   if (!allowed.length) {
     const state = name === 'complete' ? 'done' : name === 'cancel' ? 'cancelled' : null;
@@ -555,7 +563,7 @@ const FORMAT = {
   blocked: ({ e, after, source }) => ({ reason: e.reason ?? null, on: e.on ?? null, waiting_on: e.waiting_on ?? null, recurrences: Number(after.block_recurrences || 0), source_status: source }),
   block_loop_detected: ({ e, after, source, params }) => ({ reason: e.reason ?? null, kind: e.kind ?? null, recurrences: Number(after.block_recurrences || 0), limit: params.block_recurrence_limit, source_status: source }),
   dependency_wait: ({ e, source }) => ({ reason: e.reason ?? null, on: e.on ?? null, source_status: source }),
-  review_requested: ({ e, before, after }) => ({ summary: firstLine(e.summary), ci: e.ci ?? null, implementer: before.assignee, reviewer: after.assignee !== before.assignee ? after.assignee : (e.reviewer ?? null) }),
+  review_requested: ({ e, before, after }) => ({ summary: firstLine(e.summary), ci: e.ci ?? null, pr: e.ci?.pr ?? null, commit: e.ci?.commit ?? null, implementer: before.assignee, reviewer: after.assignee !== before.assignee ? after.assignee : (e.reviewer ?? null) }),
   // the reviewer is the lane that reviewed (the card's assignee while in review), unless the verdict names one
   changes_requested: ({ e, before, after }) => ({ reason: e.reason ?? null, reviewer: e.reviewer ?? before.assignee ?? null, implementer: after.assignee }),
   review_reopened: ({ after, to }) => ({ status: to, implementer: after.assignee }),
@@ -636,17 +644,6 @@ const ACTIONS = {
     const result = fire(ctx.db, ctx.board, ctx.entry, ctx.id, name, { roles: [].concat(as), payload, extra: { lanes: lanesIn(ctx.entry) } });
     ctx.effects.push(...result.effects);
   },
-  wait_run(ctx, waiting) {
-    if (typeof waiting !== 'boolean') throw new Error('wait_run requires a boolean');
-    const at = now();
-    runSession(ctx, session => {
-      if (waiting) return { ...session, wait_started_at: session.wait_started_at ?? at };
-      if (session.wait_started_at == null) return session;
-      return { ...session, wait_started_at: null,
-        wait_seconds: Number(session.wait_seconds ?? 0) + Math.max(0, at - Number(session.wait_started_at)),
-        goal_nudged_at: at };
-    });
-  },
   record(ctx, args, scope) {
     const kind = typeof args === 'string' ? args : args?.kind;
     const given = typeof args === 'object' && args?.payload ? args.payload : null;
@@ -766,15 +763,12 @@ const ACTIONS = {
     run(ctx.db, 'DELETE FROM task_links WHERE parent_id = ? AND child_id = ?', parent, ctx.id);
   },
   specify(ctx, said) {
-    if (said?.review_only != null) {
-      const task = cardOf(ctx.db, ctx.id);
-      if (typeof said.review_only !== 'boolean' || task.current_run_id || task.subtask_of || ctx.scope.card.every) throw new Error('A review-only declaration changes only an arc with no current run or recurrence.');
-      cardField(ctx, 'review_only', said.review_only ? 1 : 0);
-      record(ctx.db, ctx.id, 'review_mode_changed', { review_only: said.review_only }, null);
-    }
     if (said?.workspace) {
       const task = cardOf(ctx.db, ctx.id), ws = said.workspace;
       if (task.current_run_id) throw new Error('end the current run before changing its workspace');
+      ACTIONS.forget_session(ctx, '*');
+      const prior = one(ctx.db, 'SELECT workspace_anchor FROM supercode_cards WHERE task_id=?', ctx.id);
+      record(ctx.db, ctx.id, 'workspace_changed', { from: { kind: task.workspace_kind, repository: prior?.workspace_anchor, branch: task.branch_name }, to: { kind: ws.kind, repository: ws.repository, branch: ws.branch } }, null);
       run(ctx.db, 'UPDATE tasks SET workspace_kind=?,workspace_path=?,branch_name=? WHERE id=?', ws.kind, ws.path ?? null, ws.branch ?? null, ctx.id);
       cardField(ctx, 'workspace_anchor', ws.repository ?? null);
       cardField(ctx, 'workspace_root', null);
@@ -854,12 +848,20 @@ const ACTIONS = {
     if (!to) throw new Error(`the workflow asks nobody about ${ctx.id} (ask.to is empty)`);
     const id = `m-${randomBytes(12).toString('hex')}`;
     ctx.scope.asked = id;
-    record(ctx.db, ctx.id, 'board_message', { to: String(to), text: `${String(text ?? '')}\n\nAnswer with reply_to ${id}.`, message_id: id }, null);
+    const batch = ctx.scope.verb === 'request_state' ? {
+      requester: actorOf() ?? ctx.scope.requester,
+      window_seconds: Math.max(1, Math.min(60, Number(ctx.entry.params.request_batch_seconds) || 10)),
+    } : null;
+    const observation = ctx.scope.event?.ci;
+    if (batch && observation?.required && !observation.ready) text = `${String(text ?? '')}\nSource evidence could not be verified: ${observation.reason ?? 'unavailable'}. The decision request is retained.`;
+    record(ctx.db, ctx.id, 'board_message', { to: String(to), text: batch ? String(text ?? '') : `${String(text ?? '')}\n\nAnswer with reply_to ${id}.`, message_id: id, ...(batch ? { batch } : {}) }, null);
     ctx.effects.push({ kind: 'board_message', id: ctx.id });
   },
   send_to_actor(ctx, text) {
     const effect = { kind: 'send_to_actor', id: ctx.id, runId: ctx.runId, text, messageKey: `board-actor-${randomBytes(16).toString('hex')}` };
     const inserted = run(ctx.db, 'INSERT INTO supercode_effects (effect) VALUES (?)', JSON.stringify(effect));
+    effect.text = identifyNotice({ id: `notice-${inserted.lastInsertRowid}`, kind: 'actor_notice', run_id: ctx.runId, created_at: now() }, text);
+    run(ctx.db, 'UPDATE supercode_effects SET effect=? WHERE id=?', JSON.stringify(effect), Number(inserted.lastInsertRowid));
     ctx.effects.push({ ...effect, durableId: Number(inserted.lastInsertRowid) });
   },
 };
@@ -1026,13 +1028,19 @@ function settleRelations(db, board, entry, id, effects) {
 }
 
 
-export function projectStatus(db, board, entry, id) {
-  if (!entry.workflow.stored_as?.length) return;
+/** A card's workflow status and the status Hermes's `tasks.status` stores it as, read without writing. */
+export function storedStatus(db, board, entry, id) {
   const task = cardOf(db, id);
   const status = statusOf(db, task);
+  if (!entry.workflow.stored_as?.length) return { status, stored: task.status };
   const scope = scopeOf(db, board, task, { params: entry.params });
   const rule = entry.workflow.stored_as.find((r) => holds(r.guard, scope));
-  const stored = rule?.status ?? storedAs(entry.workflow, status);
+  return { status, stored: rule?.status ?? storedAs(entry.workflow, status) };
+}
+
+export function projectStatus(db, board, entry, id) {
+  if (!entry.workflow.stored_as?.length) return;
+  const { status, stored } = storedStatus(db, board, entry, id);
   run(db, 'UPDATE tasks SET status = ? WHERE id = ?', stored, id);
   run(db, 'INSERT INTO supercode_cards (task_id, stage) VALUES (?, ?) ON CONFLICT(task_id) DO UPDATE SET stage = excluded.stage', id, status);
 }

package/board/workspace.mjs

@@ -1,5 +1,7 @@
 // Filesystem/RPC work happens before a board transaction; the ownership check is pure.
 import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { basename, dirname } from 'node:path';
 import { Workspaces, inspectCheckout, repositoryId, teamsHome } from '@volter/supercode-teams/workspaces';
 import { localMachine, normalMachine, supercodeBin, commandEnv } from './dispatch.mjs';
 export const isWorkspacePath = value => /^(\/|~|[A-Za-z]:[\\/])/.test(value ?? '');
@@ -28,6 +30,17 @@ export function declareWorkspace(kind, value, machine, branch = null) {
   const row = workspaceDoor(machine, 'register', value);
   return { repository: row.repository, branch: branch ?? (kind === 'dir' ? row.branch : null), path: kind === 'dir' ? row.path : null };
 }
+/** The checkouts this machine keeps of any repository on `branch`: where an arc changing several repositories
+ *  keeps its work in each of them (its own worktree aside). Another machine's map is not read from here. */
+export function branchCheckouts(machine, branch) {
+  if (!branch || (machine && normalMachine(machine) !== localMachine())) return [];
+  return new Workspaces(teamsHome()).list().filter((row) => (branch === '*' || row.branch === branch) && existsSync(row.path));
+}
+/** The registered checkout of `repository` on `branch` on `machine`: where a card changing several repositories
+ *  keeps its work in each of them. */
+export function checkoutOf(machine, repository, branch) {
+  return workspaceDoor(machine, 'resolve', repositoryId(repository), { branch });
+}
 export function resolveWorkspace(task, create = false) {
   const declared = task.workspace_anchor ?? task.workspace_path;
   if (isWorkspacePath(declared)) {
@@ -36,6 +49,19 @@ export function resolveWorkspace(task, create = false) {
     if (info.linked) throw new Error('worktree declaration is already a linked worktree; name its repository instead');
     throw new Error('legacy worktree path needs registration and a repository declaration before launch');
   }
+  // A primary checkout can change when another clone is registered. That does
+  // not move an already allocated card worktree. Machine moves and workspace
+  // retargets clear this runtime receipt; never borrow an arbitrary checkout.
+  if (task.workspace_kind === 'worktree' && task.workspace_path &&
+      basename(task.workspace_path) === task.id && basename(dirname(task.workspace_path)) === '.worktrees' &&
+      (!isLocalWorkspace(task) || existsSync(task.workspace_path))) {
+    const cached = workspaceDoor(task.machine, 'inspect', task.workspace_path);
+    if (cached.linked && basename(cached.path) === task.id && basename(dirname(cached.path)) === '.worktrees' &&
+        cached.repository === repositoryId(declared) && cached.branch === (task.branch_name ?? `wt/${task.id}`)) {
+      return { ...cached, root: dirname(dirname(cached.path)) };
+    }
+    throw new Error(`card worktree ${task.workspace_path} does not match ${declared}, branch ${task.branch_name ?? `wt/${task.id}`}; retarget its workspace explicitly`);
+  }
   return workspaceDoor(task.machine, 'resolve', declared, { branch: task.branch_name, solo: task.workspace_kind === 'worktree', card: task.id, create });
 }
 export function checkWorkspace(board, task) {