@volter/supercode-orchestrator 0.5.226 → 0.5.227

package/board/workspace.mjs

@@ -97,19 +97,85 @@ export async function checkoutOf(machine, repository, branch) {
   return workspaceDoor(machine, 'resolve', repositoryId(repository), { branch });
 }
 // A card's solo worktree folder under the repository's `.worktrees`: the one it was made in, while its path is recorded
-// (a card running keeps its folder), else its handle (`vo-856`, store.mjs cardHandle; `task.handle`), as the board names
-// a card's worktree, else its id. Its branch is its own, else `wt/<id>`, as the folder named for its id had.
+// (a card running keeps its folder); else, for the branch the board last named for it (`task.named_branch`, its latest
+// `branch_named`: `voice-calls`, store.mjs cardBranch), that branch's last part, whatever the card is called now; else its
+// handle (`vo-856`, store.mjs cardHandle; `task.handle`), for a branch named by its number; else its id. Its branch is its
+// own, else `wt/<id>`, as the folder named for its id had.
 const worktreeFolder = (task) => {
   if (task.workspace_path && basename(dirname(task.workspace_path)) === '.worktrees') return basename(task.workspace_path);
   const branch = task.branch_name?.split('/').at(-1);
+  if (task.named_branch && task.branch_name === task.named_branch) return branch;
   return task.handle && (branch === task.handle || branch?.startsWith(`${task.handle}-`)) ? task.handle : task.id;
 };
 const worktreeBranch = (task) => task.branch_name ?? `wt/${task.id}`;
-export async function resolveWorkspace(task, create = false) {
+/** The card's latest `branch_named` event (the branch the board named for it, and its repository), else null. */
+const lastNamed = (db, id) => {
+  const row = db.prepare("SELECT id,json_extract(payload,'$.branch') AS branch,json_extract(payload,'$.repository') AS repository FROM task_events WHERE task_id=? AND kind='branch_named' ORDER BY id DESC LIMIT 1").get(id);
+  return row?.branch ? row : null;
+};
+/** The card's latest naming (lastNamed) while it names `branch` and no `worktree_made` follows it, else null. */
+const unmadeNaming = (db, id, branch) => {
+  const named = lastNamed(db, id);
+  if (!branch || named?.branch !== branch) return null;
+  return db.prepare("SELECT 1 FROM task_events WHERE task_id=? AND kind='worktree_made' AND id>? LIMIT 1").get(id, named.id) ? null : named;
+};
+/** Card `task`'s claim on its branch (its native id) while the branch the board last named for it (`branch_named`) is
+ *  its branch and no worktree of it has been made since (`worktree_made`, a later event, or a recorded worktree path:
+ *  unrecordedMaking): its machine's resolve then takes no branch or folder of that name that already exists (teams
+ *  workspaces.mjs). A retarget to another repository names the branch again, and claims it again there. Null otherwise. */
+export function branchClaim(db, id, branch) {
+  if (!id || !unmadeNaming(db, id, branch)) return null;
+  return db.prepare('SELECT workspace_path FROM tasks WHERE id=?').get(id)?.workspace_path ? null : id;
+}
+/** The making of card `id`'s named branch that no `worktree_made` records: the worktree path the card has recorded while
+ *  the branch the board last named for it is its branch and no making follows the naming. Every naming (createCard, a
+ *  retarget) leaves the card no path, and a launch records one only once its machine made the worktree, so a recorded
+ *  path is a making. A generation whose format this one's READABLE_BY names (storage-contract.mjs) records only the path
+ *  when it makes a worktree the board named here. { branch, repository, path }, else null. */
+export function unrecordedMaking(db, id) {
+  const task = db.prepare('SELECT branch_name,workspace_kind,workspace_path FROM tasks WHERE id=?').get(id);
+  if (task?.workspace_kind !== 'worktree' || !task.workspace_path) return null;
+  const named = unmadeNaming(db, id, task.branch_name);
+  return named ? { branch: named.branch, repository: named.repository ?? null, path: task.workspace_path } : null;
+}
+/** 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). */
+export const workspaceTask = (board, task, { claims = false } = {}) => ({ ...task, handle: task.handle ?? cardHandleOf(board, task.id),
+  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
+ *  any of the parent directories)"; t_d424b9a3's volter folder on volter-desktop holds game-std and helldiver-lowpoly)
+ *  is that folder: its own root, with no repository or branch (`folder`). Every resolution takes it from here: a run's
+ *  claim (checkWorkspace) and its launch directory (dispatch resolveLocalWorkspace) are the folder, and its review reads
+ *  the arc's recorded repositories (ci repositoryWorkspace). Any other failure still throws. */
+const plainFolder = (declared, error) => {
+  if (!/not a git repository \(or any of the parent directories\)/.test(error?.message ?? '')) throw error;
+  const path = declared.replace(/[\\/]+$/, '');
+  return { path, root: path, linked: false, repository: null, branch: null, folder: true };
+};
+/** 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 ?? '');
+/** 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
+ *  `dir` declaration naming such a folder (`<checkout>/.worktrees/<card>`, with the card's branch) is re-prepared the
+ *  same way from the repository its checkout declares; any folder elsewhere, or a checkout that resolves to another
+ *  folder, still throws the machine's own answer. */
+async function remadeDirWorktree(task, declared, error, create) {
+  const path = declared.replace(/[\\/]+$/, '');
+  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 });
+  if (made.path !== path) throw error;
+  return { ...made, root: made.path };
+}
+export async function resolveWorkspace(task, create = false, { move = false } = {}) {
   const declared = task.workspace_anchor ?? task.workspace_path;
   if (isWorkspacePath(declared)) {
+    if (task.workspace_kind === 'dir') return workspaceDoor(task.machine, 'inspect', declared)
+      .catch((error) => folderGone(error) ? remadeDirWorktree(task, declared, error, create) : plainFolder(declared, error));
     const info = await workspaceDoor(task.machine, 'inspect', declared);
-    if (task.workspace_kind === 'dir') return info;
     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');
   }
@@ -127,29 +193,49 @@ export async function resolveWorkspace(task, create = false) {
   if (task.workspace_kind === 'worktree' && task.workspace_path &&
       basename(dirname(task.workspace_path)) === '.worktrees' &&
       (!isLocalWorkspace(task) || existsSync(task.workspace_path))) {
-    const cached = await workspaceDoor(task.machine, 'inspect', task.workspace_path);
+    // 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.linked && basename(cached.path) === worktreeFolder(task) && basename(dirname(cached.path)) === '.worktrees' &&
-        cached.repository === repositoryId(declared) && cached.branch === worktreeBranch(task)) {
-      if (create) await workspaceDoor(task.machine, 'register', cached.root);
-      return { ...cached, root: dirname(dirname(cached.path)) };
+        cached.repository === repositoryId(declared)) {
+      if (cached.branch === worktreeBranch(task)) {
+        if (create) await workspaceDoor(task.machine, 'register', cached.root);
+        return { ...cached, root: dirname(dirname(cached.path)) };
+      }
+      // 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 });
+        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 });
+  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 } : {}) });
+}
+/** Whether another card's current run holds `task`'s recorded worktree folder on the same machine. */
+function heldByAnotherRun(db, task) {
+  if (task.workspace_kind !== 'worktree' || !task.workspace_path) return false;
+  const local = isLocalWorkspace(task), mine = workspacePath(task.workspace_path, local);
+  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) {
   if (task.workspace_kind === 'scratch') return null;
-  task = { ...task, handle: task.handle ?? cardHandleOf(board, task.id) };
-  const facts = await resolveWorkspace(task), peers = [];
+  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 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.
   {
-    for (const row of board.db.prepare(`SELECT t.id,t.workspace_kind,t.workspace_path,t.branch_name,c.workspace_anchor,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!='scratch' AND c.workspace_root IS NULL`).all()) {
+    for (const row of board.db.prepare(`SELECT t.id,t.readable_id,t.workspace_kind,t.workspace_path,t.branch_name,c.workspace_anchor,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!='scratch' AND c.workspace_root IS NULL`).all()) {
       if (row.id === task.id || normalMachine(row.machine ?? localMachine()) !== normalMachine(task.machine ?? localMachine())) continue;
       let other;
-      try { other = await resolveWorkspace({ ...row, handle: cardHandleOf(board, row.id) }); } catch { continue; } // Its retained path/reservation is still checked below.
+      try { other = await resolveWorkspace(workspaceTask(board, row)); } catch { continue; } // Its retained path/reservation is still checked below.
       if ((row.workspace_kind === 'worktree' ? other.path : other.root) === workspaceRoot) peers.push(row.id);
     }
   }

package/board/ztrack.mjs

@@ -19,7 +19,7 @@ import { createHash, randomBytes } from 'node:crypto';
 import { existsSync, linkSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
-import { actorOf, boardKey, CARD_NUMBERS, contention, raiseCardNumbers, event, json, now, principalOf, storageFault, STORAGE_TRIES, unreadable } from './store.mjs';
+import { actorOf, boardKey, CARD_NUMBERS, contention, raiseCardNumbers, unnumberTasks, event, json, now, principalOf, storageFault, STORAGE_TRIES, unreadable } from './store.mjs';
 import { GitDocument } from './git-document.mjs';
 import { unimported } from './legacy-store.mjs';
 import { noteStep, recordSlow } from '@volter/supercode-harness-sdk/slow-log';
@@ -108,6 +108,11 @@ const isArchive = (role) => role === 'archived' || String(role ?? '').startsWith
 // The open document's record of the numbers the board has given (numberMark: its key, its number), and a task line's
 // number (`- [ ] VO-2836 c3`); either written keyed, or with `#` as before a board read its numbers with a key.
 const NUMBER_MARK = /^The board has given card numbers up to (?:#|([A-Z][A-Z0-9]+)-)(\d+)\.[ \t]*$/m;
+// The open document's record of every card's number (VO-3578: a store made again from its documents keeps every card's
+// number). A heading carries no number (a 2.x codec reads `## VO-154 t_… — title` as a card whose id is VO-154), so the
+// numbers live in the preamble, which every reader of the documents, of any release, reads as text: `<id> <KEY-N>, …`.
+const NUMBERS_KEPT = /^The board keeps its card numbers: (.*)\.[ \t]*$/m;
+const NUMBER_KEPT = /([^\s,]+) (?:#|[A-Z][A-Z0-9]+-)(\d+)/g;
 const TASK_NUMBER = /^\s*[-*] \[[ xX]\]\s+(?:#|[A-Z][A-Z0-9]+-)(\d+)\s+[a-z]+\d+\s/gm;
 
 const BOARD_TABLES = `
@@ -138,7 +143,7 @@ export function openZtrackBoard(marker, { create = false, document = null, decla
   }
   const config = JSON.parse(read(marker));
   const backing = new ZtrackBoard({ ...config, seed, marker, init, root, slug, held, readOnly });
-  return { db: backing.db, snapshot: (path) => backing.snapshot(path), tx: (fn) => backing.tx(fn), publishPending: () => backing.git?.publishPending(), unimported: () => backing.unimported(), close: () => backing.close(), document: backing.path,
+  return { db: backing.db, snapshot: (path) => backing.snapshot(path), vacuum: (sql) => backing.vacuum(sql), tx: (fn) => backing.tx(fn), publishPending: () => backing.git?.publishPending(), unimported: () => backing.unimported(), close: () => backing.close(), document: backing.path,
     documentsChanged: () => backing.documentsChanged(), documentsUnwatched: (unwatched) => { backing.unwatched = unwatched; }, saidOnOpen: () => backing.sayLate() };
 }
 
@@ -286,6 +291,13 @@ class ZtrackBoard {
     this.conn.prepare('VACUUM INTO ?').run(path);
   }
 
+  // Run SQL on the store's own connection outside its write wrapper (a rebuild: SQLite forbids VACUUM inside a tx).
+  vacuum(sql) {
+    if (this.active || this.readOnly) throw new Error('rebuilding the board needs a writable backing outside a transaction');
+    this.tx(() => {});
+    this.conn.exec(sql);
+  }
+
   statement(sql) {
     let statement = this.statements.get(sql);
     if (!statement) {
@@ -462,13 +474,14 @@ class ZtrackBoard {
       put(`chunks:${role}`, entries);
     }
     put('published', published);
-    // The earlier store held no numbers: its cards take the numbers their documents' headings give them, and the rest
-    // are numbered in the order they were made, after every number the documents name (documentNumbers).
+    // The earlier store held no numbers: its cards take the numbers their documents' headings give them, and the other
+    // cards are numbered in the order they were made, after every number the documents name (documentNumbers); a task is not.
     db.exec(`DELETE FROM ${CARD_NUMBERS}; DELETE FROM sqlite_sequence WHERE name = '${CARD_NUMBERS}'`);
     const named = this.documentNumbers();
     this.numberFromHeadings([...named.headings].filter(([id]) => db.prepare('SELECT 1 FROM tasks WHERE id = ?').get(id)), db);
     raiseCardNumbers(db, named.highest);
-    db.exec(`INSERT INTO ${CARD_NUMBERS} (task_id) SELECT id FROM tasks WHERE id NOT IN (SELECT task_id FROM ${CARD_NUMBERS}) ORDER BY created_at, id`);
+    db.exec(`INSERT INTO ${CARD_NUMBERS} (task_id) SELECT id FROM tasks WHERE id NOT IN (SELECT task_id FROM ${CARD_NUMBERS})
+      AND id NOT IN (SELECT task_id FROM supercode_cards WHERE subtask_of IS NOT NULL) ORDER BY created_at, id`);
     db.exec('COMMIT');
   }
 
@@ -919,8 +932,14 @@ class ZtrackBoard {
     if (initial) {
       if (rebuilding) this.conn.exec(`DELETE FROM ${CARD_NUMBERS}`);
       this.numberFromHeadings([...plan.numbers].filter(([id]) => plan.rows.has(id)));
-      raiseCardNumbers(this.conn, this.documentNumbers().highest);
+      const named = this.documentNumbers();
+      this.numberFromHeadings([...named.kept].filter(([id]) => plan.rows.has(id) || this.one('SELECT 1 FROM main.tasks WHERE id = ?', id)));
+      raiseCardNumbers(this.conn, named.highest);
     }
+    // What is numbered before the cards load: a task the document or the store had numbered keeps it, and a task row the
+    // load inserts gives back the number the insert trigger hands it (only cards are numbered).
+    const numbered = overlay ? null : new Set(this.statement(`SELECT task_id FROM main.${CARD_NUMBERS}`).all().map((row) => row.task_id));
+    const handedOut = overlay ? 0 : this.one(`SELECT seq FROM main.sqlite_sequence WHERE name = '${CARD_NUMBERS}'`)?.seq ?? 0;
     for (const [id, rows] of plan.rows) {
       const before = fingerprintOf(id);
       const oldTask = this.one(`SELECT * FROM ${schema}.tasks WHERE id = ?`, id) ?? {};
@@ -939,6 +958,7 @@ class ZtrackBoard {
         events.push({ id, kind, payload: { by, source: 'document', status: after.status, assignee: after.assignee, author: by }, before, after });
       }
     }
+    if (!overlay) unnumberTasks(this.conn, numbered, handedOut);
     for (const id of plan.checked) this.errors.delete(id);
     for (const [id, reason] of plan.errors) this.errors.set(id, reason);
     // A read overlays new document cards before the owner commits them. Give that
@@ -1043,7 +1063,7 @@ class ZtrackBoard {
       return parents;
     };
     let parents = cardsTouched();
-    const mark = this.numbersRendered ? this.numberMark() : null;
+    const mark = this.numberMark();
     if (!parents.size && !mark) return [];
     const heldBy = (id) => this.errors.has(id) || this.one('SELECT 1 FROM main.supercode_cards WHERE subtask_of = ? AND task_id IN (SELECT id FROM main.board_errors)', id);
     // A card held by a recorded refusal is not rendered, so the store's verbs move its tasks past its lines. When
@@ -1278,7 +1298,7 @@ class ZtrackBoard {
   // `headings`, card id → the number its heading gives, and `highest`, the highest number any of them names (a
   // heading, a task line, or the open document's record of the numbers given, numberMark).
   documentNumbers() {
-    const headings = new Map();
+    const headings = new Map(), kept = new Map();
     let highest = 0;
     const dir = dirname(this.path), named = basename(this.path);
     let rotated = [];
@@ -1286,7 +1306,10 @@ class ZtrackBoard {
     for (const path of [this.path, this.archive, ...rotated]) {
       const text = lf(read(path));
       for (const line of text.matchAll(TASK_NUMBER)) highest = Math.max(highest, Number(line[1]));
-      if (path === this.path) highest = Math.max(highest, Number(NUMBER_MARK.exec(text)?.[2] ?? 0));
+      if (path === this.path) {
+        highest = Math.max(highest, Number(NUMBER_MARK.exec(text)?.[2] ?? 0));
+        for (const [, id, number] of (NUMBERS_KEPT.exec(text)?.[1] ?? '').matchAll(NUMBER_KEPT)) { kept.set(nativeId(id), Number(number)); highest = Math.max(highest, Number(number)); }
+      }
       let records = [];
       try { ({ records } = this.codec.inspectBoardDocument(text, path)); } catch { continue; }
       for (const record of records) {
@@ -1295,26 +1318,31 @@ class ZtrackBoard {
         if (!headings.has(nativeId(record.id))) headings.set(nativeId(record.id), record.number);
       }
     }
-    return { headings, highest };
+    for (const [id, number] of kept) if (!headings.has(id)) headings.set(id, number);
+    return { headings, kept, highest };
   }
 
   // The open document records the highest number the store has given (a line of its preamble, NUMBER_MARK), so a store
   // made again from the documents hands out none at or below it, whatever card held it: a subtask filed and gone, or
-  // a card the documents no longer show. The edit that brings the line up to the store's count, or null.
+  // a card the documents no longer show; and every card's number (NUMBERS_KEPT), which that store gives back. The edit
+  // that brings the two lines up to the store, or null. Only the preamble is written: no card is written again for it.
   numberMark() {
     const given = Number(this.one('SELECT seq FROM main.sqlite_sequence WHERE name = ?', CARD_NUMBERS)?.seq ?? 0);
     if (!given) return null;
     const keyed = this.numberForm === 'keyed';
     const line = (top) => `The board has given card numbers up to ${keyed ? `${this.cardKey}-` : '#'}${top}.`;
+    const cards = this.statement(`SELECT n.task_id, n.number FROM main.${CARD_NUMBERS} n JOIN main.supercode_cards c ON c.task_id = n.task_id WHERE c.subtask_of IS NULL ORDER BY n.number`).all();
+    const kept = `The board keeps its card numbers: ${cards.map((row) => `${row.task_id} ${this.cardKey}-${row.number}`).join(', ')}.`;
     const first = this.entries('open')[0];
     if (first && first.id === null) {
       const text = this.texts([first])[0].text;
       const said = NUMBER_MARK.exec(text);
-      if (said && (keyed ? said[1] === this.cardKey : said[1] === undefined) && Number(said[2]) >= given) return null;
-      const next = said ? text.replace(NUMBER_MARK, line(Math.max(given, Number(said[2])))) : `${text.replace(/\n*$/, '')}\n\n${line(given)}\n\n`;
+      let next = said ? text.replace(NUMBER_MARK, line(Math.max(given, Number(said[2])))) : `${text.replace(/\n*$/, '')}\n\n${line(given)}\n\n`;
+      next = NUMBERS_KEPT.test(next) ? next.replace(NUMBERS_KEPT, () => kept) : next.replace(NUMBER_MARK, (mark) => `${mark}\n${kept}`);
+      if (next === text) return null;
       return { index: 0, entry: { cid: null, id: null, level: 0, len: next.length, rec: null, text: next } };
     }
-    const text = `${line(given)}\n\n`;
+    const text = `${line(given)}\n${kept}\n\n`;
     return { prepend: true, entry: { cid: null, id: null, level: 0, len: text.length, rec: null, text } };
   }