@volter/supercode-orchestrator 0.4.131 → 0.4.133

package/board/ci.mjs

@@ -1,6 +1,9 @@
 // Deployment evidence is observed before a board mutation. No network or Git
 // process runs inside the optimistic transaction that decides completion.
 import { spawnSync } from 'node:child_process';
+import { readFileSync, realpathSync, writeFileSync, renameSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { createHash } from 'node:crypto';
 
 const observations = new Map();
 const key = (board, id) => `${board.root}\0${board.slug}\0${id}`;
@@ -40,6 +43,16 @@ export function observeCompletionEvidence(board, id, entry, payload = {}) {
     const repo = /(?:github\.com[:/])([^/]+\/[^/]+?)(?:\.git)?$/.exec(remote)?.[1];
     if (!repo) throw new Error('Deployment evidence requires this workspace\'s GitHub origin.');
     Object.assign(state, { commit, repository: repo });
+    if (entry.params.completion_ci.keeper_repositories?.includes(repo)) {
+      const receiptPath = join(board.root, 'runtime-deployment.json');
+      const receipt = JSON.parse(readFileSync(receiptPath, 'utf8'));
+      if (receipt.repository !== repo || receipt.completed_at < Number(run('git', ['show', '-s', '--format=%ct', commit], path)) * 1000) throw new Error('No keeper tick after this runtime commit.');
+      run('git', ['merge-base', '--is-ancestor', commit, receipt.head], receipt.checkout);
+      const current = workflowRevision(board.root);
+      if (!current || current.head !== receipt.head || current.workflow_hash !== receipt.workflow_hash) throw new Error('The retained keeper tick does not describe the live checkout and loaded workflow revision.');
+      Object.assign(state, { ready: true, workflow: 'launchd keeper', run_id: `${receipt.pid}@${receipt.completed_at}`, status: 'completed', conclusion: 'success', deployed_sha: receipt.head, url: receiptPath });
+      return state;
+    }
     const configured = entry.params.completion_ci.workflows?.[repo] ?? entry.params.completion_ci.workflows?.['*'];
     if (!Array.isArray(configured) || !configured.length) throw new Error(`No deployment workflow is declared for ${repo} in completion_ci.workflows.`);
     const matchedRules = (entry.params.completion_ci.path_workflows?.[repo] ?? []).filter(rule =>
@@ -58,8 +71,37 @@ export function observeCompletionEvidence(board, id, entry, payload = {}) {
     if (receipt.headSha !== commit) throw new Error(`CI run ${receipt.databaseId} is for ${receipt.headSha}, not ${commit}.`);
     if (!deploymentWorkflows.includes(receipt.workflowName)) throw new Error(`${receipt.workflowName} is not a declared deployment workflow for ${repo}.`);
     if (receipt.status !== 'completed' || receipt.conclusion !== 'success') throw new Error(`Deployment CI ${receipt.databaseId} is ${receipt.status}/${receipt.conclusion || 'pending'}.`);
+    state.deployed_sha = commit;
     state.ready = true;
     state.reason = null;
   } catch (error) { state.reason = error.message; }
   return state;
 }
+
+const digest = bytes => createHash('sha256').update(bytes).digest('hex');
+/** Read the tracked workflow revision the next serve tick will load. */
+export function workflowRevision(root) {
+  try {
+    const workflow = realpathSync(join(root, 'workflow.yaml'));
+    const checkout = run('git', ['rev-parse', '--show-toplevel'], dirname(workflow));
+    const head = run('git', ['rev-parse', 'HEAD'], checkout);
+    const repository = /(?:github\.com[:/])([^/]+\/[^/]+?)(?:\.git)?$/.exec(run('git', ['remote', 'get-url', 'origin'], checkout))?.[1];
+    const name = relative(checkout, workflow).replaceAll('\\', '/');
+    const source = readFileSync(workflow, 'utf8').trimEnd();
+    if (run('git', ['show', `${head}:${name}`], checkout) !== source) return null;
+    // Prompts are loaded with the workflow and must belong to the same revision.
+    run('git', ['diff', '--quiet', 'HEAD', '--', name, join(dirname(name), 'prompts')], checkout);
+    return { checkout, repository, head, workflow_hash: digest(source), started_at: Date.now(), pid: process.pid };
+  } catch { return null; }
+}
+
+/** Only the retained serve loop calls this after a successful tick. */
+export function retainWorkflowTick(root, before) {
+  if (!before) return null;
+  const after = workflowRevision(root);
+  if (!after || after.head !== before.head || after.workflow_hash !== before.workflow_hash) return null;
+  const receipt = { ...before, completed_at: Date.now() };
+  const path = join(root, 'runtime-deployment.json'), temporary = `${path}.${process.pid}.tmp`;
+  writeFileSync(temporary, JSON.stringify(receipt) + '\n', { mode: 0o600 }); renameSync(temporary, path);
+  return receipt;
+}

package/board/cli.mjs

@@ -1199,14 +1199,16 @@ async function serve(root, args = {}) {
         const state = await laneState(root);
         const settings = { ...state.settings, ...override };
         interval = settings.interval;
-        for (const r of await tick({ root, lanes: state.lanes, settings, params })) {
+        for (const r of await tick({ root, lanes: state.lanes, settings, params, deploymentReceipt: true })) {
           const said = summary(r);
+          if (r.deployment) log(`runtime deployed ${r.deployment.repository}@${r.deployment.head}; workflow ${r.deployment.workflow_hash}; tick ${r.deployment.completed_at}`);
           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; }
           // Event bursts do not shorten the six-sweep stuck warning.
           stuck[r.board] = r.ready_waiting && !r.started.length && !r.paused ? (stuck[r.board] || Date.now()) : 0;
           if (stuck[r.board] && Date.now() - stuck[r.board] >= interval * 6000 && Date.now() - (warned[r.board] ?? 0) >= 300_000) { log(`board ${r.board} stuck: ${r.ready_waiting} ready card(s) and nothing started for ${Math.floor((Date.now() - stuck[r.board]) / 1000)}s; \`supercode workflow diagnostics\``); warned[r.board] = Date.now(); }
+          for (const [t, why] of r.queued) log(`  ${t} waits: ${why}`);
           for (const [t, why] of r.failed) log(`  ${t} did not start: ${why}`);
           for (const [t, why] of r.unsettled ?? []) log(`  ${t} could not be read: ${why}`);
           for (const [t, s, m] of r.started) log(`  ${t} started ${s} (${m})`);

package/board/dispatch.mjs

@@ -15,6 +15,7 @@
 // Every side effect follows a committed transition: a card is claimed before its session is launched, and a
 // subscriber's cursor moves only after its notice was delivered, so two dispatchers over one board never both
 // launch and a crash between the two steps is answered by the next tick.
+import { workflowRevision, retainWorkflowTick } from './ci.mjs';
 import { createRequire } from 'node:module';
 import { spawn as spawnChild, spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
@@ -1683,8 +1684,9 @@ export async function plan({ root, lanes, settings, slugs = null, params = {} })
  * `only` limits starting to one card (a create that answers whether its card started). Each board is ticked under its
  * version-checked card claims; no dispatcher file lock. Answers one report per board.
  */
-export async function tick({ root, lanes, settings, only = null, slugs = null, dispatch = true, params = {} }) {
+export async function tick({ root, lanes, settings, only = null, slugs = null, dispatch = true, params = {}, deploymentReceipt = false }) {
   // a verb's flags (dispatch --max, --failure-limit) are params of this tick, read by the workflow as its own
+  const deployment = deploymentReceipt ? workflowRevision(root) : null;
   const loaded = await loadWorkflow(root, { fresh: true });
   const entry = { ...loaded, params: { ...loaded.params, ...params } };
   const needFleet = Object.values(lanes).some((l) => l.surface === 'pane');
@@ -1749,5 +1751,9 @@ export async function tick({ root, lanes, settings, only = null, slugs = null, d
     }
     out.push(report);
   }
+  if (deployment && out.every(report => !report.error)) {
+    const receipt = retainWorkflowTick(root, deployment);
+    if (receipt && out[0]) out[0].deployment = receipt;
+  }
   return out;
 }

package/board/workflow.mjs

@@ -399,7 +399,7 @@ export function eventTo(db, board, entry, id, status, { roles = [], payload = {}
     if (!taken?.target || String(templateValue(taken.target, scope) ?? '') !== status) continue;
     const failed = (taken.validate ?? []).find((v) => !holds(v.expr, scope));
     if (!failed) return { name };
-    refusal ??= failed.message;
+    refusal ??= render(failed.message, scope);
   }
   return { name: null, refusal };
 }

package/package.json

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