@volter/supercode-orchestrator 0.5.205 → 0.5.207

package/board/client.mjs

@@ -7,6 +7,7 @@ import { mkdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homeOf, parse } from './args.mjs';
 import { processSession } from './caller-session.mjs';
+import { noteCommandError, noteStep } from '@volter/supercode-harness-sdk/slow-log';
 
 /**
  * `supercode workflow <verb>`: the CLI holds nothing. A card verb is sent to the home's board owner (`workflow serve`,
@@ -38,6 +39,7 @@ export async function runWorkflow(argv) {
     if (writes) {
       try { lock = await takeHome(root); }
       catch (error) {
+        noteCommandError(error, { phase: 'board ownership' });
         process.stderr.write(`supercode workflow: ${verb} writes the boards of ${root}, which have a running owner (${error.message}); stop \`supercode workflow serve\` to run it\n`);
         return 1;
       }
@@ -68,7 +70,10 @@ async function takeHome(root) {
 }
 
 async function sendToOwner(root, argv, args) {
+  const began = performance.now();
   const sid = processSession();
+  noteStep('board caller session', performance.now() - began);
+  const preparing = performance.now();
   const harness = sid ? (sid === process.env.CODEX_THREAD_ID ? 'codex' : 'claude-code') : null;
   // a file named `-` is the caller's standard input, read here and sent with the verb
   const stdin = [args.file, args['body-file']].includes('-') ? readFileSync(0, 'utf8') : null;
@@ -76,9 +81,20 @@ async function sendToOwner(root, argv, args) {
   // board it names, else the one its environment names) and its Teams context (named, else the one selected here).
   const board = args.board ?? process.env.HERMES_KANBAN_BOARD ?? null;
   const facts = { ...callerFacts(), SUPERCODE_CONTEXT: process.env.SUPERCODE_CONTEXT || new WorkspaceContexts(supercodeHome()).read().current || 'local' };
-  const answer = await askBoardOwner(root, { argv: withoutHome(argv), board, caller: null, session: sid ? { id: sid, harness } : null, facts, cwd: process.cwd(), stdin });
+  noteStep('board request preparation', performance.now() - preparing);
+  const asking = performance.now();
+  let answer;
+  try {
+    answer = await askBoardOwner(root, { argv: withoutHome(argv), board, caller: null, session: sid ? { id: sid, harness } : null, facts, cwd: process.cwd(), stdin });
+  } finally { noteStep('board owner answer', performance.now() - asking); }
   // the owner took the verb and the call ended with no answer: its outcome is unknown, never a plain failure
-  if (answer.unanswered === true) { process.stderr.write(`supercode workflow: ${unansweredText(answer, `\`${withoutHome(argv).join(' ')}\``)}`); return 1; }
+  if (answer.unanswered === true) {
+    const cause = unansweredText(answer, 'the workflow request');
+    noteCommandError({ code: 'owner_unanswered', exitCode: 1 }, { phase: 'board owner answer' });
+    process.stderr.write(`supercode workflow: ${cause}`);
+    return 1;
+  }
+  if (answer.code !== 0) noteCommandError({ code: 'owner_rejected', exitCode: answer.code }, { phase: 'board owner answer' });
   if (answer.stdout) process.stdout.write(answer.stdout);
   if (answer.stderr) process.stderr.write(answer.stderr);
   return answer.code ?? 1;

package/board/custody.mjs

@@ -0,0 +1,109 @@
+// Native identity survives a handback. Custody decides what this board may do with it.
+import { randomUUID } from 'node:crypto';
+import { hostname } from 'node:os';
+import { actorOf, claimer, event, json, now, tx } from './store.mjs';
+
+export const sessionAddress = s => s?.address ?? (s?.machine && s?.harness && s?.session_id ? `sc:${s.machine}:${s.harness}:${s.session_id}` : null);
+export const detachedCard = (db, id) => json(db.prepare('SELECT detached FROM supercode_cards WHERE task_id=?').get(id)?.detached, null);
+export const personCustody = (db, address) => address ? db.prepare('SELECT * FROM supercode_session_custody WHERE address=?').get(address) ?? null : null;
+export const detachedSession = (db, session) => Boolean(session?.detached_at || personCustody(db, sessionAddress(session)));
+
+// No timer releases an operation that may still be inside a native door. Only its
+// finally, or positive absence of its process on this host, releases the reservation.
+function operationAlive(row) {
+  const at = row.owner.lastIndexOf(':');
+  if (row.owner.slice(0, at) !== hostname()) return true;
+  const pid = Number(row.owner.slice(at + 1));
+  if (!Number.isInteger(pid) || pid <= 0) return true;
+  try { process.kill(pid, 0); return true; }
+  catch (error) { return error.code !== 'ESRCH'; }
+}
+
+export function assertNoSessionOperation(db, id, address) {
+  for (const row of db.prepare('SELECT * FROM supercode_session_operations WHERE card_ref=? OR address=?').all(id, address)) {
+    if (operationAlive(row)) throw new Error(`cannot detach while ${row.kind} is in progress (${row.owner}); wait for that native operation to finish`);
+    db.prepare('DELETE FROM supercode_session_operations WHERE token=?').run(row.token);
+  }
+}
+
+/** Reserve ownership before an await. Detach and a native mutation cannot both win. */
+export async function sessionOperation(board, { taskId = null, address = null, kind }, perform) {
+  const token = randomUUID();
+  tx(board, db => {
+    const custody = personCustody(db, address);
+    if ((taskId && detachedCard(db, taskId)) || custody) throw Object.assign(new Error(`session belongs to ${custody?.person ?? 'a person'}; verified adoption is required before ${kind}`), { sessionDetached: true });
+    db.prepare('INSERT INTO supercode_session_operations(token,card_ref,address,kind,owner,started_at) VALUES(?,?,?,?,?,?)').run(token, taskId, address, kind, claimer(), now());
+  });
+  try { return await perform(); }
+  finally { tx(board, db => db.prepare('DELETE FROM supercode_session_operations WHERE token=?').run(token)); }
+}
+
+/** Give the card's one held native session to a person, without stopping it. */
+export function detachSession(board, id, person) {
+  if (!/^person:\S+$/.test(String(person ?? ''))) throw new Error('detach requires --to person:<id>, or a signed-in person caller');
+  return tx(board, db => {
+    const task = db.prepare('SELECT * FROM tasks WHERE id=?').get(id);
+    if (!task) throw new Error(`no card ${id}`);
+    const prior = detachedCard(db, id);
+    if (prior) {
+      if (prior.person !== person) throw new Error(`${id} already belongs to ${prior.person}; adopt it before another handback`);
+      return prior;
+    }
+    const rows = db.prepare('SELECT * FROM task_runs WHERE task_id=? ORDER BY id DESC').all(id);
+    const latest = new Map();
+    for (const row of rows) {
+      const session = json(row.metadata, {})?.supercode;
+      if (session?.launch_pending && !session.close_confirmed_at && !session.close_transferred_to) throw new Error('an unresolved launch remains on this card; settle its receipt before detaching');
+      if (!session || latest.has(session.slot ?? 'worker')) continue;
+      latest.set(session.slot ?? 'worker', { row, session });
+    }
+    const held = [...latest.values()].filter(({ session: s }) => sessionAddress(s) && !s.forgotten && !s.close_transferred_to && !(s.close_confirmed_at && !s.released) && !detachedSession(db, s));
+    const chosen = held.find(({ row }) => row.id === task.current_run_id) ?? held[0];
+    if (!chosen) throw new Error(`${id} has no bound native session to detach`);
+    const { row, session } = chosen, address = sessionAddress(session);
+    if (!session.session_id || !session.machine || !session.harness || session.launch_pending) throw new Error('a pending or unidentified launch cannot be detached');
+    if (task.current_run_id && task.current_run_id !== row.id) throw new Error('the current run has no bound native session; wait for its launch to settle');
+    if (held.some(item => sessionAddress(item.session) !== address)) throw new Error(`${id} holds other session slots; close those through the board before detaching its remaining session`);
+    if (rows.some(reference => {
+      const s = json(reference.metadata, {})?.supercode;
+      return sessionAddress(s) && sessionAddress(s) !== address && s.close_requested && !s.close_confirmed_at && !s.close_transferred_to && !s.detached_at;
+    })) throw new Error('another native session on this card has an unresolved close; settle that receipt before detaching');
+    assertNoSessionOperation(db, id, address);
+    const adoption = db.prepare("SELECT id,kind,payload FROM task_events WHERE task_id=? AND kind IN ('dispatch_held','dispatch_released','session_adopted','adoption_failed','adoption_claimed') ORDER BY id DESC LIMIT 1").get(id);
+    const request = json(adoption?.payload, {});
+    if (adoption?.kind === 'adoption_claimed' && request.lock && operationAlive({ owner: request.lock })) throw new Error('an adoption is already being bound; wait for its answer before detaching');
+    for (const other of db.prepare('SELECT r.id,r.task_id,r.metadata FROM task_runs r JOIN tasks t ON t.current_run_id=r.id WHERE t.id<>?').all(id)) {
+      if (sessionAddress(json(other.metadata, {})?.supercode) === address) throw new Error(`${address} also belongs to ${other.task_id} run ${other.id}; its custody must be resolved first`);
+    }
+    const detached = { person, at: now(), by: actorOf(), run: row.id, session: { address, session_id: session.session_id, machine: session.machine, harness: session.harness, pane: session.pane ?? null }, slot: session.slot ?? 'worker' };
+    // Every historical reference on this board loses custody, including old
+    // unended rows; those cannot veto a later, verified adoption's close.
+    const references = db.prepare(`SELECT id,metadata FROM task_runs
+      WHERE json_extract(metadata,'$.supercode.address')=? OR
+      (json_extract(metadata,'$.supercode.machine')=? AND json_extract(metadata,'$.supercode.harness')=? AND json_extract(metadata,'$.supercode.session_id')=?)`)
+      .all(address, session.machine, session.harness, session.session_id);
+    for (const reference of references) {
+      const metadata = json(reference.metadata, {}), s = metadata.supercode;
+      if (sessionAddress(s) !== address) continue;
+      if (s.close_claim?.lock && Number(s.close_claim.expires) > now()) throw new Error(`a close of ${address} is claimed; wait for its closer to finish`);
+      metadata.supercode = { ...s, detached_at: detached.at, detached_to: person, resumable: false, lifecycle_notice_pending: null };
+      db.prepare("UPDATE task_runs SET metadata=?,ended_at=COALESCE(ended_at,?),status=CASE WHEN ended_at IS NULL THEN 'detached' ELSE status END,outcome=CASE WHEN ended_at IS NULL THEN 'detached' ELSE outcome END,claim_lock=NULL,claim_expires=NULL,worker_pid=NULL WHERE id=?").run(JSON.stringify(metadata), detached.at, reference.id);
+    }
+    db.prepare('INSERT INTO supercode_cards(task_id,detached) VALUES(?,?) ON CONFLICT(task_id) DO UPDATE SET detached=excluded.detached').run(id, JSON.stringify(detached));
+    db.prepare('INSERT INTO supercode_session_custody(address,task_id,person,detached_at,detached_by,run_id) VALUES(?,?,?,?,?,?)').run(address, id, person, detached.at, detached.by, row.id);
+    db.prepare('UPDATE tasks SET current_run_id=NULL,session_id=NULL,claim_lock=NULL,claim_expires=NULL,worker_pid=NULL WHERE id=?').run(id);
+    // No automatic subscription on this board may keep waking the person's session.
+    db.prepare("DELETE FROM kanban_notify_subs WHERE platform='supercode' AND chat_id=?").run(address);
+    if ((adoption?.kind === 'dispatch_held' && request.reason === 'adoption requested') || adoption?.kind === 'adoption_claimed') event(db, id, 'adoption_failed', { request: request.request ?? adoption.id, session: request.session, reason: 'session detached to a person' });
+    event(db, id, 'session_detached', detached, row.id);
+    return detached;
+  });
+}
+
+/** Called only inside the transaction that binds a verified native adoption. */
+export function takeSessionCustody(db, id, address) {
+  const custody = personCustody(db, address);
+  if (custody && custody.task_id !== id) throw new Error(`${address} was detached from ${custody.task_id}; adopt it there before moving its board ownership`);
+  db.prepare('DELETE FROM supercode_session_custody WHERE address=?').run(address);
+  db.prepare('UPDATE supercode_cards SET detached=NULL WHERE task_id=?').run(id);
+}