@voidlabs.gg/voidshift-agents 0.5.0 → 0.6.0

package/README.md

@@ -74,9 +74,9 @@ or `vs-parked`) and the round (`vs-v1`, `vs-v2`). On Linear it posts the plan an
 one final comment, nothing in between.
 
 ```sh
-vsf agents status                  # runner, the card in progress, parked cards
+vsf agents status                  # runner, the card each workspace is on, parked cards
 vsf agents run ENG-123 [--from qa] # run one card now, in this terminal
-vsf agents start | stop | restart  # the background runner (stop cancels the card)
+vsf agents start | stop | restart  # the background runner (stop cancels its cards)
 vsf agents pause | resume          # pick up no new cards for a while
 vsf agents cancel | retry ENG-123  # stop a card, or queue a parked one again
 vsf agents runs | show ENG-123     # what happened, step by step
@@ -84,11 +84,25 @@ vsf agents logs [ENG-123] [-f]     # the runner log, or a card's step logs
 vsf agents workflows               # workflows in the order they match
 vsf agents workflow add|edit|show|rename|move|rm
 vsf agents projects | project add|edit|show|rename|rm
+vsf agents workspace add|list|rm   # folders of repos, each with its own queue
 vsf agents homes | link DIR        # where the agents are installed
 vsf agents clean                   # old worktrees and run logs
 vsf agents validate [DIR]          # check the config and agent folders
 ```
 
+Each workspace has one queue: cards in different workspaces run side by side,
+two cards in one workspace one after the other. Projects are in the `default`
+workspace until you move them:
+
+```sh
+vsf agents workspace add solvia --root ~/work/solvia   # steps carry ~/work/solvia/CONTEXT.md
+vsf agents project edit erp --workspace solvia --match DS06
+```
+
+`--match` names a tracker project (or its first word, so `DS06` matches "DS06
+Atleurope ERP"). A card of that project runs in the matching project, in any
+workspace, before the workflow's own project is considered.
+
 A workflow can also be a folder you write by hand,
 `~/.config/voidshift/agents/defs/NAME/agent.json`, with its prompt files next to
 it. Steps are the built-in ids above or your own:

package/dist/config.d.ts

@@ -52,7 +52,16 @@ export declare function describeTrigger(t: Trigger): string;
 export interface Project {
     path: string;
     base?: string;
+    workspace?: string;
+    match?: string[];
 }
+export interface Workspace {
+    root: string;
+    context?: string;
+}
+export declare const DEFAULT_WORKSPACE = "default";
+export declare const WORKSPACE_NAME: RegExp;
+export declare const workspaceOf: (project: Pick<Project, "workspace"> | undefined) => string;
 export interface WriteBack {
     labels?: boolean;
     state?: string | null;
@@ -72,6 +81,7 @@ export interface AgentsConfig {
         review?: string;
     };
     projects: Record<string, Project>;
+    workspaces: Record<string, Workspace>;
     workflows: Record<string, Workflow>;
     reviewState: string;
     timeoutMinutes: number;
@@ -104,6 +114,15 @@ export declare function agentFolders(configDir: string): string[];
 export declare function readAgentFolder(dir: string): Workflow;
 export declare function readAgentsConfig(configDir: string): AgentsConfig;
 export declare function writeAgentsConfig(configDir: string, config: AgentsConfig): void;
+export declare const workspacesInUse: (config: Pick<AgentsConfig, "projects" | "workspaces">) => string[];
+export declare function matchesProject(entry: string, projectName: string): boolean;
+export declare function resolveProject(config: Pick<AgentsConfig, 'projects'>, workflow: Pick<Workflow, 'project'>, card: {
+    projectName?: string;
+}): {
+    name: string;
+    project: Project;
+} | null;
+export declare function workspaceContext(config: Pick<AgentsConfig, 'workspaces'>, name: string): string;
 export interface ResolvedStep {
     id: string;
     label: string;

package/dist/config.js

@@ -43,6 +43,9 @@ export function describeTrigger(t) {
         return `cron ${t.schedule}`;
     return `${t.source === 'voidtrack' ? 'VoidTrack ' : ''}${t.team} + ${t.label}`;
 }
+export const DEFAULT_WORKSPACE = 'default';
+export const WORKSPACE_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+export const workspaceOf = (project) => project?.workspace || DEFAULT_WORKSPACE;
 // Step lists to start a workflow from.
 export const TEMPLATES = {
     build: { steps: ['vs-dev', 'vs-qa'], maxRounds: 3 },
@@ -53,6 +56,7 @@ export const DEFAULTS = {
     engine: 'claude',
     models: { dev: 'opus', review: 'sonnet' },
     projects: {},
+    workspaces: {},
     workflows: {},
     reviewState: 'In Review',
     timeoutMinutes: 45,
@@ -157,6 +161,45 @@ export function writeAgentsConfig(configDir, config) {
     const workflows = Object.fromEntries(Object.entries(config.workflows).filter(([name]) => !folders?.[name]));
     writeFileSync(configPath(configDir), JSON.stringify({ ...rest, workflows }, null, 2) + '\n');
 }
+// Every workspace a config uses: the named ones, then any a project names,
+// the default one included.
+export const workspacesInUse = (config) => [
+    ...new Set([...Object.keys(config.workspaces ?? {}), ...Object.values(config.projects).map(workspaceOf)]),
+];
+// Whether a match entry names a tracker project: the whole name, or its first
+// word, so "DS06" matches "DS06 Atleurope ERP". Case does not matter.
+export function matchesProject(entry, projectName) {
+    const want = entry.trim().toLowerCase();
+    const name = projectName.trim().toLowerCase();
+    return !!want && (want === name || want === name.split(/\s+/)[0]);
+}
+// The project a card runs in. Explicit matches on the card's tracker project
+// come first, in every workspace, and only then the workflow's own project.
+// A scheduled run has no tracker project, so it always takes the workflow's.
+export function resolveProject(config, workflow, card) {
+    if (card.projectName) {
+        for (const [name, project] of Object.entries(config.projects)) {
+            if (project.match?.some((m) => matchesProject(m, card.projectName)))
+                return { name, project };
+        }
+    }
+    const project = config.projects[workflow.project];
+    return project ? { name: workflow.project, project } : null;
+}
+// The workspace's context text for the step prompts: its context file, or
+// CONTEXT.md in its root. Empty when there is none.
+export function workspaceContext(config, name) {
+    const ws = config.workspaces?.[name];
+    if (!ws)
+        return '';
+    const file = ws.context ? resolve(ws.root, ws.context) : join(ws.root, 'CONTEXT.md');
+    try {
+        return readFileSync(file, 'utf8').trim();
+    }
+    catch {
+        return '';
+    }
+}
 const packDir = fileURLToPath(new URL('../pack/', import.meta.url));
 const packSkill = (name) => join(packDir, name, 'SKILL.md');
 // The file a custom step's prompt comes from: its prompt file, a pack skill,

package/dist/control.d.ts

@@ -1,5 +1,6 @@
 import { type AgentsConfig, type Tracker as Kind } from './config.ts';
 import { type Current, type RunEntry } from './state.ts';
+import { type Trackers } from './tracker.ts';
 import type { Check, ToolCommand, ToolContext } from './types.ts';
 export { parsePlistArgs } from './launchd.ts';
 export declare const trackersInUse: (config: Pick<AgentsConfig, "workflows">) => Kind[];
@@ -9,8 +10,8 @@ export declare function stampDate(stamp: string): Date;
 export declare function countRounds(steps: {
     result?: string;
 }[]): number;
-export declare const isInterrupted: (e: RunEntry, live: Current | null) => boolean;
-export declare function formatRunLine(e: RunEntry, now?: number, live?: Current | null): string;
+export declare const isInterrupted: (e: RunEntry, live: Current[]) => boolean;
+export declare function formatRunLine(e: RunEntry, now?: number, live?: Current[]): string;
 export declare function scanRunnerErrors(text: string, now: number): {
     count: number;
     last: string;
@@ -23,5 +24,16 @@ export interface CancelDeps {
     cancelCard: (card: string, label: string, source: Kind) => Promise<boolean>;
 }
 export declare function cancelCurrent(ctx: ToolContext, c: Current, deps: CancelDeps): Promise<void>;
+export declare function trackerWarnings(kinds: Kind[], trackers: Trackers): Promise<{
+    kind: Kind;
+    message: string;
+}[]>;
+export declare function workingLine(current: (Current & {
+    elapsedMinutes: number;
+}) | null): string;
+export declare function workspaceLines(workspaces: string[], running: (Current & {
+    elapsedMinutes: number;
+})[]): string[];
+export declare function pickCancel(locks: Current[], dispatcher: Current | null, card?: string): Current | string;
 export declare const controlCommands: Record<string, ToolCommand>;
 export declare function controlChecks(ctx: ToolContext): Promise<Check[]>;

package/dist/control.js

@@ -2,13 +2,13 @@ import { spawnSync } from 'node:child_process';
 import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, rmSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { parseArgs } from 'node:util';
-import { agentsDir, isCardTrigger, readAgentsConfig } from "./config.js";
-import { isPaused, listRuns, ours, clearCurrent, liveCurrent, readCurrent, setPaused, writeRun } from "./state.js";
+import { agentsDir, isCardTrigger, readAgentsConfig, workspaceOf, workspacesInUse } from "./config.js";
+import { isPaused, listRuns, ours, clearLock, liveCurrent, liveRuns, readCurrent, setPaused, workspaceLocks, writeRun } from "./state.js";
 import { runnerService } from "./service.js";
 import { TRACKERS, trackersFor } from "./tracker.js";
 import { parseFrom, resolveName, stepNames } from "./names.js";
 import { isStatusLabel } from "./workflow.js";
-import { cancelCard, tick } from "./runner.js";
+import { cancelCard, dispatch, tick } from "./runner.js";
 const HOUR = 3_600_000;
 const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
 const CARD_ID = /^[A-Za-z][A-Za-z0-9]*-\d+$/;
@@ -78,9 +78,9 @@ export function countRounds(steps) {
     }
     return rounds;
 }
-// A run that says 'running' but is not the live card was cut off.
-export const isInterrupted = (e, live) => e.record?.outcome === 'running' && !(live && (live.runDir ? live.runDir === e.dir : live.card === e.card));
-export function formatRunLine(e, now = Date.now(), live = null) {
+// A run that says 'running' but is none of the live runs was cut off.
+export const isInterrupted = (e, live) => e.record?.outcome === 'running' && !live.some((l) => (l.runDir ? l.runDir === e.dir : l.card === e.card));
+export function formatRunLine(e, now = Date.now(), live = []) {
     const r = e.record;
     if (!r)
         return `${e.card}  ${when(stampDate(e.stamp))}  older run, logs only (${plural(e.logs.length, 'log')})`;
@@ -121,14 +121,14 @@ const readLog = (configDir) => {
     }
 };
 const USAGE = {
-    status: 'status [--json]   Runner, current card, parked cards and workflows',
+    status: 'status [--json]   Runner, the card each workspace is on, parked cards and workflows',
     start: 'start   Start the background runner',
-    stop: 'stop   Stop the runner and cancel the card it is working on',
+    stop: 'stop   Stop the runner and cancel the cards it is working on',
     restart: 'restart   Stop and start the runner',
     pause: 'pause   Pick up no new cards; a card in progress carries on',
     resume: 'resume   Pick up new cards again',
     run: 'run [CARD] [--workflow W] [--from STEP]   Run now instead of waiting for the next minute',
-    cancel: 'cancel [CARD]   Stop the card being worked on and clear its labels',
+    cancel: 'cancel [CARD]   Stop a card being worked on and clear its labels',
     retry: 'retry CARD [--workflow W]   Queue a parked or cancelled card again',
     runs: 'runs [CARD] [--limit N] [--json]   Past runs, newest first',
     show: 'show CARD [--json]   Steps, outcome and labels of the latest run',
@@ -215,7 +215,7 @@ export async function cancelCurrent(ctx, c, deps) {
     }
     else
         ctx.log('Cleared a stale lock.');
-    clearCurrent(ctx.configDir);
+    clearLock(ctx.configDir, c);
 }
 const realDeps = (ctx) => ({
     ours,
@@ -230,23 +230,30 @@ const realDeps = (ctx) => ({
         }
     },
 });
-async function startCmd(ctx) {
-    if (!Object.keys(readAgentsConfig(ctx.configDir).workflows).length) {
-        ctx.log('No workflows yet. Create one first: vsf agents workflow add.');
-        return 1;
-    }
-    const trackers = trackersFor(ctx.configDir);
-    for (const kind of trackersInUse(readAgentsConfig(ctx.configDir))) {
+// One message per tracker whose key is missing or refused. The tick skips a
+// tracker it cannot open, so these warn rather than stop the runner.
+export async function trackerWarnings(kinds, trackers) {
+    const out = [];
+    for (const kind of kinds) {
         try {
             await trackers(kind).viewer();
         }
         catch (err) {
             const msg = err.message;
             const flag = kind === 'linear' ? '' : ` --${kind}`;
-            ctx.log(/^No .* API key/.test(msg) ? msg : `${TRACKERS[kind].name} did not accept the key: ${msg}. Run vsf agents key${flag}.`);
-            return 1;
+            out.push({ kind, message: /^No .* API key/.test(msg) ? msg : `${TRACKERS[kind].name} did not accept the key: ${msg}. Run vsf agents key${flag}.` });
         }
     }
+    return out;
+}
+async function startCmd(ctx) {
+    if (!Object.keys(readAgentsConfig(ctx.configDir).workflows).length) {
+        ctx.log('No workflows yet. Create one first: vsf agents workflow add.');
+        return 1;
+    }
+    for (const w of await trackerWarnings(trackersInUse(readAgentsConfig(ctx.configDir)), trackersFor(ctx.configDir))) {
+        ctx.log(`Warning: ${w.message.replace(/\.?$/, '.')} Workflows on ${TRACKERS[w.kind].name} are skipped until then.`);
+    }
     setPaused(ctx.configDir, false);
     if (!runnerService().start(ctx.home, program(ctx), logPath(ctx.configDir))) {
         ctx.log('Could not start the runner. Check vsf agents logs.');
@@ -256,13 +263,29 @@ async function startCmd(ctx) {
 }
 async function stopCmd(ctx) {
     runnerService().stop(ctx.home);
-    // Stopping the runner may have stopped the pass; finish or tidy up whatever the lock still names.
+    // Stopping the runner may have stopped its runs; finish or tidy up whatever the locks still name.
+    for (const c of workspaceLocks(ctx.configDir))
+        await cancelCurrent(ctx, c, realDeps(ctx));
     const c = readCurrent(ctx.configDir);
     if (c)
         await cancelCurrent(ctx, c, realDeps(ctx));
     ctx.log('Runner stopped.');
     return 0;
 }
+// The lock holds the round as the card's vs-vN label shows it; 0 before any round.
+export function workingLine(current) {
+    if (!current)
+        return '';
+    if (!current.card)
+        return ' Checking now.';
+    return ` Working on ${current.card}${current.title ? ` "${current.title}"` : ''} (${[current.workflow, current.step, current.round ? `round ${current.round}` : '', `${current.elapsedMinutes}m`].filter(Boolean).join(', ')}).`;
+}
+const elapsed = (c) => (c.startedAt ? Math.max(0, Math.round((Date.now() - Date.parse(c.startedAt)) / 60_000)) : 0);
+// One line per workspace: the card it is on, or idle.
+export function workspaceLines(workspaces, running) {
+    const names = [...new Set([...workspaces, ...running.map((r) => workspaceOf(r))])];
+    return names.map((ws) => `  ${ws}:${workingLine(running.find((r) => workspaceOf(r) === ws) ?? null) || ' idle.'}`);
+}
 const status = guard(async (args, ctx) => {
     const p = parse('status', args, { json: { type: 'boolean' } }, ctx);
     if (typeof p === 'number')
@@ -271,8 +294,11 @@ const status = guard(async (args, ctx) => {
     const runner = runnerState(ctx);
     const text = readLog(ctx.configDir);
     const lastTick = lastTickOf(text);
-    const live = liveCurrent(ctx.configDir);
-    const current = live ? { ...live, checking: !live.card, elapsedMinutes: live.startedAt ? Math.max(0, Math.round((Date.now() - Date.parse(live.startedAt)) / 60_000)) : 0 } : null;
+    const live = liveRuns(ctx.configDir);
+    const running = live.map((c) => ({ ...c, workspace: workspaceOf(c), elapsedMinutes: elapsed(c) }));
+    const dispatcher = liveCurrent(ctx.configDir);
+    // The first run, or the dispatcher checking for work, for dashboards that know one run only.
+    const current = running.length ? { ...running[0], checking: false } : dispatcher ? { ...dispatcher, checking: true, elapsedMinutes: elapsed(dispatcher) } : null;
     const seen = new Set();
     const parked = [];
     const interrupted = [];
@@ -288,20 +314,22 @@ const status = guard(async (args, ctx) => {
     const workflows = Object.keys(config.workflows).length;
     const projects = Object.keys(config.projects).length;
     if (p.values.json) {
-        ctx.log(JSON.stringify({ engine: config.engine, runner, lastTick, current, parked, interrupted, workflows, projects }, null, 2));
+        ctx.log(JSON.stringify({ engine: config.engine, runner, lastTick, current, running, parked, interrupted, workflows, projects }, null, 2));
         return 0;
     }
-    const working = current && !current.card
-        ? ' Checking now.'
-        : current
-            ? ` Working on ${current.card ?? 'a card'}${current.title ? ` "${current.title}"` : ''} (${[current.workflow, current.step, current.round !== undefined ? `round ${current.round + 1}` : '', `${current.elapsedMinutes}m`].filter(Boolean).join(', ')}).`
-            : '';
+    // One workspace keeps the single line; several get a line each.
+    const workspaces = workspacesInUse(config);
+    const perWorkspace = runner !== 'stopped' && (workspaces.length > 1 || running.some((r) => !workspaces.includes(r.workspace)));
+    const working = perWorkspace ? '' : workingLine(current);
     if (runner === 'running')
         ctx.log(`Runner: running.${working}`);
     else if (runner === 'paused')
         ctx.log(`Runner: paused, picks up no new cards. vsf agents resume to continue.${working}`);
     else
         ctx.log('Runner: stopped. vsf agents start to begin.');
+    if (perWorkspace)
+        for (const line of workspaceLines(workspaces, running))
+            ctx.log(line);
     if (lastTick)
         ctx.log(`Last check: ${clock(new Date(lastTick.at))}, ${lastTick.line.replace(/\.$/, '') || 'no details'}.`);
     for (const card of interrupted)
@@ -388,6 +416,20 @@ const run = guard(async (args, ctx) => {
     }
     return code;
 });
+// The lock a cancel ends, or why there is none. Every run's lock counts, stale
+// ones included, so a dead run can be tidied up; with none, the dispatcher's
+// own lock, a check in progress. Without a card it must be the only one.
+export function pickCancel(locks, dispatcher, card) {
+    const all = locks.length ? locks : dispatcher ? [dispatcher] : [];
+    if (!all.length)
+        return card ? `${card} is not running.` : 'Nothing is running.';
+    const name = (l) => `${l.card ?? 'a check'}${l.workspace ? ` in ${l.workspace}` : ''}`;
+    if (card)
+        return all.find((l) => l.card === card) ?? `${card} is not running. Running: ${all.map(name).join(', ')}.`;
+    if (all.length > 1)
+        return `More than one card is running: ${all.map(name).join(', ')}. Name one: vsf agents cancel CARD.`;
+    return all[0];
+}
 const cancel = guard(async (args, ctx) => {
     const p = parse('cancel', args, {}, ctx);
     if (typeof p === 'number')
@@ -395,16 +437,12 @@ const cancel = guard(async (args, ctx) => {
     const card = p.positionals[0]?.toUpperCase();
     if (p.positionals.length > 1 || (card && !CARD_ID.test(card)))
         return usageError('cancel', ctx, 'Give one card id like ENG-12.');
-    const c = readCurrent(ctx.configDir);
-    if (!c) {
-        ctx.log(card ? `${card} is not running.` : 'Nothing is running.');
-        return card ? 1 : 0;
+    const found = pickCancel(workspaceLocks(ctx.configDir), readCurrent(ctx.configDir), card);
+    if (typeof found === 'string') {
+        ctx.log(found);
+        return found.startsWith('More than one') ? 2 : card ? 1 : 0;
     }
-    if (card && c.card !== card) {
-        ctx.log(`${c.card ?? 'Another card'} is running, not ${card}.`);
-        return 1;
-    }
-    await cancelCurrent(ctx, c, realDeps(ctx));
+    await cancelCurrent(ctx, found, realDeps(ctx));
     return 0;
 });
 const retry = guard(async (args, ctx) => {
@@ -414,7 +452,7 @@ const retry = guard(async (args, ctx) => {
     const id = p.positionals[0]?.toUpperCase();
     if (p.positionals.length !== 1 || !CARD_ID.test(id))
         return usageError('retry', ctx, 'Give one card id like ENG-12.');
-    if (liveCurrent(ctx.configDir)?.card === id) {
+    if (liveRuns(ctx.configDir).some((c) => c.card === id)) {
         ctx.log(`${id} is running now. vsf agents cancel ${id} first.`);
         return 1;
     }
@@ -484,7 +522,7 @@ const runs = guard(async (args, ctx) => {
     }
     if (!entries.length)
         ctx.log('No runs yet.');
-    const live = liveCurrent(ctx.configDir);
+    const live = liveRuns(ctx.configDir);
     for (const e of entries)
         ctx.log(formatRunLine(e, Date.now(), live));
     return 0;
@@ -518,7 +556,7 @@ const show = guard(async (args, ctx) => {
         return 0;
     }
     ctx.log(`${latest.card}  ${latest.title}`);
-    ctx.log(`Workflow ${latest.workflow}, ${isInterrupted(all[0], liveCurrent(ctx.configDir)) ? 'interrupted' : latest.outcome}${latest.prUrl ? `, PR ${latest.prUrl}` : ''}`);
+    ctx.log(`Workflow ${latest.workflow}, ${isInterrupted(all[0], liveRuns(ctx.configDir)) ? 'interrupted' : latest.outcome}${latest.prUrl ? `, PR ${latest.prUrl}` : ''}`);
     if (labels)
         ctx.log(`Labels: ${labels.join(', ') || 'none'}`);
     for (const s of latest.steps) {
@@ -634,10 +672,10 @@ const clean = guard(async (args, ctx) => {
     if (ms === null)
         return usageError('clean', ctx, `${age} is not an age. Use a number of days or hours, like 14d or 36h.`);
     const cutoff = Date.now() - ms;
-    const live = liveCurrent(ctx.configDir);
+    const live = new Set(liveRuns(ctx.configDir).map((c) => c.card));
     const wtRoot = join(agentsDir(ctx.configDir), 'worktrees');
     const worktrees = (existsSync(wtRoot) ? readdirSync(wtRoot) : [])
-        .filter((card) => card !== live?.card)
+        .filter((card) => !live.has(card))
         .filter((card) => {
         const record = listRuns(ctx.configDir, card)[0]?.record;
         const ended = record?.endedAt ? Date.parse(record.endedAt) : mtime(join(wtRoot, card));
@@ -645,7 +683,7 @@ const clean = guard(async (args, ctx) => {
     })
         .map((card) => join(wtRoot, card));
     const old = listRuns(ctx.configDir).filter((e) => {
-        if (e.record?.outcome === 'running' && e.card === live?.card)
+        if (e.record?.outcome === 'running' && live.has(e.card))
             return false;
         return (e.record?.endedAt ? Date.parse(e.record.endedAt) : mtime(e.dir)) < cutoff;
     });
@@ -675,12 +713,17 @@ const clean = guard(async (args, ctx) => {
     ctx.log(`Removed ${plural(worktrees.length, 'worktree')} and ${plural(old.length, 'run')}.`);
     return 0;
 });
-// Internal: the runner (launchd or systemd) runs this every minute.
-const tickCmd = async (_args, ctx) => {
+// Internal: the runner (launchd or systemd) runs this every minute, and it
+// starts itself with --card or --schedule for each run, one per workspace.
+const tickCmd = async (args, ctx) => {
     const stamped = (l) => ctx.log(`${new Date().toISOString()} ${l}`);
     try {
+        const { values } = parseArgs({ args, options: { card: { type: 'string' }, workflow: { type: 'string' }, schedule: { type: 'string' } }, strict: true });
         const config = readAgentsConfig(ctx.configDir);
-        return await tick({ configDir: ctx.configDir, config, trackers: trackersFor(ctx.configDir), log: stamped, selfCommand: ctx.selfCommand });
+        const rc = { configDir: ctx.configDir, config, trackers: trackersFor(ctx.configDir), log: stamped, selfCommand: ctx.selfCommand };
+        if (values.card || values.workflow)
+            return await tick(rc, values.card?.toUpperCase(), { workflow: values.workflow, schedule: values.schedule, child: true });
+        return await dispatch(rc, { reload: () => readAgentsConfig(ctx.configDir) });
     }
     catch (err) {
         stamped(`Could not run the check: ${err.message}`);
@@ -723,8 +766,8 @@ export async function controlChecks(ctx) {
             ? { name: 'runner program', status: 'fail', detail: `runner points at a missing ${missing[0]}`, fix: 'vsf agents restart' }
             : { name: 'runner program', status: 'ok', detail: 'found' });
     }
-    const c = readCurrent(ctx.configDir);
-    if (c && !ours(c.pid))
+    const locks = [readCurrent(ctx.configDir), ...workspaceLocks(ctx.configDir)];
+    if (locks.some((c) => c && !ours(c.pid)))
         checks.push({ name: 'stale lock', status: 'warn', detail: 'a stale lock from a run that died', fix: 'vsf agents cancel' });
     if (existsSync(logPath(ctx.configDir))) {
         const { count, last } = scanRunnerErrors(readLog(ctx.configDir), Date.now());