@volter/supercode-orchestrator 0.4.111 → 0.4.113

package/board/cli.mjs

@@ -10,6 +10,7 @@ import { basename, join, resolve } from 'node:path';
 import { tmpdir } from 'node:os';
 import { read } from '../orchestration.mjs';
 import { view, backingPaths, layOut, backingOf, boardExists, boardPath, DEFAULT_BOARD, event, json, listBoards, logsDir, now, openBoard, setActor, tx } from './store.mjs';
+import { isLocalWorkspace } from './workspace.mjs';
 import { openZtrackBoard } from './ztrack.mjs';
 import * as engine from './engine.mjs';
 import { adoptSession, boardAddress, boardLabel, boardSettings, callerSession, reconcileCallerLaunch, closeRequested, lanesOf, localMachine, observeFleet, paused, plan, startCard, tick } from './dispatch.mjs';
@@ -22,7 +23,7 @@ Hermes Kanban's verbs, with their flags:
   init [--backing sqlite|files|ztrack] [--document <arcs.md>]
   migrate --backing ztrack --document <arcs.md> --status-map <json>
   boards list|create|rm|switch|show|rename|set-default-workdir|export|import
-  create <title> [--body] [--assignee] [--parent]... [--workspace scratch|worktree[:<path>]|dir:<path>] [--branch] [--project]
+  create <title> [--body] [--assignee] [--parent]... [--workspace scratch|worktree:<repository>|dir:<repository>] [--branch] [--project]
          [--tenant] [--priority] [--triage] [--idempotency-key] [--max-runtime 30m] [--created-by] [--skill]... [--max-retries]
          [--model] [--provider] [--goal|--no-goal] [--goal-max-turns] [--initial-status blocked|running]
   swarm <goal> --worker PROFILE:TITLE[:SKILL,SKILL]... --verifier P --synthesizer P
@@ -189,7 +190,7 @@ const ts = (t) => {
 const line = (t) => `${ICONS[t.status] ?? '?'} ${t.id}  ${(t.stage ?? t.status).padEnd(8)}  ${(t.assignee || '(unassigned)').padEnd(20)}${t.tenant ? ` [${t.tenant}]` : ''}  ${t.title}${t.machine ? `  @${t.machine}` : ''}`;
 const cardDict = (t) => ({
   id: t.id, title: t.title, body: t.body, assignee: t.assignee, status: t.status, priority: t.priority, tenant: t.tenant,
-  workspace_kind: t.workspace_kind, workspace_path: t.workspace_path, branch_name: t.branch_name, project_id: t.project_id,
+  workspace_kind: t.workspace_kind, repository: t.workspace_anchor ?? null, workspace_path: t.workspace_path, branch_name: t.branch_name, project_id: t.project_id,
   created_by: t.created_by, created_at: t.created_at, started_at: t.started_at, completed_at: t.completed_at, result: t.result,
   skills: t.skills ?? [], max_retries: t.max_retries, model_override: t.model_override, provider_override: t.provider_override,
   session_id: t.session_id, workflow_template_id: t.workflow_template_id, current_step_key: t.current_step_key,
@@ -392,7 +393,8 @@ export async function runWorkflow(argv) {
       out.push(`  time:      ${Object.entries(card.time).filter(([, v]) => v > 0).map(([k, v]) => `${k} ${mins(v)}`).join(', ') || '-'}`);
       if (t.subtask_of) out.push(`  subtask of: ${t.subtask_of}`);
       if (t.tenant) out.push(`  tenant:    ${t.tenant}`);
-      out.push(`  workspace: ${t.workspace_kind}${t.workspace_path ? ` @ ${t.workspace_path}` : ''}`);
+      out.push(`  workspace: ${t.workspace_kind}${t.workspace_anchor ? `:${t.workspace_anchor}` : ''}`);
+      if (t.workspace_path) out.push(`  resolved:  ${t.workspace_path}`);
       if (t.branch_name) out.push(`  branch:    ${t.branch_name}`);
       if (t.skills?.length) out.push(`  skills:    ${t.skills.join(', ')}`);
       if (t.model_override) out.push(`  model:     ${t.model_override}${t.provider_override ? ` (provider: ${t.provider_override})` : ''}`);
@@ -611,8 +613,8 @@ export async function runWorkflow(argv) {
       if (!targets[0]) throw new Error(`${verb} needs a card id, or --all`);
       const results = [];
       for (const t of targets) {
-        if (verb === 'specify' && (args.title !== undefined || args.body !== undefined)) {
-          const moved = await withBoardAsync((b) => engine.specify(b, t, { title: args.title ?? null, body: args.body ?? null, author: args.author ?? callerAddress() ?? callerName() }));
+        if (verb === 'specify' && (args.title !== undefined || args.body !== undefined || args.workspace !== undefined)) {
+          const moved = await withBoardAsync((b) => engine.specify(b, t, { title: args.title ?? null, body: args.body ?? null, workspace: args.workspace ?? null, branch: args.branch ?? null, author: args.author ?? callerAddress() ?? callerName() }));
           results.push({ id: t, specified: true, status: moved.to });
         } else if (verb === 'decompose' && args.child?.length) {
           const children = args.child.map((c) => { const [title, assignee] = c.split(/@(?=[^@]*$)/); return { title: title.trim(), assignee: assignee?.trim() || undefined }; });
@@ -739,8 +741,9 @@ export async function runWorkflow(argv) {
       const logDays = Number(args['log-retention-days'] ?? 30);
       let removedWs = 0;
       const scratchRoot = slug === DEFAULT_BOARD ? join(root, 'kanban', 'workspaces') : join(boardDir(root, slug), 'workspaces');
-      const archived = withBoard((b) => b.db.prepare("SELECT id, workspace_kind, workspace_path FROM tasks WHERE status = 'archived'").all());
+      const archived = withBoard((b) => b.db.prepare("SELECT t.id,t.workspace_kind,t.workspace_path,c.machine FROM tasks t LEFT JOIN supercode_cards c ON c.task_id=t.id WHERE t.status = 'archived'").all());
       for (const t of archived) {
+        if (!isLocalWorkspace(t)) continue;
         if (t.workspace_kind === 'worktree' && t.workspace_path && existsSync(t.workspace_path)) {
           // an archived card's worktree goes, as Hermes's gc removes it (the branch stays)
           const r = spawnSync('git', ['-C', t.workspace_path, 'worktree', 'remove', '--force', t.workspace_path], { encoding: 'utf8' });

package/board/dispatch.mjs

@@ -24,6 +24,7 @@ import { randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { view, boardPath, claimer, event, json, listBoards, logsDir, now, openBoard, setActor, tx } from './store.mjs';
 import { doors, fire, loadWorkflow, resumeOf, runSpec, requestSessionClose, retireSupersededRuns, refreshRelationAnswers, transitionsFor, scopeOf, statusOf, templateValue, workflowFor } from './workflow.mjs';
+import { checkWorkspace, assertWorkspaceOwner, resolveWorkspace } from './workspace.mjs';
 import { evaluate, holds, render } from './expr.mjs';
 import {
   cardContext, claimTtl, currentRun, DEFAULT_FAILURE_LIMIT, extendClaim, getTask, lastSession,
@@ -58,7 +59,7 @@ export const supercodeBin = () => process.env.SUPERCODE_BIN || 'supercode';
 // Installed board workers use their sibling Teams package, not a CLI build's retained checkout.
 // An explicit operator override remains authoritative for source development.
 let teamsEntry;
-function commandEnv(as = null) {
+export function commandEnv(as = null) {
   if (teamsEntry === undefined) {
     try { teamsEntry = createRequire(import.meta.url).resolve('@volter/supercode-teams/bin'); }
     catch { teamsEntry = null; }
@@ -439,9 +440,12 @@ function startCards(board, fleet, lanes, settings, report, entry, effects, { onl
       for (const l of limits) if (holds(l.counts, scope)) { const g = JSON.stringify(evaluate(l.group, scope)); l.tally.set(g, (l.tally.get(g) ?? 0) + 1); }
       continue;
     }
-    let moved;
+    let moved, checked;
     try {
+      checked = checkWorkspace(board, task);
       moved = tx(board, (db) => {
+        assertWorkspaceOwner(db, task, checked);
+        if (checked) db.prepare('UPDATE supercode_cards SET workspace_root=? WHERE task_id=?').run(checked.mainRoot, task.id);
         if (!task.assignee && plan.profile) {
           db.prepare('UPDATE tasks SET assignee = ? WHERE id = ?').run(plan.profile, task.id);
           event(db, task.id, 'assigned', { assignee: plan.profile, source: 'workflow role' });
@@ -473,7 +477,12 @@ function startCards(board, fleet, lanes, settings, report, entry, effects, { onl
 
 /** Launch what the card's status runs: its role's lane, in the run's session slot, told the run's prompt and doors. */
 export function launchRun(board, entry, id, lane, fleet, settings) {
-  const task = getTaskNow(board, id);
+  let task = getTaskNow(board, id);
+  const checked = checkWorkspace(board, task);
+  if (checked) tx(board, (db) => {
+    assertWorkspaceOwner(db, task, checked);
+    db.prepare('UPDATE supercode_cards SET workspace_root=? WHERE task_id=?').run(checked.mainRoot, id);
+  });
   const status = view(board, (db) => statusOf(db, task));
   const spec = runSpec(entry, status, task);
   if (!spec) return null;
@@ -502,7 +511,12 @@ export function launchRun(board, entry, id, lane, fleet, settings) {
 export async function startCard(board, id, { roles = ['manager'], lanes, settings } = {}) {
   const entry = await loadWorkflow(board.root);
   const fleet = observeFleet();
-  const moved = tx(board, (db) => fire(db, board, entry, id, entry.workflow.dispatch.start, { roles, payload: { lock: claimer() } }));
+  const before = getTaskNow(board, id), checked = checkWorkspace(board, before);
+  const moved = tx(board, (db) => {
+    assertWorkspaceOwner(db, before, checked);
+    if (checked) db.prepare('UPDATE supercode_cards SET workspace_root=? WHERE task_id=?').run(checked.mainRoot, id);
+    return fire(db, board, entry, id, entry.workflow.dispatch.start, { roles, payload: { lock: claimer() } });
+  });
   const task = getTaskNow(board, id);
   const spec = runSpec(entry, moved.to, task);
   const profile = spec ? view(board, (db) => evaluate(entry.workflow.roles?.[spec.role] ?? 'card.assignee', scopeOf(db, board, task, { params: entry.params }))) : null;
@@ -696,7 +710,7 @@ function launcherCheck(db, task, lane, fleet) {
   if (!fleet.online.has(machine)) return `machine ${machine} is offline; the card starts when it is back`;
   // a card on this machine gets its workspace made here (scratch, dir or worktree, as Hermes makes it); another
   // machine's card names its directory there
-  if (machine !== localMachine() && (task.workspace_kind !== 'dir' || !task.workspace_path)) return `a pane session on ${machine} starts in a directory there: the card's workspace is dir:<absolute path>, not ${task.workspace_kind}`;
+  if (machine !== localMachine() && task.workspace_kind === 'scratch') return `a remote card names its repository with worktree:<repository> or dir:<repository>`;
   if (!HARNESSES[lane.harness]) return `the board opens pane sessions of ${Object.keys(HARNESSES).join(' and ')}; the lane's worker is ${lane.harness}`;
   return null;
 }
@@ -828,9 +842,11 @@ function reconcileLaunches(board, fleet, report, entry, effects, settings) {
 
 function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'worker', meta = {} } = {}) {
   const machine = normalMachine(task.machine);
-  if (machine === localMachine() && !(task.workspace_kind === 'dir' && task.workspace_path && existsSync(task.workspace_path))) {
+  {
     const made = resolveLocalWorkspace(board, task);
-    tx(board, (db) => db.prepare('UPDATE tasks SET workspace_path = ? WHERE id = ?').run(made, task.id));
+    tx(board, (db) => {
+      db.prepare('UPDATE tasks SET workspace_path=?, branch_name=COALESCE(branch_name,?) WHERE id=?').run(made, task.workspace_kind === 'worktree' ? `wt/${task.id}` : null, task.id);
+    });
     task = { ...task, workspace_path: made };
   }
   const model = task.model_override ?? lane.model;
@@ -994,6 +1010,7 @@ function paneSurvives(machine, pane) {
 /** Hermes's own worker argv and task environment, run on this machine; watched by its pid. */
 function launchHeadless(board, task, runId, lane, settings, { prompt = null, skills: runSkills = [], meta = {} } = {}) {
   const workspace = resolveLocalWorkspace(board, task);
+  tx(board, (db) => db.prepare('UPDATE tasks SET workspace_path=?,branch_name=COALESCE(branch_name,?) WHERE id=?').run(workspace, task.workspace_kind === 'worktree' ? `wt/${task.id}` : null, task.id));
   // the card's own skills and the ones its status's run names (a reviewer's, for one)
   const skills = [...new Set([...task.skills, ...runSkills])];
   const args = ['-p', lane.name, '--cli', '--accept-hooks', ...skills.flatMap((s) => ['--skills', s]),
@@ -1041,20 +1058,7 @@ function rotateLog(file, max, backups) {
 /** A headless card's directory on this machine, made as Hermes makes it (scratch, dir, or a git worktree). */
 function resolveLocalWorkspace(board, task) {
   const root = board.root;
-  if (task.workspace_kind === 'dir') { mkdirSync(task.workspace_path, { recursive: true }); return task.workspace_path; }
-  if (task.workspace_kind === 'worktree') {
-    const anchor = task.workspace_path;
-    if (!anchor) throw new Error(`card ${task.id} is a worktree card with no repository (worktree:<path>)`);
-    const top = spawnSync('git', ['-C', anchor, 'rev-parse', '--show-toplevel'], { encoding: 'utf8' });
-    const repo = top.status === 0 ? top.stdout.trim() : null;
-    const target = repo && repo === anchor ? join(repo, '.worktrees', task.id) : anchor;
-    if (!existsSync(target)) {
-      const branch = task.branch_name || `wt/${task.id}`;
-      const made = spawnSync('git', ['-C', repo ?? dirname(anchor), 'worktree', 'add', '-B', branch, target], { encoding: 'utf8' });
-      if (made.status !== 0) throw new Error(`git worktree add ${target}: ${made.stderr.trim().slice(-300)}`);
-    }
-    return target;
-  }
+  if (task.workspace_kind !== 'scratch') return resolveWorkspace(task, true).path;
   const dir = task.workspace_path || (board.slug === 'default' ? join(root, 'kanban', 'workspaces', task.id) : join(root, 'kanban', 'boards', board.slug, 'workspaces', task.id));
   mkdirSync(dir, { recursive: true });
   return dir;
@@ -1102,7 +1106,7 @@ export function adoptSession(board, id, who, { workspace = null, ttl, assignee =
     if (!task.machine) db.prepare('INSERT INTO supercode_cards (task_id, machine) VALUES (?, ?) ON CONFLICT(task_id) DO UPDATE SET machine = excluded.machine').run(id, host);
     // the lane that resumes it if it is lost, set in the same transaction (assigning first would let a tick start another)
     if (assignee && assignee !== task.assignee) { db.prepare('UPDATE tasks SET assignee = ? WHERE id = ?').run(assignee, id); event(db, id, 'assigned', { assignee }); }
-    if (dir && !(task.workspace_kind === 'dir' && task.workspace_path)) {
+    if (dir && !task.workspace_anchor && !(task.workspace_kind === 'dir' && task.workspace_path)) {
       db.prepare("UPDATE tasks SET workspace_kind = 'dir', workspace_path = ? WHERE id = ?").run(dir.replace(/^dir:/, ''), id);
     }
     // the workflow's adopt event: the card is claimed for its implementer, whose session this now is
@@ -1124,7 +1128,7 @@ export function adoptSession(board, id, who, { workspace = null, ttl, assignee =
 
 // a notice sent within a transaction's caller that cannot await (the launcher): the same door, synchronously
 function deliverNow(board, to, body, key) {
-  const request = { op: 'send', from: boardAddress(board.label), from_name: `${board.label} board`, to, queue: false, id: key,
+  const request = { op: 'send', from: boardAddress(board.label), from_name: `${board.label} board`, to, queue: false, id: key, subject: String(body).split('\n')[0].slice(0, 160),
     body: `[Board notice from the ${board.label} board] ${body}\n\n(An automated notice from the board's dispatcher; replies to this address go nowhere.)` };
   const r = sc(['message', 'remote-deliver'], { input: JSON.stringify(request), timeout: 120_000 });
   const answer = lastJson(r.stdout);
@@ -1133,7 +1137,7 @@ function deliverNow(board, to, body, key) {
 
 async function send(from, label, to, body, key, { queue = false, ask = false } = {}) {
   const request = {
-    op: 'send', from, from_name: `${label} board`, to, queue, id: key,
+    op: 'send', from, from_name: `${label} board`, to, queue, id: key, subject: String(body).split('\n')[0].slice(0, 160),
     // a question the board waits on is answered by a reply; a notice is not
     body: ask ? `[A question from the ${label} board] ${body}` : `[Board notice from the ${label} board] ${body}\n\n(An automated notice from the board's dispatcher; replies to this address go nowhere.)`,
   };

package/board/engine.mjs

@@ -10,6 +10,7 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { existsSync, rmSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+import { checkWorkspace, assertWorkspaceOwner, declareWorkspace, isLocalWorkspace, isWorkspacePath } from './workspace.mjs';
 import { DatabaseSync } from 'node:sqlite';
 import { view, claimer, event, json, newTaskId, now, tx } from './store.mjs';
 import { addDependency, retireSupersededRuns, refreshCardInputs, requestSessionClose, eventTo, fire, loadWorkflow, setStatus, settle, startNew, statusOf, runEvent, workflowFor } from './workflow.mjs';
@@ -35,7 +36,7 @@ export function getTask(db, id) {
   const row = one(db, 'SELECT * FROM tasks WHERE id = ?', id);
   if (!row) return null;
   const ours = one(db, 'SELECT * FROM supercode_cards WHERE task_id = ?', id);
-  return { ...row, blocked_by: json(ours?.blocked_by, []) ?? [], paused: json(ours?.paused, null), archived: Boolean(ours?.archived), every: ours?.every ?? null, skills: json(row.skills, []) ?? [], machine: ours?.machine ?? null, subtask_of: ours?.subtask_of ?? null };
+  return { ...row, workspace_anchor: ours?.workspace_anchor ?? null, blocked_by: json(ours?.blocked_by, []) ?? [], paused: json(ours?.paused, null), archived: Boolean(ours?.archived), every: ours?.every ?? null, skills: json(row.skills, []) ?? [], machine: ours?.machine ?? null, subtask_of: ours?.subtask_of ?? null };
 }
 
 function must(db, id) {
@@ -48,13 +49,12 @@ const parentsOf = (db, id) => all(db, 'SELECT t.id, t.status FROM tasks t JOIN t
 const childrenOf = (db, id) => all(db, 'SELECT child_id AS id FROM task_links WHERE parent_id = ?', id).map((r) => r.id);
 const parentsDone = (db, id) => parentsOf(db, id).every((p) => p.status === 'done' || p.status === 'archived');
 
-/** The workspace word Hermes's CLI takes: `scratch`, `worktree`, `worktree:<path>`, `dir:<path>`. */
+/** The workspace word Hermes's CLI takes: `scratch`, `worktree:<repository>`, `dir:<repository>`. */
 export function parseWorkspace(word = 'scratch') {
   const [kind, ...rest] = String(word).split(':');
   const path = rest.join(':') || null;
-  if (!WORKSPACE_KINDS.includes(kind)) throw new Error(`workspace is scratch | worktree | worktree:<path> | dir:<path>, not ${word}`);
-  if (kind === 'dir' && !path) throw new Error('a dir workspace names its path (dir:<absolute path>)');
-  if (path && !/^(\/|~|[A-Za-z]:[\\/])/.test(path)) throw new Error(`workspace path ${path} is not absolute`);
+  if (!WORKSPACE_KINDS.includes(kind)) throw new Error(`workspace is scratch | worktree:<repository> | dir:<repository>, not ${word}`);
+  if (kind === 'dir' && !path) throw new Error('a dir workspace names its repository (dir:volter-ai/editor)');
   return { kind, path };
 }
 
@@ -155,8 +155,20 @@ export function createCard(board, spec) {
   const title = String(spec.title ?? '').trim();
   if (!title) throw new Error('a card has a title');
   const ws = parseWorkspace(spec.workspace ?? 'scratch');
-  if (spec.branch && ws.kind !== 'worktree') throw new Error('a branch is only for a worktree workspace');
+  if (spec.branch && ws.kind === 'scratch') throw new Error('a scratch workspace has no repository branch');
   const parents = [...new Set((spec.parents ?? []).filter(Boolean))];
+  const project = spec.project ? projectOf(board.root, spec.project) : null;
+  if (project) {
+    if (ws.kind === 'scratch') ws.kind = 'worktree';
+    if (ws.kind === 'worktree' && !ws.path) ws.path = project.primary_path;
+  }
+  const machineHint = spec.machine ?? (spec.subtaskOf ? getTask(board.db, spec.subtaskOf)?.machine : null);
+  const declared = declareWorkspace(ws.kind, ws.path, machineHint, spec.branch);
+  const workspaceTask = { workspace_kind: ws.kind, workspace_path: declared.path, workspace_anchor: declared.repository, branch_name: declared.branch, machine: machineHint };
+  // Logical repositories may be filed before a machine has registered them; launch refuses missing mappings.
+  const checked = ws.kind === 'dir' && declared.path ? checkWorkspace(board, workspaceTask) : null;
+  ws.path = declared.path;
+  spec = { ...spec, branch: declared.branch ?? spec.branch };
   const initial = spec.initialStatus ?? null;
   if (initial && !['blocked', 'running'].includes(initial)) throw new Error('initial status is blocked or running');
   if (spec.provider && !spec.model) throw new Error('a provider needs a model');
@@ -172,17 +184,16 @@ export function createCard(board, spec) {
     if (arc?.subtask_of) throw new Error(`${arc.id} is itself a subtask of ${arc.subtask_of}; a subtask belongs to an arc`);
     let id = newTaskId();
     while (one(db, 'SELECT 1 FROM tasks WHERE id = ?', id)) id = newTaskId();
-    // a project (Hermes's projects registry, `projects.db` in the home) anchors the card's worktree in its repository
-    const project = spec.project ? projectOf(board.root, spec.project) : null;
+    assertWorkspaceOwner(db, workspaceTask, checked);
+    // The repository declaration stays separate from the resolved worktree path.
     if (project) {
       if (ws.kind === 'scratch') ws.kind = 'worktree';
-      if (ws.kind === 'worktree' && !ws.path && project.primary_path) ws.path = join(project.primary_path, '.worktrees', id);
       if (ws.kind === 'worktree' && !spec.branch) {
         const t = title.toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40).replace(/-+$/, '');
         spec = { ...spec, branch: `${project.slug}/${id}${t ? `-${t}` : ''}` };
       }
     }
-    spec = { ...spec, project: project?.id ?? null };
+    spec = { ...spec, project: project?.id ?? null, branch: spec.branch ?? (ws.kind === 'worktree' ? `wt/${id}` : null) };
     const t = now();
     run(db, `INSERT INTO tasks (id, title, body, assignee, status, priority, created_by, created_at, workspace_kind, workspace_path, branch_name,
                tenant, idempotency_key, max_runtime_seconds, skills, max_retries, model_override, provider_override, reasoning_effort, session_id,
@@ -193,7 +204,7 @@ export function createCard(board, spec) {
       spec.skills?.length ? JSON.stringify(spec.skills) : null, spec.maxRetries ?? null, spec.model ?? null, spec.provider ?? null,
       spec.reasoning ?? null, spec.sessionId ?? null, spec.project ?? null, spec.goal ? 1 : 0, spec.goal?.maxTurns ?? null);
     const machine = spec.machine ?? arc?.machine ?? null;
-    if (machine || arc) run(db, 'INSERT OR REPLACE INTO supercode_cards (task_id, machine, subtask_of) VALUES (?, ?, ?)', id, machine, arc?.id ?? null);
+    run(db, 'INSERT OR REPLACE INTO supercode_cards (task_id,machine,subtask_of,workspace_anchor,workspace_root) VALUES (?,?,?,?,?)', id, machine, arc?.id ?? null, declared.repository, checked?.mainRoot ?? null);
     const entry = workflowFor(board.root);
     for (const p of parents) addDependency(db, entry, id, p);
     // where it starts is the workflow's `initial` (Hermes: triage, blocked, todo behind open parents, else ready)
@@ -236,7 +247,9 @@ function wouldCycle(db, parent, child) {
 export function setMachine(board, id, machine) {
   return tx(board, (db) => {
     const task = must(db, id);
-    if (task.status === 'running' && task.claim_lock) throw new Error(`${id} is running on ${task.machine}; reclaim it before moving it`);
+    if (task.current_run_id) throw new Error(`${id} has an open run on ${task.machine}; end it before moving it`);
+    if (task.workspace_kind !== 'scratch' && (!task.workspace_anchor || isWorkspacePath(task.workspace_anchor))) throw new Error('declare the repository and branch with workflow specify --workspace before moving a legacy path card');
+    if (machine !== task.machine) run(db, 'UPDATE tasks SET workspace_path=NULL WHERE id=?', id);
     run(db, 'INSERT INTO supercode_cards (task_id, machine) VALUES (?, ?) ON CONFLICT(task_id) DO UPDATE SET machine = excluded.machine', id, machine || null);
     event(db, id, 'machine_set', { machine: machine || null, was: task.machine });
   });
@@ -292,7 +305,7 @@ export function extendClaim(db, id, { ttl, reason, extra = {} }) {
  */
 function cleanupWorkspace(board, id) {
   const task = view(board, (db) => getTask(db, id));
-  if (!task?.workspace_path || !['scratch', 'worktree'].includes(task.workspace_kind)) return;
+  if (!task?.workspace_path || !isLocalWorkspace(task) || !['scratch', 'worktree'].includes(task.workspace_kind)) return;
   const waiting = view(board, (db) => one(db, "SELECT 1 FROM task_links l JOIN tasks t ON t.id = l.child_id WHERE l.parent_id = ? AND t.status NOT IN ('done', 'archived') LIMIT 1", id));
   if (waiting || !existsSync(task.workspace_path)) return;
   if (task.workspace_kind === 'worktree') { spawnSync('git', ['-C', task.workspace_path, 'worktree', 'remove', '--force', task.workspace_path], { encoding: 'utf8' }); return; }
@@ -446,7 +459,16 @@ export const schedule = (board, id, reason = null, { roles } = {}) => act(board,
 export const promote = (board, id, { actor = 'user', reason = null, force = false, roles } = {}) => act(board, id, 'promote', { roles, payload: { actor, reason, force } });
 export const reclaim = (board, id, reason = null, { roles } = {}) => act(board, id, 'reclaim', { roles, payload: { reason } });
 export const archive = (board, id, { roles } = {}) => act(board, id, 'archive', { roles });
-export const specify = (board, id, { title = null, body = null, author = 'user', roles } = {}) => act(board, id, 'specify', { roles, payload: { title, body, author } });
+export function specify(board, id, { title = null, body = null, workspace = null, branch = null, author = 'user', roles } = {}) {
+  let declaration = null;
+  if (workspace != null) {
+    const task = getTask(board.db, id), ws = parseWorkspace(workspace);
+    if (task.current_run_id) throw new Error('end the current run before changing its workspace');
+    declaration = { kind: ws.kind, ...declareWorkspace(ws.kind, ws.path, task.machine, branch) };
+    if (declaration.kind === 'worktree') declaration.branch ??= `wt/${id}`;
+  }
+  return act(board, id, 'specify', { roles, payload: { title, body, author, ...(declaration ? { workspace: declaration } : {}) } });
+}
 export const editResult = (board, id, { result, summary = null, metadata = undefined, roles } = {}) => act(board, id, 'edit', { roles, payload: { result, summary, metadata } });
 export const heartbeat = (board, id, note = null, { roles, until = null } = {}) => act(board, id, 'heartbeat', { roles, payload: { note, until } });
 export const setModel = (board, id, model = null, provider = null, { roles } = {}) => {
@@ -462,7 +484,7 @@ export async function decompose(board, id, children, { author = 'user', roles }
   const task = view(board, (db) => must(db, id));
   const ids = children.map((c) => createCard(board, {
     title: c.title, body: c.body ?? null, assignee: c.assignee ?? task.assignee, machine: task.machine,
-    workspace: task.workspace_path ? `${task.workspace_kind}:${task.workspace_path}` : task.workspace_kind, tenant: task.tenant, createdBy: author,
+    workspace: task.workspace_anchor ? `${task.workspace_kind}:${task.workspace_anchor}` : task.workspace_path ? `${task.workspace_kind}:${task.workspace_path}` : task.workspace_kind, tenant: task.tenant, createdBy: author,
   }).id);
   await act(board, id, 'decompose', { roles, payload: { children: ids, author } });
   return ids;
@@ -564,7 +586,7 @@ const cap = (text, n) => (text && text.length > n ? `${text.slice(0, n)}… (${t
 export function cardContext(db, id) {
   const task = must(db, id);
   const out = [`# Card ${task.id}: ${task.title}`, ''];
-  out.push(`Status: ${task.status}. Machine: ${task.machine ?? 'unset'}. Workspace: ${task.workspace_kind}${task.workspace_path ? ` ${task.workspace_path}` : ''}.${task.subtask_of ? ` A subtask of ${task.subtask_of}.` : ''}`);
+  out.push(`Status: ${task.status}. Machine: ${task.machine ?? 'unset'}. Workspace: ${task.workspace_kind}${task.workspace_anchor ? ` ${task.workspace_anchor}` : task.workspace_path ? ` ${task.workspace_path}` : ''}${task.branch_name ? ` (branch ${task.branch_name})` : ''}.${task.subtask_of ? ` A subtask of ${task.subtask_of}.` : ''}`);
   if (task.body) out.push('', cap(task.body, 8 * 1024));
   const parents = all(db, 'SELECT t.id, t.title, t.result FROM tasks t JOIN task_links l ON l.parent_id = t.id WHERE l.child_id = ?', id);
   if (parents.length) {

package/board/rows.mjs

@@ -13,7 +13,7 @@ export class RuntimeRows {
       const columns=mem.prepare(`PRAGMA table_info(${quote(name)})`).all();
       const keys=columns.filter(c=>c.pk).sort((a,b)=>a.pk-b.pk).map(c=>c.name);
       if (!keys.length) keys.push('rowid');
-      this.tables.set(name,{name,sql,keys});
+      this.tables.set(name,{name,sql,keys,columns});
       const key=prefix=>`json_array(${keys.map(k=>`${prefix}.${quote(k)}`).join(',')})`;
       for(const [suffix,verb,prefix] of [['i','INSERT','NEW'],['u','UPDATE','NEW'],['d','DELETE','OLD']])
         mem.exec(`CREATE TEMP TRIGGER IF NOT EXISTS ${quote(`_runtime_${name}_${suffix}`)} AFTER ${verb} ON main.${quote(name)} BEGIN INSERT OR IGNORE INTO _runtime_dirty VALUES ('${name}',${key(prefix)}); END`);
@@ -53,7 +53,7 @@ export class RuntimeRows {
       const table=this.tables.get(name);
       const row=mem.prepare(`SELECT * FROM ${quote(name)} WHERE ${table.keys.map(k=>`${quote(k)} IS ?`).join(' AND ')}`).get(...JSON.parse(key))??null;
       if(name==='tasks')return {name:'@runtime',key:JSON.parse(key)[0],value:row&&Object.fromEntries(Object.entries(row).filter(([k])=>RUNTIME.has(k))),source:{name,key,row}};
-      if(name==='supercode_cards')return {name:'@clock',key:JSON.parse(key)[0],value:row&&{since:row.since,after_fired:row.after_fired,next_run_at:row.next_run_at},source:{name,key,row}};
+      if(name==='supercode_cards')return {name:'@clock',key:JSON.parse(key)[0],value:row&&{workspace_root:row.workspace_root,since:row.since,after_fired:row.after_fired,next_run_at:row.next_run_at},source:{name,key,row}};
       return {name,key,value:row,source:{name,key,row}};
     }).filter(change=>{
       if(all)return true;
@@ -78,6 +78,9 @@ export class RuntimeRows {
     for(const name of ['tasks','supercode_cards']) {
       const table=this.tables.get(name); if(!table)return;
       this.db.exec(table.sql.replace(/^CREATE TABLE (?:IF NOT EXISTS )?(?:"[^"]+"|\w+)/,`CREATE TABLE IF NOT EXISTS ${quote('read_'+name)}`));
+      const columns=this.db.prepare(`PRAGMA table_info(${quote('read_'+name)})`).all();
+      for(const c of table.columns) if(!columns.some(old=>old.name===c.name))this.db.exec(`ALTER TABLE ${quote('read_'+name)} ADD COLUMN ${quote(c.name)} ${c.type}${c.dflt_value==null?'':` DEFAULT ${c.dflt_value}`}`);
+
     }
     const rows=previous===revision-1?changes.filter(c=>['tasks','supercode_cards'].includes(c.source.name)).map(c=>c.source):this.db.prepare("SELECT name,key,value FROM runtime_rows WHERE name IN ('@task_cache','@card_cache')").all().map(r=>({name:r.name==='@task_cache'?'tasks':'supercode_cards',key:JSON.stringify([r.key]),row:json(r.value,null)}));
     for(const {name,key,row} of rows) {

package/board/store.mjs

@@ -72,7 +72,7 @@ const OURS = `CREATE TABLE IF NOT EXISTS supercode_cards (task_id TEXT PRIMARY K
 CREATE TABLE IF NOT EXISTS supercode_effects (id INTEGER PRIMARY KEY AUTOINCREMENT, effect TEXT NOT NULL);`;
 // `stage`: the card's workflow status where kanban.db stores another (a `reviewing` card is `running` to Hermes)
 // `since`: when the card entered its workflow status; `after_fired`: which of the status's `after` moves have run since
-const OURS_COLUMNS = { subtask_of: 'TEXT', stage: 'TEXT', since: 'INTEGER', after_fired: 'TEXT', blocked_by: 'TEXT', paused: 'TEXT', archived: 'INTEGER DEFAULT 0', every: 'TEXT', next_run_at: 'INTEGER' };
+const OURS_COLUMNS = { workspace_anchor: 'TEXT', workspace_root: 'TEXT', subtask_of: 'TEXT', stage: 'TEXT', since: 'INTEGER', after_fired: 'TEXT', blocked_by: 'TEXT', paused: 'TEXT', archived: 'INTEGER DEFAULT 0', every: 'TEXT', next_run_at: 'INTEGER' };
 
 // ------------------------------------------------------------------ backings
 //

package/board/workflow.mjs

@@ -344,7 +344,7 @@ export function fire(db, board, entry, id, name, { roles = [], payload = {}, ext
   // `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 allowed = candidates.filter((t) => !t.by?.length || t.by.some((r) => roles.includes(r)));
-  if (!allowed.length) throw new Error(`${id} is ${from}; ${name.replace(/_/g, '-')} there is for ${[...new Set(candidates.flatMap((t) => t.by ?? []))].join(' or ')}`);
+  if (!allowed.length) throw new Error(`${id} is ${from}; ${name.replace(/_/g, '-')} there is for ${[...new Set(candidates.flatMap((t) => t.by ?? []))].join(' or ')}. ${candidates.map((t) => t.description).filter(Boolean).join(' ')}`);
   const taken = allowed.find((t) => holds(t.guard ?? null, scope));
   if (!taken) { const none = new Error(`${id} is ${from}; ${name.replace(/_/g, '-')} does not apply to it now`); none.noTransition = true; throw none; }
   for (const v of taken.validate ?? []) {
@@ -557,7 +557,8 @@ const ACTIONS = {
     if (!['paused', 'archived'].includes(name)) throw new Error(`unknown flag ${name}`);
     if (name === 'paused') {
       const was = json(one(ctx.db, 'SELECT paused FROM supercode_cards WHERE task_id = ?', ctx.id)?.paused, null);
-      if (!value && was && was.by !== actorOf() && !ctx.scope.sender?.includes('owner') && !(ctx.scope.sender?.includes('hermes') && ctx.scope.event?.hermes)) throw new Error('only the pauser or owner may resume this card');
+      const clearBy = ctx.entry.workflow.flags?.paused?.clear_by ?? ['pauser', 'owner'];
+      if (!value && was && !clearBy.some((role) => role === 'pauser' ? was.by === actorOf() : ctx.scope.sender?.includes(role))) throw new Error(`only ${clearBy.join(' or ')} may resume this card; ask the manager with your reason`);
       if (value && !String(reason ?? '').trim()) throw new Error('pause needs a reason');
       cardField(ctx, name, value ? JSON.stringify({ by: actorOf(), reason }) : null);
     } else cardField(ctx, name, Number(Boolean(value)));
@@ -682,6 +683,13 @@ const ACTIONS = {
     run(ctx.db, 'DELETE FROM task_links WHERE parent_id = ? AND child_id = ?', parent, ctx.id);
   },
   specify(ctx, said) {
+    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');
+      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);
+    }
     if (said?.title && String(said.title).trim()) run(ctx.db, 'UPDATE tasks SET title = ? WHERE id = ?', String(said.title).trim(), ctx.id);
     if (said?.body !== undefined && said?.body !== null) run(ctx.db, 'UPDATE tasks SET body = ? WHERE id = ?', said.body, ctx.id);
   },

package/board/workspace.mjs

@@ -0,0 +1,62 @@
+// Filesystem/RPC work happens before a board transaction; the ownership check is pure.
+import { spawnSync } from 'node:child_process';
+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 ?? '');
+function workspaceDoor(machine, verb, value, options = {}) {
+  if (!machine || normalMachine(machine) === localMachine()) {
+    const map = new Workspaces(teamsHome());
+    if (verb === 'inspect') return inspectCheckout(value);
+    if (verb === 'register') return map.register(value);
+    return map.resolve(value, options.branch, options);
+  }
+  const args = ['teams', 'workspace', verb, value, '--machine', machine];
+  for (const key of ['branch', 'card']) if (options[key]) args.push(`--${key}`, options[key]);
+  for (const key of ['solo', 'create']) if (options[key]) args.push(`--${key}`);
+  const r = spawnSync(supercodeBin(), args, { env: commandEnv(), encoding: 'utf8', timeout: 60_000 });
+  if (r.status !== 0) throw new Error(`workspace on ${machine}: ${(r.stderr || r.stdout || r.error?.message).trim()}`);
+  return JSON.parse(r.stdout);
+}
+export function declareWorkspace(kind, value, machine, branch = null) {
+  if (kind === 'scratch') return { repository: null, branch: null, path: null };
+  if (!value) throw new Error('workspace names a repository, for example worktree:volter-ai/editor');
+  if (!isWorkspacePath(value)) return { repository: repositoryId(value), branch, path: null };
+  // A legacy path supplied explicitly is checked and registered on its machine, never copied into the card.
+  const info = workspaceDoor(machine, 'inspect', value);
+  if (kind === 'worktree' && info.linked) throw new Error('worktree workspace already names a linked worktree; name its repository for a solo worktree');
+  const row = workspaceDoor(machine, 'register', value);
+  return { repository: row.repository, branch: branch ?? (kind === 'dir' ? row.branch : null), path: kind === 'dir' ? row.path : null };
+}
+export function resolveWorkspace(task, create = false) {
+  const declared = task.workspace_anchor ?? task.workspace_path;
+  if (isWorkspacePath(declared)) {
+    const info = 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');
+  }
+  return workspaceDoor(task.machine, 'resolve', declared, { branch: task.branch_name, solo: task.workspace_kind === 'worktree', card: task.id, create });
+}
+export function checkWorkspace(board, task) {
+  if (task.workspace_kind === 'scratch') return null;
+  const facts = resolveWorkspace(task), peers = [];
+  if (task.workspace_kind === 'dir' && !facts.linked) {
+    for (const row of board.db.prepare(`SELECT t.id,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='dir'`).all()) {
+      if (row.id === task.id || normalMachine(row.machine ?? localMachine()) !== normalMachine(task.machine ?? localMachine())) continue;
+      let other;
+      try { other = resolveWorkspace({ ...row, workspace_kind: 'dir' }); } catch { continue; } // That card's own launch reports its invalid workspace.
+      if (!other.linked && other.root === facts.root) peers.push(row.id);
+    }
+  }
+  const checked = { ...facts, mainRoot: task.workspace_kind === 'dir' && !facts.linked ? facts.root : null, peers };
+  assertWorkspaceOwner(board.db, task, checked);
+  return checked;
+}
+export function assertWorkspaceOwner(db, task, checked) {
+  if (!checked?.mainRoot) return;
+  const conflict = db.prepare(`SELECT t.id,c.machine,c.workspace_root 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='dir'`).all()
+    .find(row => row.id !== task.id && normalMachine(row.machine ?? localMachine()) === normalMachine(task.machine ?? localMachine()) && (row.workspace_root === checked.mainRoot || checked.peers?.includes(row.id)));
+  if (conflict) throw new Error(`main checkout is already used by running card ${conflict.id}; declare worktree:${checked.repository} for a solo worktree`);
+}
+
+export const isLocalWorkspace = task => !task.machine || normalMachine(task.machine) === localMachine();

package/board/ztrack.mjs

@@ -130,10 +130,10 @@ class ZtrackBoard {
         const documentChanges = changes.filter(({source})=>{
           if(source.name==='tasks') {
             const before=this.rows.cachedTasks[JSON.parse(source.key)[0]];
-            if(source.row?.workspace_kind!=='scratch' && source.row?.workspace_path!==before?.workspace_path)return true;
+            if(source.row?.workspace_kind==='dir' && !this.rows.cachedCards[JSON.parse(source.key)[0]]?.workspace_anchor && source.row?.workspace_path!==before?.workspace_path)return true;
             return JSON.stringify(canonical(source.row,new Set([...RUNTIME,'status'])))!==JSON.stringify(canonical(before,new Set([...RUNTIME,'status'])));
           }
-          if(source.name==='supercode_cards')return JSON.stringify(canonical(source.row,new Set(['since','after_fired','next_run_at'])))!==JSON.stringify(canonical(this.rows.cachedCards[JSON.parse(source.key)[0]],new Set(['since','after_fired','next_run_at'])));
+          if(source.name==='supercode_cards')return JSON.stringify(canonical(source.row,new Set(['since','after_fired','next_run_at','workspace_root'])))!==JSON.stringify(canonical(this.rows.cachedCards[JSON.parse(source.key)[0]],new Set(['since','after_fired','next_run_at','workspace_root'])));
           return false;
         });
         this.publishedFingerprints = {};
@@ -242,7 +242,11 @@ class ZtrackBoard {
           this.mem.exec(`CREATE TEMP VIEW tasks AS SELECT ${fields.join(',')} FROM source.read_tasks t LEFT JOIN source.read_supercode_cards c ON c.task_id=t.id`);
           continue;
         }
-        if(native && name==='supercode_cards') {this.mem.exec('CREATE TEMP VIEW supercode_cards AS SELECT * FROM source.read_supercode_cards');continue;}
+        if(native && name==='supercode_cards') {
+          const have=new Set(this.mem.prepare('PRAGMA source.table_info(read_supercode_cards)').all().map(c=>c.name));
+          const fields=this.mem.prepare('PRAGMA main.table_info(supercode_cards)').all().map(c=>have.has(c.name)?quote(c.name):`${c.dflt_value??'NULL'} AS ${quote(c.name)}`);
+          this.mem.exec(`CREATE TEMP VIEW supercode_cards AS SELECT ${fields.join(',')} FROM source.read_supercode_cards`);continue;
+        }
         if(native && name==='task_links') {this.mem.exec("CREATE TEMP VIEW task_links AS SELECT json_extract(b.value,'$.id') parent_id,r.task_id child_id FROM source.read_supercode_cards r,json_each(r.blocked_by) b WHERE json_extract(b.value,'$.kind')='card'");continue;}
         if(name==='task_links') {
           this.mem.exec(`CREATE TEMP VIEW task_links AS SELECT json_extract(b.value,'$.id') parent_id,r.key child_id FROM source.runtime_rows r,json_each(json_extract(r.value,'$.blocked_by')) b WHERE r.name='@card_cache' AND json_extract(b.value,'$.kind')='card'`);
@@ -298,7 +302,7 @@ class ZtrackBoard {
         const keys = Object.keys(row);
         if (keys.length) this.mem.prepare(`UPDATE tasks SET ${keys.map(k => `${quote(k)}=?`).join(',')} WHERE id=?`).run(...keys.map(k => row[k]), id);
       }
-      for (const [id, row] of Object.entries(this.saved.clocks ?? {})) this.mem.prepare('UPDATE supercode_cards SET since=?,after_fired=?,next_run_at=? WHERE task_id=?').run(row.since??null,row.after_fired??null,row.next_run_at??null,id);
+      for (const [id, row] of Object.entries(this.saved.clocks ?? {})) this.mem.prepare('UPDATE supercode_cards SET since=?,after_fired=?,next_run_at=?,workspace_root=? WHERE task_id=?').run(row.since??null,row.after_fired??null,row.next_run_at??null,row.workspace_root??null,id);
       this.rows.watch(this.mem);
       if (observe) this.documentEvents();
       return;
@@ -381,8 +385,8 @@ class ZtrackBoard {
     const workspace = /^(scratch|dir|worktree)(?::(.*))?$/.exec(card.workspace ?? 'scratch');
     const task = { ...meta, ...this.saved.runtime?.[id], id, title: card.title, body: stored.body,
       status: card.status, assignee: card.assignee ?? null, created_at: meta.created_at ?? now(), priority: card.priority ?? 0,
-      workspace_kind: workspace?.[1] ?? 'scratch', workspace_path: workspace?.[1] === 'scratch' ? (this.saved.runtime?.[id]?.workspace_path ?? meta.workspace_path ?? null) : workspace?.[2] ?? null, branch_name: card.branch ?? null };
-    const state = { ...this.saved.clocks?.[id], task_id: id, stage: card.status, machine: card.machine ?? null, subtask_of: parent,
+      workspace_kind: workspace?.[1] ?? 'scratch', workspace_path: this.saved.runtime?.[id]?.workspace_path ?? (/^(\/|~|[A-Za-z]:[\\/])/.test(workspace?.[2] ?? '') ? workspace[2] : null), branch_name: card.branch ?? null };
+    const state = { ...this.saved.clocks?.[id], task_id: id, workspace_anchor: workspace?.[2] ?? null, stage: card.status, machine: card.machine ?? null, subtask_of: parent,
       blocked_by: JSON.stringify((card.relations ?? []).map((r) => ({ ...(meta.blocked_by ?? []).find((b) => b.id === nativeId(r.issueId)), id: nativeId(r.issueId), kind: /^[ma]-/.test(r.issueId) ? 'message' : 'card' }))),
       paused: card.paused ? JSON.stringify(card.paused) : null, archived: meta.archived ? 1 : 0, every: card.every ?? null };
     return { task, state };
@@ -438,7 +442,7 @@ class ZtrackBoard {
       const metadata = Object.fromEntries(Object.entries(row).filter(([k, v]) => !RUNTIME.has(k) && !CARD_MAIN.has(k) && v != null));
       if (c.archived) metadata.archived = true;
       if (json(c.blocked_by, []).length) metadata.blocked_by = json(c.blocked_by, []);
-      cards.set(row.id, { ...parsed, metadata, priority: row.priority ?? 0, workspace: row.workspace_kind + (row.workspace_kind !== 'scratch' && row.workspace_path ? `:${row.workspace_path}` : ''),
+      cards.set(row.id, { ...parsed, metadata, priority: row.priority ?? 0, workspace: row.workspace_kind + (row.workspace_kind !== 'scratch' && (c.workspace_anchor ?? row.workspace_path) ? `:${c.workspace_anchor ?? row.workspace_path}` : ''),
         branch: row.branch_name || undefined, machine: c.machine || undefined, paused: json(c.paused, null) ?? undefined, every: c.every || undefined,
         relations: json(c.blocked_by, []).map((b) => ({ type: 'blocked-by', issueId: this.fileIds.get(b.id) ?? b.id })), acceptanceCriteria: [] });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.4.111",
+  "version": "0.4.113",
   "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": {
@@ -26,7 +26,8 @@
   "dependencies": {
     "@volter/supercode-harness-sdk": "^0.3.41",
     "@volter/ztrack": "^2.4.16",
-    "yaml": "^2.9.0"
+    "yaml": "^2.9.0",
+    "@volter/supercode-teams": "^0.2.120"
   },
   "devDependencies": {
     "@chat-adapter/state-memory": "4.39.0",