@volter/supercode-orchestrator 0.5.228 → 0.5.230

package/board/workspace.mjs

@@ -1,10 +1,10 @@
 // Filesystem/RPC work happens before a board transaction; the ownership check is pure.
 import { existsSync, realpathSync } from 'node:fs';
-import { basename, dirname } from 'node:path';
+import { basename, dirname, posix, win32 } from 'node:path';
 import { runtimeDoor } from './runtime-door.mjs';
 import { inspectCheckout } from '@volter/teams/checkout';
 import { localMachine, normalMachine, commandEnv } from './dispatch.mjs';
-import { cardHandleOf } from './store.mjs';
+import { cardHandleOf, json, REVIEW_ALLOCATION_KEY, REVIEW_ALLOCATION_MACHINE, REVIEW_ALLOCATION_PATH } from './store.mjs';
 
 // Repository identities are portable input values; the daemon owns their checkout resolution.
 function repositoryId(value) {
@@ -63,6 +63,35 @@ export async function cardCommitsOn(machine, path, card, branches = [], ref = nu
   if (!answer || typeof answer !== 'object' || !('at' in answer) || (answer.at !== null && !(Number(answer.at) > 0))) throw new Error(`machine ${name} answered no commit reading`);
   return { at: answer.at === null ? null : Number(answer.at) };
 }
+/** Card worktree folder `path` on `machine` as its machine reads it now: its folder as that machine resolves it (its
+ *  links followed), or null when the folder is not there (this machine's own file reading; another's inspect door, whose
+ *  git says the folder is gone). Throws when it could not be read. */
+export async function worktreePresent(machine, path) {
+  if (!machine || normalMachine(machine) === localMachine()) {
+    if (!existsSync(path)) return null;
+    try { return realpathSync(path); } catch { return path; }
+  }
+  try { const facts = await workspaceDoor(machine, 'inspect', path); return facts?.path ?? facts?.root ?? path; }
+  catch (error) { if (folderGone(error)) return null; throw error; }
+}
+/** Card worktree `path` on `machine` at its card's close (teams workspaces.mjs retireCardWorktree): removed through git
+ *  when it is on the card's `branch`, its branch merged and its tree clean, else kept and described. Every machine's
+ *  folder, this one's included, is read and retired by that machine's daemon through its door, which also forgets a
+ *  removed checkout in its workspace map: the board reaches the machine layer only through its doors. A machine that
+ *  cannot answer throws, so the board asks again. */
+export async function retireWorktree(machine, path, { merged = [], branch = null } = {}) {
+  const local = !machine || normalMachine(machine) === localMachine();
+  const name = local ? localMachine() : normalMachine(machine);
+  if (!local && presence?.known === true && presence.offline?.has(name)) throw new Error(`worktree ${path} on ${machine}: machine ${name} is offline`);
+  // its two network reads (origin's default branch, its fetch) are each bounded at 30 s there
+  const r = await runtimeDoor(local ? null : machine, 'harness.v1.workspaces.retire', { path, merged, branch }, { timeout: 120_000, env: commandEnv() });
+  if (r.code !== 0) {
+    let refusal = null; try { refusal = JSON.parse(String(r.stderr).trim().split('\n').pop()); } catch { /* said in its own words */ }
+    if (refusal?.code === -32601 || /unknown method/.test(refusal?.message ?? '')) throw new Error(`machine ${name}'s daemon has no worktree retiring door (harness.v1.workspaces.retire); its card worktree ${path} is retired once that machine runs a supercode that has it`);
+    throw new Error(`worktree ${path} on ${machine}: ${String(refusal?.message ?? (r.stderr || r.stdout || 'its door did not answer')).trim().slice(0, 300)}`);
+  }
+  return JSON.parse(r.stdout);
+}
 /** A workspace declaration that asks no machine (scratch, or a repository named by id), else null: a path is declared
  *  through its machine's door (declareWorkspace). */
 export function plainWorkspace(kind, value, branch = null) {
@@ -140,7 +169,12 @@ export function unrecordedMaking(db, id) {
 }
 /** Card `task` as its workspace is resolved: its handle, the branch the board last named for it and, when `claims`, its
  *  claim on that branch (branchClaim). */
+const workspaceTags = (board, task) => {
+  const raw = task.tags ?? (task.id ? board.db.prepare('SELECT tags FROM supercode_cards WHERE task_id=?').get(task.id)?.tags : null);
+  return Array.isArray(raw) ? raw : raw ? JSON.parse(raw) : task.tenant ? [task.tenant] : [];
+};
 export const workspaceTask = (board, task, { claims = false } = {}) => ({ ...task, handle: task.handle ?? cardHandleOf(board, task.id),
+  tags: workspaceTags(board, task),
   named_branch: task.id ? lastNamed(board.db, task.id)?.branch ?? null : null,
   ...(claims ? { branch_claim: task.workspace_kind === 'worktree' ? branchClaim(board.db, task.id, task.branch_name) : null } : {}) });
 /** A `dir` workspace declared as a folder its machine answers is no git checkout at all (git's "not a git repository (or
@@ -155,6 +189,7 @@ const plainFolder = (declared, error) => {
 };
 /** Its machine's git answered that the folder is not there (git's "cannot change to '<path>': No such file or directory"). */
 const folderGone = (error) => /cannot change to .*: No such file or directory/.test(error?.message ?? '');
+const recordingOptions = task => ({ include_recordings: Array.isArray(task.tags) && task.tags.includes('workspace-recordings') });
 /** A card's worktree folder deleted from disk (removed through git, or by hand) is made again from the card's branch by
  *  its machine's resolve door (teams workspaces.mjs resolve: its stale registration forgotten, the branch's pushed head
  *  fetched), at the folder it had: a card whose recorded worktree is gone is re-prepared at launch, never guarded. A
@@ -166,11 +201,24 @@ async function remadeDirWorktree(task, declared, error, create) {
   if (!folderGone(error) || !task.branch_name || basename(dirname(path)) !== '.worktrees') throw error;
   const checkout = await workspaceDoor(task.machine, 'inspect', dirname(dirname(path))).catch(() => null);
   if (!checkout?.repository || checkout.linked) throw error;
-  const made = await workspaceDoor(task.machine, 'resolve', checkout.repository, { branch: task.branch_name, solo: true, card: basename(path), create });
+  const made = await workspaceDoor(task.machine, 'resolve', checkout.repository, { branch: task.branch_name, solo: true, card: basename(path), create, ...recordingOptions(task) });
   if (made.path !== path) throw error;
   return { ...made, root: made.path };
 }
-export async function resolveWorkspace(task, create = false, { move = false } = {}) {
+export async function resolveWorkspace(task, create = false, { move = false, role = null, cwd = null, reviewWorkspace = null } = {}) {
+  if (task.workspace_kind === 'worktree' && role === 'reviewer') {
+    // A conversation's cwd is part of its native resume identity, including reviewers predating isolated allocations.
+    if (cwd) return { ...await workspaceDoor(task.machine, 'inspect', cwd), path: cwd, reviewWorkspace };
+    const beside = reviewWorkspace?.path ?? task.workspace_path;
+    const paths = /^(?:[A-Za-z]:[\\/]|\\\\)/.test(beside ?? '') ? win32 : posix;
+    const checkout = beside && paths.basename(paths.dirname(beside)) === '.worktrees' ? paths.dirname(paths.dirname(beside)) : null;
+    const made = await workspaceDoor(task.machine, 'resolve', task.workspace_anchor, {
+      solo: true, detached: true, card: `${task.id}-review`, create, ...(checkout ? { checkout } : {}),
+    });
+    if (!made.linked || made.branch !== null)
+      throw new Error(`workspace resolve on ${task.machine ?? localMachine()} did not provide the detached reviewer allocation for ${task.id}; its answer names branch ${made.branch ?? '(none)'}`);
+    return { ...made, reviewWorkspace: { path: made.path, repository: made.repository, machine: normalMachine(task.machine ?? localMachine()) } };
+  }
   const declared = task.workspace_anchor ?? task.workspace_path;
   if (isWorkspacePath(declared)) {
     if (task.workspace_kind === 'dir') return workspaceDoor(task.machine, 'inspect', declared)
@@ -196,7 +244,7 @@ export async function resolveWorkspace(task, create = false, { move = false } =
     // Another machine's folder is read there, and one its git answers is gone is made again through that machine's
     // resolve door at the same folder, as a missing folder on this machine is by the solo resolve after this branch.
     const cached = await workspaceDoor(task.machine, 'inspect', task.workspace_path).catch((error) => { if (folderGone(error)) return null; throw error; });
-    if (!cached) return workspaceDoor(task.machine, 'resolve', declared, { branch: worktreeBranch(task), solo: true, card: worktreeFolder(task), create });
+    if (!cached) return workspaceDoor(task.machine, 'resolve', declared, { branch: worktreeBranch(task), solo: true, card: worktreeFolder(task), create, ...recordingOptions(task) });
     if (cached.linked && basename(cached.path) === worktreeFolder(task) && basename(dirname(cached.path)) === '.worktrees' &&
         cached.repository === repositoryId(declared)) {
       if (cached.branch === worktreeBranch(task)) {
@@ -206,14 +254,14 @@ export async function resolveWorkspace(task, create = false, { move = false } =
       // Off its branch, it is put on it only for a start of this card that no other current run shares (`move`), by its
       // machine's resolve door when that loses nothing, which otherwise answers why not. Every other read refuses as before.
       if (move) {
-        const made = await workspaceDoor(task.machine, 'resolve', declared, { branch: worktreeBranch(task), solo: true, card: worktreeFolder(task), create, move });
+        const made = await workspaceDoor(task.machine, 'resolve', declared, { branch: worktreeBranch(task), solo: true, card: worktreeFolder(task), create, move, ...recordingOptions(task) });
         if (made.path === cached.path) return { ...made, root: dirname(dirname(made.path)) };
       }
     }
     throw new Error(`card worktree ${task.workspace_path} does not match ${declared}, branch ${worktreeBranch(task)}; retarget its workspace explicitly`);
   }
   const solo = task.workspace_kind === 'worktree';
-  return workspaceDoor(task.machine, 'resolve', declared, { branch: solo ? worktreeBranch(task) : task.branch_name, solo, card: solo ? worktreeFolder(task) : task.id, create, ...(solo && task.branch_claim ? { claim: task.branch_claim } : {}) });
+  return workspaceDoor(task.machine, 'resolve', declared, { branch: solo ? worktreeBranch(task) : task.branch_name, solo, card: solo ? worktreeFolder(task) : task.id, create, ...(solo ? recordingOptions(task) : {}), ...(solo && task.branch_claim ? { claim: task.branch_claim } : {}) });
 }
 /** Whether another card's current run holds `task`'s recorded worktree folder on the same machine. */
 function heldByAnotherRun(db, task) {
@@ -222,12 +270,12 @@ function heldByAnotherRun(db, task) {
   return db.prepare(`SELECT t.id,t.workspace_path,c.machine FROM tasks t LEFT JOIN supercode_cards c ON c.task_id=t.id WHERE t.current_run_id IS NOT NULL AND t.workspace_kind='worktree' AND t.id!=?`).all(task.id)
     .some(row => normalMachine(row.machine ?? localMachine()) === normalMachine(task.machine ?? localMachine()) && workspacePath(row.workspace_path, local) === mine);
 }
-export async function checkWorkspace(board, task) {
+export async function checkWorkspace(board, task, options = {}) {
   if (task.workspace_kind === 'scratch') return null;
   task = workspaceTask(board, task, { claims: true });
   // Every caller starts this card (a claim, its launch attempt, a person's start), so its own worktree may be put on its
   // branch, unless another card's current run holds the same folder on this machine; a peer is only ever read.
-  const facts = await resolveWorkspace(task, false, { move: !heldByAnotherRun(board.db, task) }), peers = [];
+  const facts = await resolveWorkspace(task, false, { ...options, move: !heldByAnotherRun(board.db, task) }), peers = [];
   const workspaceRoot = task.workspace_kind === 'worktree' ? facts.path : facts.root;
   // New claims retain their exact checkout receipt before launch. Legacy claims without a receipt are resolved
   // once for this check, including subdirectories and remote aliases that their retained path alone cannot identify.
@@ -248,6 +296,27 @@ const workspacePath = (path, local) => {
   if (local) { try { return realpathSync(path); } catch { /* a pre-launch reservation may not exist yet */ } }
   return path.replace(/\/+$/, '');
 };
+/** Allocations the board made for this card's reviewer slots, retained independently of their current conversation. */
+export function reviewWorkspaces(db, id) {
+  // Advance by distinct indexed keys, skipping all repetitions of an allocation in prior review runs.
+  return db.prepare(`WITH RECURSIVE allocations(key) AS (
+      SELECT (SELECT ${REVIEW_ALLOCATION_KEY} FROM task_runs WHERE task_id=? AND ${REVIEW_ALLOCATION_KEY} IS NOT NULL
+        ORDER BY ${REVIEW_ALLOCATION_KEY} LIMIT 1)
+      UNION ALL SELECT (SELECT ${REVIEW_ALLOCATION_KEY} FROM task_runs WHERE task_id=? AND ${REVIEW_ALLOCATION_KEY} IS NOT NULL
+        AND ${REVIEW_ALLOCATION_KEY}>allocations.key ORDER BY ${REVIEW_ALLOCATION_KEY} LIMIT 1)
+      FROM allocations WHERE key IS NOT NULL)
+    SELECT metadata FROM task_runs WHERE id IN (SELECT (SELECT id FROM task_runs WHERE task_id=?
+      AND ${REVIEW_ALLOCATION_KEY} IS NOT NULL AND ${REVIEW_ALLOCATION_KEY}=allocations.key ORDER BY id DESC LIMIT 1)
+      FROM allocations WHERE key IS NOT NULL) ORDER BY id DESC`).all(id, id, id)
+    .map(row => { const session = json(row.metadata, {}).supercode; return { ...session.review_workspace, slot: session.slot ?? 'worker' }; });
+}
+/** All board-owned worktrees of a card; an adopted session's arbitrary cwd is never an allocation. */
+export function cardWorktrees(db, task) {
+  if (task.workspace_kind !== 'worktree') return [];
+  const worktrees = [...(task.workspace_path ? [{ path: task.workspace_path, machine: task.machine, branch: task.branch_name }] : []),
+    ...reviewWorkspaces(db, task.id).map(row => ({ ...row, branch: null }))];
+  return [...new Map(worktrees.map(row => [`${normalMachine(row.machine ?? localMachine())}:${row.path}`, row])).values()];
+}
 export function assertWorkspaceOwner(db, task, checked) {
   if (!checked?.workspaceRoot) return;
   const machine = normalMachine(task.machine ?? localMachine()), local = machine === localMachine();
@@ -256,6 +325,14 @@ export function assertWorkspaceOwner(db, task, checked) {
     .find(row => row.id !== task.id && normalMachine(row.machine ?? localMachine()) === machine &&
       (workspacePath(row.workspace_root, local) === path || workspacePath(row.workspace_path, local) === path || checked.peers?.includes(row.id)));
   if (conflict) throw new Error(`workspace ${checked.path} is already used by running card ${conflict.id}; declare worktree:${checked.repository} for a solo worktree`);
+  const reviewer = db.prepare(`WITH RECURSIVE owners(id) AS (
+      SELECT (SELECT task_id FROM task_runs WHERE ${REVIEW_ALLOCATION_PATH}=? AND ${REVIEW_ALLOCATION_MACHINE}=?
+        ORDER BY task_id LIMIT 1)
+      UNION ALL SELECT (SELECT task_id FROM task_runs WHERE ${REVIEW_ALLOCATION_PATH}=? AND ${REVIEW_ALLOCATION_MACHINE}=?
+        AND task_id>owners.id ORDER BY task_id LIMIT 1) FROM owners WHERE id IS NOT NULL)
+    SELECT t.id FROM owners JOIN tasks t ON t.id=owners.id WHERE t.id!=? AND t.workspace_kind='worktree'
+      AND t.status NOT IN ('done','archived','cancelled') LIMIT 1`).get(path, machine, path, machine, task.id);
+  if (reviewer) throw new Error(`workspace ${checked.path} belongs to reviewer of card ${reviewer.id}; declare worktree:${checked.repository} for a solo worktree`);
 }
 
 export const isLocalWorkspace = task => !task.machine || normalMachine(task.machine) === localMachine();