@voidlabs.gg/voidshift-agents 0.4.3 → 0.4.5

package/dist/runner.js

@@ -1,14 +1,14 @@
-import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
 import { basename, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { LABELS, PLAN_HEADING, buildPrompt, findingsFor, fixTarget, isStatusLabel, latestPlan, parseDevResult, parseVerdict, planBody, qaPassed, stageLabels, verdictBlock, } from "./workflow.js";
-import { STEPS, agentsDir, hasWork, isProducer } from "./config.js";
+import { agentsDir, hasWork, isCardTrigger, resolveStep, stepId, stepIdLabel } from "./config.js";
+import { lastDue, parseCron } from "./cron.js";
 import { runAgent, stopAgents } from "./engine.js";
-import { commitsAhead, defaultBranch, ensureDraftPr, ensureWorktree, headSha, markReady, push, resetWorktree, waitForChecks, waitForPrHead } from "./git.js";
+import { commitsAhead, enforceCommitPolicy, defaultBranch, ensureDraftPr, ensureWorktree, headSha, markReady, push, resetWorktree, waitForChecks, waitForPrHead } from "./git.js";
+import { noTracker } from "./tracker.js";
 import { recall, vaultPath } from "./memory.js";
-import { bootTime, clearCurrent, isPaused, ours, readCurrent, readPending, writeCurrent, writePending, writeRun } from "./state.js";
-const packDir = fileURLToPath(new URL('../pack/', import.meta.url));
-const skill = (name) => readFileSync(join(packDir, name, 'SKILL.md'), 'utf8');
+import { claudeSettingsFile, readRules, rulesSection } from "./profile.js";
+import { bootTime, clearCurrent, isPaused, ours, readCurrent, readPending, writeCurrent, writePending, writeRun, readCronState, writeCronState } from "./state.js";
 const stamp = () => new Date().toISOString().replace(/[:.]/g, '-');
 class Park extends Error {
 }
@@ -18,7 +18,7 @@ function withLabels(card, drop, add) {
 const UNATTENDED = `# Running unattended
 
 You are one step in a workflow. Nobody can answer questions and the
-Linear connection is not available: the card and any plan are included above.
+tracker connection is not available: the card and any plan are included above.
 Do not write plan files; return your output as your final message. Make the
 call the code supports and state it.`;
 // Agents keep the memory vault the way you do: durable learnings become notes.
@@ -35,29 +35,37 @@ export function summarize(output) {
 }
 // The run in progress, so a cancel signal can mark it.
 let active = null;
-const isVerdict = (s) => STEPS[s].output === 'verdict';
+const isVerdict = (d) => d.output === 'verdict';
+const isProducer = (d) => d.output === 'plan' || d.output === 'commits';
+// The card label for a step: its own for a built-in step, a generic one otherwise.
+const stageOf = (d) => LABELS.stage[d.builtin ?? ''] ?? LABELS.working;
 // One card through a trigger's workflow. Steps run in order. A failed check (or a
 // run of consecutive checks) sends its findings back to the nearest earlier
 // step that produces something, Plan or Dev, and the workflow continues from
 // there, until everything passes or the loop cap parks the card.
 export async function runCard(card, trigger, workflowName, workflow, project, rc, opts = {}) {
-    const { linear, config, log } = rc;
+    const { config, log } = rc;
+    // A scheduled run has no card, so it has nothing to write back to.
+    const linear = isCardTrigger(trigger) ? rc.trackers(trigger.source) : noTracker;
+    const label = isCardTrigger(trigger) ? trigger.label : '';
     const runDir = join(agentsDir(rc.configDir), 'runs', card.identifier, stamp());
     mkdirSync(runDir, { recursive: true });
     const say = (line) => log(`${card.identifier} ${line}`);
-    const steps = workflow.steps;
+    // Write back settings apply to card runs; a scheduled run has nothing to write to.
+    const writeBack = isCardTrigger(trigger) ? (workflow.writeBack ?? {}) : {};
+    const labelsOn = writeBack.labels !== false;
     const startedAt = new Date().toISOString();
-    const record = { card: card.identifier, title: card.title, url: card.url, workflow: workflowName, trigger: trigger.label, steps: [], outcome: 'running', startedAt };
+    const record = { card: card.identifier, title: card.title, url: card.url || undefined, workflow: workflowName, trigger: label || (trigger.source === 'cron' ? trigger.schedule : ''), source: trigger.source, steps: [], outcome: 'running', startedAt };
     active = { record, runDir };
     const save = () => writeRun(runDir, record);
     save();
     let loops = 0;
     // The lock tells status and cancel what is running.
-    const mark = (step) => writeCurrent(rc.configDir, { pid: process.pid, card: card.identifier, title: card.title, workflow: workflowName, step, round: loops, startedAt, runDir });
-    // Written before the first Linear call, so a cancel always knows the card.
+    const mark = (step) => writeCurrent(rc.configDir, { pid: process.pid, card: card.identifier, title: card.title, workflow: workflowName, step, round: loops, startedAt, runDir, source: trigger.source });
+    // Written before the first tracker call, so a cancel always knows the card.
     mark('Starting');
-    const begin = (step) => {
-        const rec = { step, label: STEPS[step].label, startedAt: new Date().toISOString() };
+    const begin = (def) => {
+        const rec = { step: def.id, label: def.label, startedAt: new Date().toISOString() };
         record.steps.push(rec);
         mark(rec.label);
         save();
@@ -84,8 +92,14 @@ export async function runCard(card, trigger, workflowName, workflow, project, rc
     const setRound = (n) => {
         loops = n;
     };
-    const stage = (name, round) => linear.setLabels(card, stageLabels(card.labels, trigger.label, name, round));
-    // Linear hears from the runner twice: the plan once it has passed review,
+    const stage = async (name, round) => {
+        if (labelsOn)
+            await linear.setLabels(card, stageLabels(card.labels, label, name, round));
+    };
+    // How a run ends on the card: a stage label, or with labels off only the
+    // trigger taken away so the card is not picked up again.
+    const endLabels = (name, round) => linear.setLabels(card, labelsOn ? stageLabels(card.labels, label, name, round) : card.labels.filter((l) => l !== label));
+    // The tracker hears from the runner twice: the plan once it has passed review,
     // and one final comment. Findings stay here until the final one.
     let lastFindings = '';
     let planToPost = null;
@@ -97,38 +111,52 @@ export async function runCard(card, trigger, workflowName, workflow, project, rc
     };
     async function park(reason) {
         say(`parked: ${reason}`);
-        const comment = `**Parked:** ${reason}${lastFindings ? `\n\n${lastFindings}` : ''}\n\nFix the cause, then add \`${trigger.label}\` again to retry.`;
-        const add = [LABELS.parked, ...(loops ? [LABELS.version(loops)] : [])];
+        const comment = `**Parked:** ${reason}${lastFindings ? `\n\n${lastFindings}` : ''}\n\nFix the cause, then add \`${label}\` again to retry.`;
+        const add = labelsOn ? [LABELS.parked, ...(loops ? [LABELS.version(loops)] : [])] : [];
         let commented = false;
         try {
             await postPlan();
             await linear.comment(card, comment);
             commented = true;
-            await linear.setLabels(card, stageLabels(card.labels, trigger.label, LABELS.parked, loops || undefined));
+            await endLabels(LABELS.parked, loops || undefined);
         }
         catch (err) {
-            say(`could not reach Linear to park it (${err.message}). Will retry next minute.`);
+            if (!isCardTrigger(trigger))
+                return done('parked', reason);
+            say(`could not reach ${trigger.source === 'voidtrack' ? 'VoidTrack' : 'Linear'} to park it (${err.message}). Will retry next minute.`);
             // An empty comment is skipped on retry, so it is not posted twice.
-            writePending(rc.configDir, [...readPending(rc.configDir), { card: card.identifier, comment: commented ? '' : comment, drop: [trigger.label], add, dropStatus: true }]);
+            writePending(rc.configDir, [...readPending(rc.configDir), { card: card.identifier, comment: commented ? '' : comment, drop: [label], add, dropStatus: labelsOn, source: trigger.source }]);
         }
         return done('parked', reason);
     }
     try {
         if (!existsSync(join(project.path, '.git')))
             throw new Park(`The project folder ${project.path} is not a git repository on this Mac.`);
-        const from = opts.from ? steps.indexOf(opts.from) : 0;
+        const steps = workflow.steps.map((s) => resolveStep(s, config, config.folders?.[workflowName]));
+        const from = opts.from ? steps.findIndex((d) => d.id === opts.from) : 0;
         if (from < 0)
-            throw new Park(`Workflow ${workflowName} has no ${STEPS[opts.from].label} step.`);
-        let plan = latestPlan(await linear.comments(card.identifier));
-        const firstPlan = steps.indexOf('vs-plan', from);
-        const needsPlan = steps.findIndex((s, n) => n >= from && (s === 'vs-dev' || s === 'vs-plan-review'));
+            throw new Park(`Workflow ${workflowName} has no ${stepIdLabel(opts.from)} step.`);
+        // A scheduled run has no card to plan on, so its task is the plan unless a Plan step writes one.
+        let plan = isCardTrigger(trigger) ? latestPlan(await linear.comments(card.identifier)) : card.description ?? null;
+        const firstPlan = steps.findIndex((d, n) => n >= from && d.output === 'plan');
+        // A check before any commits is a check on the plan, like Plan review.
+        const needsPlan = steps.findIndex((d, n) => n >= from && (d.output === 'commits' || (d.output === 'verdict' && d.builtin !== 'vs-qa')));
         if (!plan && needsPlan >= 0 && (firstPlan < 0 || firstPlan > needsPlan)) {
             throw new Park('No plan comment (starting with "## Plan") was found. Publish a plan first, or start the workflow with Plan.');
         }
-        await stage(LABELS.stage[steps[from]]);
+        await stage(stageOf(steps[from]));
         const base = project.base || defaultBranch(project.path);
         const vault = vaultPath(rc.configDir);
-        const known = [recall(rc.selfCommand, rc.configDir, `${workflow.project} ${card.title}\n${card.description ?? ''}`), vault ? memoryNote(vault) : ''].filter(Boolean).join('\n\n');
+        // Your profile rides along on every step: rules in the prompt, Claude settings as a file.
+        let settingsFile;
+        try {
+            settingsFile = claudeSettingsFile(rc.configDir, runDir);
+        }
+        catch (err) {
+            throw new Park(`Your agent profile's Claude settings are broken: ${err.message}`);
+        }
+        const rules = rulesSection(readRules(rc.configDir));
+        const known = [recall(rc.selfCommand, rc.configDir, `${workflow.project} ${card.title}\n${card.description ?? ''}`), vault ? memoryNote(vault) : '', rules].filter(Boolean).join('\n\n');
         const worktree = join(agentsDir(rc.configDir), 'worktrees', card.identifier);
         ensureWorktree(project.path, worktree, card.branchName, base);
         say(`working in ${worktree} on ${card.branchName}`);
@@ -137,13 +165,12 @@ export async function runCard(card, trigger, workflowName, workflow, project, rc
         let prUrl = '';
         let logs = 0;
         const planText = () => plan ?? '(No plan was posted on this card. Check the work against the card itself.)';
-        const timeoutMs = config.timeoutMinutes * 60_000;
         const logFile = (name) => join(runDir, `${String(logs++).padStart(2, '0')}-${name}.log`);
-        async function check(step, round) {
-            const label = STEPS[step].label;
-            const rec = begin(step);
+        async function check(def, round) {
+            const label = def.label;
+            const rec = begin(def);
             let ciNote = '';
-            if (step === 'vs-qa') {
+            if (def.builtin === 'vs-qa') {
                 if (commitsAhead(worktree, base) === 0) {
                     end(rec, 'SKIP', 'No changes on the branch yet.');
                     return { step: label, verdict: 'SKIP', report: 'No changes on the branch yet.' };
@@ -171,12 +198,12 @@ export async function runCard(card, trigger, workflowName, workflow, project, rc
                     ciNote = ci.verdict === 'SHIP' ? '# CI\n\nCI passed on this branch.' : '# CI\n\nThis repo has no CI checks.';
                 }
             }
-            const log = logFile(step);
+            const log = logFile(def.id);
             const r = await runAgent({
-                engine: config.engine, model: config.models.review, cwd: worktree, vault, write: step === 'vs-qa', logFile: log, timeoutMs,
-                prompt: buildPrompt({ skill: skill(step), card, plan: planText(), base, round, extra: [known, ciNote, UNATTENDED].filter(Boolean).join('\n\n') }),
+                engine: def.engine, model: def.model, cwd: worktree, vault, settingsFile, write: def.write, logFile: log, timeoutMs: def.timeoutMs,
+                prompt: buildPrompt({ skill: def.prompt(), card, plan: planText(), base, round, extra: [known, ciNote, UNATTENDED].filter(Boolean).join('\n\n') }),
             });
-            if (step === 'vs-qa')
+            if (def.builtin === 'vs-qa')
                 resetWorktree(worktree);
             const verdict = parseVerdict(r.output);
             end(rec, verdict, r.output, log);
@@ -184,18 +211,18 @@ export async function runCard(card, trigger, workflowName, workflow, project, rc
         }
         let i = from;
         while (i < steps.length) {
-            const step = steps[i];
-            say(`${STEPS[step].label}`);
-            if (isVerdict(step)) {
+            const def = steps[i];
+            say(def.label);
+            if (isVerdict(def)) {
                 const [start, end] = verdictBlock(steps, i, isVerdict);
                 const target = fixTarget(steps, start, isProducer);
                 const producer = target >= 0 ? steps[target] : undefined;
                 // The round being checked: how many times its producer has run.
-                const round = Math.max(producer === 'vs-plan' ? runs.plan : runs.dev, 1);
+                const round = Math.max(producer?.output === 'plan' ? runs.plan : runs.dev, 1);
                 setRound(round);
                 const results = [];
                 for (const s of steps.slice(start, end)) {
-                    await stage(LABELS.stage[s], round);
+                    await stage(stageOf(s), round);
                     results.push(await check(s, round));
                 }
                 if (qaPassed(results)) {
@@ -207,26 +234,26 @@ export async function runCard(card, trigger, workflowName, workflow, project, rc
                 if (target < 0) {
                     await postPlan();
                     await linear.comment(card, `**Changes needed.**\n\n${notes}`);
-                    await linear.setLabels(card, stageLabels(card.labels, trigger.label, LABELS.changes, round));
+                    await endLabels(LABELS.changes, round);
                     say('changes requested');
                     return done('changes');
                 }
                 // Rounds caps how many times Plan or Dev runs, counting the first.
                 if (round >= workflow.maxRounds) {
-                    throw new Park(`Checks still failed after ${round} ${producer === 'vs-plan' ? 'plan' : 'dev'} rounds.${prUrl ? ` PR: ${prUrl}` : ''}`);
+                    throw new Park(`Checks still failed after ${round} ${producer?.output === 'plan' ? 'plan' : 'dev'} rounds.${prUrl ? ` PR: ${prUrl}` : ''}`);
                 }
                 findings.set(target, notes);
                 i = target;
                 continue;
             }
-            if (step === 'vs-plan') {
+            if (def.output === 'plan') {
                 setRound(runs.plan + 1);
-                await stage(LABELS.stage[step], runs.plan + 1);
-                const rec = begin(step);
-                const log = logFile('plan');
+                await stage(stageOf(def), runs.plan + 1);
+                const rec = begin(def);
+                const log = logFile(def.builtin ? 'plan' : def.id);
                 const r = await runAgent({
-                    engine: config.engine, model: config.models.dev, cwd: worktree, vault, write: false, logFile: log, timeoutMs,
-                    prompt: buildPrompt({ skill: skill('vs-plan'), card, plan: plan ?? '(none yet, you are writing it)', base, round: runs.plan + 1, findings: findings.get(i), extra: [known, UNATTENDED].filter(Boolean).join('\n\n') }),
+                    engine: def.engine, model: def.model, cwd: worktree, vault, settingsFile, write: def.write, logFile: log, timeoutMs: def.timeoutMs,
+                    prompt: buildPrompt({ skill: def.prompt(), card, plan: plan ?? '(none yet, you are writing it)', base, round: runs.plan + 1, findings: findings.get(i), extra: [known, UNATTENDED].filter(Boolean).join('\n\n') }),
                 });
                 const result = parseDevResult(r.output);
                 end(rec, result.status === 'blocked' ? 'blocked' : 'done', r.output, log);
@@ -236,22 +263,22 @@ export async function runCard(card, trigger, workflowName, workflow, project, rc
                 planToPost = plan;
                 runs.plan++;
             }
-            else if (step === 'vs-publish') {
+            else if (def.output === 'publish') {
                 await postPlan();
-                const rec = begin(step);
+                const rec = begin(def);
                 push(worktree, card.branchName);
                 end(rec, 'pushed');
             }
-            else if (step === 'vs-dev') {
+            else if (def.output === 'commits') {
                 await postPlan();
                 setRound(runs.dev + 1);
-                await stage(LABELS.stage[step], runs.dev + 1);
-                const rec = begin(step);
-                const log = logFile('dev');
+                await stage(stageOf(def), runs.dev + 1);
+                const rec = begin(def);
+                const log = logFile(def.builtin ? 'dev' : def.id);
                 const before = headSha(worktree);
                 const dev = await runAgent({
-                    engine: config.engine, model: config.models.dev, cwd: worktree, vault, write: true, logFile: log, timeoutMs,
-                    prompt: buildPrompt({ skill: skill('vs-dev'), card, plan: planText(), base, round: runs.dev + 1, findings: findings.get(i), extra: [known, UNATTENDED].filter(Boolean).join('\n\n') }),
+                    engine: def.engine, model: def.model, cwd: worktree, vault, settingsFile, write: def.write, logFile: log, timeoutMs: def.timeoutMs,
+                    prompt: buildPrompt({ skill: def.prompt(), card, plan: planText(), base, round: runs.dev + 1, findings: findings.get(i), extra: [known, UNATTENDED].filter(Boolean).join('\n\n') }),
                 });
                 const result = parseDevResult(dev.output);
                 end(rec, result.status === 'blocked' ? 'blocked' : 'done', dev.output, log);
@@ -263,23 +290,42 @@ export async function runCard(card, trigger, workflowName, workflow, project, rc
                 // just check the same commit again.
                 if (runs.dev > 0 && headSha(worktree) === before)
                     throw new Park('The dev agent made no new commits this round.');
+                // Only this round's commits, which are not pushed yet.
+                const fixed = enforceCommitPolicy(worktree, before, config.commits ?? {});
+                if (fixed)
+                    say(`applied the commit policy to ${fixed} commit${fixed === 1 ? '' : 's'}`);
                 push(worktree, card.branchName);
                 prUrl = ensureDraftPr(worktree, card.branchName, base, `${card.identifier}: ${card.title}`, card.url);
                 record.prUrl = prUrl;
                 save();
                 runs.dev++;
             }
+            else {
+                // A step with no output the workflow reads: it runs once and must finish.
+                await stage(stageOf(def), loops || undefined);
+                const rec = begin(def);
+                const log = logFile(def.id);
+                const r = await runAgent({
+                    engine: def.engine, model: def.model, cwd: worktree, vault, settingsFile, write: def.write, logFile: log, timeoutMs: def.timeoutMs,
+                    prompt: buildPrompt({ skill: def.prompt(), card, plan: plan ?? '(none)', base, round: loops || 1, extra: [known, UNATTENDED].filter(Boolean).join('\n\n') }),
+                });
+                end(rec, r.ok ? 'done' : 'failed', r.output, log);
+                if (!r.ok)
+                    throw new Park(`The ${def.label} step failed or timed out.`);
+            }
             findings.delete(i);
             i++;
         }
         await postPlan();
-        let moved = false;
-        if (hasWork(workflow)) {
+        // Unset moves a card with commits to reviewState; a state always moves it; null never does.
+        const state = writeBack.state === undefined ? (hasWork(workflow) ? config.reviewState : null) : writeBack.state;
+        if (hasWork(workflow))
             markReady(worktree, card.branchName);
-            moved = await linear.moveTo(card, config.reviewState);
+        const moved = state ? await linear.moveTo(card, state) : true;
+        await endLabels(LABELS.verified, loops || undefined);
+        if (writeBack.comment !== false) {
+            await linear.comment(card, `**All checks passed.**${prUrl ? ` PR ready: ${prUrl}` : ''}${!moved ? `\n\n(No "${state}" state on this team, so the card was not moved.)` : ''}`);
         }
-        await linear.setLabels(card, stageLabels(card.labels, trigger.label, LABELS.verified, loops || undefined));
-        await linear.comment(card, `**All checks passed.**${prUrl ? ` PR ready: ${prUrl}` : ''}${hasWork(workflow) && !moved ? `\n\n(No "${config.reviewState}" state on this team, so the card was not moved.)` : ''}`);
         say('verified');
         return done('verified');
     }
@@ -292,34 +338,107 @@ export async function runCard(card, trigger, workflowName, workflow, project, rc
         active = null;
     }
 }
-// The first card waiting on any workflow's triggers, in workflow order.
-// With a workflow name, only that workflow is considered.
-export async function nextJob(rc, only, workflowName) {
-    const pinned = only ? await rc.linear.card(only) : null;
-    for (const [name, workflow] of Object.entries(rc.config.workflows)) {
-        if (workflowName && name !== workflowName)
-            continue;
-        for (const trigger of workflow.triggers) {
-            const cards = pinned ? [pinned] : await rc.linear.myCardsWithLabel(trigger.label);
-            // A pinned card may have lost its label (a parked card re-run by hand), so match by team.
-            const card = cards.find((c) => c.teamKey === trigger.team && (pinned || c.labels.includes(trigger.label)));
-            if (card)
-                return { card, trigger, workflow: name };
+// A scheduled run's stand-in for a card: the task, on a branch of its own.
+export function cronCard(workflow, task, at) {
+    const stamp = at.toISOString().slice(0, 16).replace(/[-:T]/g, '');
+    const slug = workflow.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'cron';
+    return {
+        id: '',
+        identifier: `${slug.replace(/-/g, '').toUpperCase()}-${stamp}`,
+        title: task.split('\n')[0].slice(0, 80),
+        description: task,
+        url: '',
+        branchName: `vs/${slug}-${stamp}`,
+        teamId: '',
+        teamKey: '',
+        labels: [],
+    };
+}
+const cronKey = (workflow, schedule) => `${workflow} ${schedule}`;
+// The first job waiting on any workflow's triggers, in workflow order: a card
+// carrying a trigger label, or a schedule that came due since it last fired.
+// A schedule seen for the first time starts counting from now. With a card,
+// only that card is considered; with a workflow name, only that workflow, and
+// `force` fires its schedule now.
+export async function nextJob(rc, only, workflowName, opts = {}) {
+    const now = opts.now ?? new Date();
+    const workflows = Object.entries(rc.config.workflows).filter(([name]) => !workflowName || name === workflowName);
+    let pinned = null;
+    if (only) {
+        const team = only.split('-')[0].toUpperCase();
+        const sources = [...new Set(workflows.flatMap(([, w]) => w.triggers.filter(isCardTrigger).filter((t) => t.team === team).map((t) => t.source)))];
+        for (const source of sources) {
+            try {
+                pinned = { card: await rc.trackers(source).card(only), source };
+                break;
+            }
+            catch (err) {
+                if (source === sources.at(-1))
+                    throw err;
+            }
         }
+        if (!pinned)
+            return null;
+    }
+    const cron = readCronState(rc.configDir);
+    let cronChanged = false;
+    try {
+        for (const [name, workflow] of workflows) {
+            for (const trigger of workflow.triggers) {
+                if (!isCardTrigger(trigger)) {
+                    const schedule = only ? null : parseCron(trigger.schedule);
+                    if (!schedule)
+                        continue;
+                    const key = cronKey(name, trigger.schedule);
+                    const last = cron[key];
+                    const due = opts.force ? now : last ? lastDue(schedule, new Date(last), now) : null;
+                    if (!last || due) {
+                        cron[key] = now.toISOString();
+                        cronChanged = true;
+                    }
+                    if (due)
+                        return { card: cronCard(name, trigger.task, due), trigger, workflow: name };
+                    continue;
+                }
+                // A pinned card may have lost its label (a parked card re-run by hand), so match by team.
+                if (pinned) {
+                    if (pinned.source === trigger.source && pinned.card.teamKey === trigger.team)
+                        return { card: pinned.card, trigger, workflow: name };
+                    continue;
+                }
+                let cards;
+                try {
+                    cards = await rc.trackers(trigger.source).myCardsWithLabel(trigger.label, trigger.team);
+                }
+                catch (err) {
+                    // One tracker being down or unset must not stop the others.
+                    rc.log(`Could not check ${trigger.source === 'voidtrack' ? 'VoidTrack' : 'Linear'} for ${trigger.team} + ${trigger.label} (${err.message}). Trying again next minute.`);
+                    continue;
+                }
+                const card = cards.find((c) => c.teamKey === trigger.team && c.labels.includes(trigger.label));
+                if (card)
+                    return { card, trigger, workflow: name };
+            }
+        }
+        return null;
+    }
+    finally {
+        if (cronChanged)
+            writeCronState(rc.configDir, cron);
     }
-    return null;
 }
-// Retries Linear writes that failed while parking. Never throws.
+// Retries tracker writes that failed while parking. Never throws.
 async function flushPending(rc) {
     const left = [];
     for (const p of readPending(rc.configDir)) {
         try {
-            const card = await rc.linear.card(p.card);
+            const tracker = rc.trackers(p.source ?? 'linear');
+            const card = await tracker.card(p.card);
             if (p.comment) {
-                await rc.linear.comment(card, p.comment);
+                await tracker.comment(card, p.comment);
                 p.comment = '';
             }
-            await rc.linear.setLabels(card, withLabels(card, (l) => p.drop.includes(l) || (!!p.dropStatus && isStatusLabel(l)), p.add));
+            await tracker.setLabels(card, withLabels(card, (l) => p.drop.includes(l) || (!!p.dropStatus && isStatusLabel(l)), p.add));
         }
         catch {
             left.push(p);
@@ -332,27 +451,27 @@ async function flushPending(rc) {
         // nothing more to do
     }
 }
-// Takes the working label off a cancelled card and says so. When Linear
+// Takes the working label off a cancelled card and says so. When the tracker
 // cannot be reached the same change is queued for the next tick.
-export async function cancelCard(linear, configDir, cardId, label) {
+export async function cancelCard(tracker, configDir, cardId, label, source = 'linear') {
     const comment = `**Cancelled.** Add \`${label}\` again to restart.`;
     try {
-        const card = await linear.card(cardId);
-        await linear.setLabels(card, withLabels(card, isStatusLabel, []));
-        await linear.comment(card, comment);
+        const card = await tracker.card(cardId);
+        await tracker.setLabels(card, withLabels(card, isStatusLabel, []));
+        await tracker.comment(card, comment);
         return true;
     }
     catch {
-        queueCancel(configDir, cardId, comment);
+        queueCancel(configDir, cardId, comment, source);
         return false;
     }
 }
-function queueCancel(configDir, cardId, comment) {
+function queueCancel(configDir, cardId, comment, source = 'linear') {
     const pending = readPending(configDir);
     if (pending.some((p) => p.card === cardId && p.comment === comment))
         return;
     try {
-        writePending(configDir, [...pending, { card: cardId, comment, drop: [], add: [], dropStatus: true }]);
+        writePending(configDir, [...pending, { card: cardId, comment, drop: [], add: [], dropStatus: true, source }]);
     }
     catch {
         // nothing more to do
@@ -385,13 +504,15 @@ export async function tick(rc, only, opts = {}) {
                 // the run folder is gone
             }
         }
-        if (running) {
+        if (running && running.record.source !== 'cron') {
             const { card, trigger } = running.record;
+            const source = running.record.source ?? 'linear';
             const timeout = new Promise((resolve) => setTimeout(() => resolve(false), 5000).unref());
-            const finished = await Promise.race([cancelCard(rc.linear, rc.configDir, card, trigger), timeout]);
+            const work = (async () => cancelCard(rc.trackers(source), rc.configDir, card, trigger, source))().catch(() => false);
+            const finished = await Promise.race([work, timeout]);
             // Did not finish in time: leave the work for the next tick.
             if (!finished)
-                queueCancel(rc.configDir, card, `**Cancelled.** Add \`${trigger}\` again to restart.`);
+                queueCancel(rc.configDir, card, `**Cancelled.** Add \`${trigger}\` again to restart.`, source);
         }
         clearCurrent(rc.configDir);
         process.exit(143);
@@ -404,10 +525,10 @@ export async function tick(rc, only, opts = {}) {
             return 0;
         let job;
         try {
-            job = await nextJob(rc, only, opts.workflow);
+            job = await nextJob(rc, only, opts.workflow, { force: !!opts.workflow && !only });
         }
         catch (err) {
-            rc.log(`Could not check Linear (${err.message}). Trying again next minute.`);
+            rc.log(`Could not read ${only} (${err.message}).`);
             return 1;
         }
         if (!job) {
@@ -421,8 +542,8 @@ export async function tick(rc, only, opts = {}) {
             rc.log(`Workflow ${job.workflow} points at a missing project ${workflow.project}. Run vsf agents workflow edit to fix it.`);
             return 1;
         }
-        if (opts.from && !workflow.steps.includes(opts.from)) {
-            rc.log(`Workflow ${job.workflow} has no ${STEPS[opts.from].label} step.`);
+        if (opts.from && !workflow.steps.some((s) => stepId(s) === opts.from)) {
+            rc.log(`Workflow ${job.workflow} has no ${stepIdLabel(opts.from)} step.`);
             return 2;
         }
         const outcome = await runCard(job.card, job.trigger, job.workflow, workflow, project, rc, { from: opts.from });

package/dist/state.d.ts

@@ -1,4 +1,4 @@
-import { type StepId } from './config.ts';
+import { type Trigger } from './config.ts';
 export interface Current {
     pid: number;
     card?: string;
@@ -8,6 +8,7 @@ export interface Current {
     round?: number;
     startedAt?: string;
     runDir?: string;
+    source?: Trigger['source'];
 }
 export declare const lockPath: (configDir: string) => string;
 export declare function readCurrent(configDir: string): Current | null;
@@ -25,12 +26,13 @@ export interface Pending {
     drop: string[];
     add: string[];
     dropStatus?: boolean;
+    source?: 'linear' | 'voidtrack';
 }
 export declare function readPending(configDir: string): Pending[];
 export declare function writePending(configDir: string, pending: Pending[]): void;
 export type Outcome = 'running' | 'verified' | 'changes' | 'parked' | 'cancelled';
 export interface StepRecord {
-    step: StepId;
+    step: string;
     label: string;
     startedAt: string;
     endedAt?: string;
@@ -44,6 +46,7 @@ export interface RunRecord {
     url?: string;
     workflow: string;
     trigger: string;
+    source?: Trigger['source'];
     steps: StepRecord[];
     outcome: Outcome;
     reason?: string;
@@ -61,3 +64,5 @@ export interface RunEntry {
     logs: string[];
 }
 export declare function listRuns(configDir: string, card?: string): RunEntry[];
+export declare function readCronState(configDir: string): Record<string, string>;
+export declare function writeCronState(configDir: string, state: Record<string, string>): void;

package/dist/state.js

@@ -105,3 +105,18 @@ export function listRuns(configDir, card) {
     }
     return out.sort((a, b) => (a.stamp < b.stamp ? 1 : -1));
 }
+// When each schedule last fired, by workflow and schedule, so a restart or a
+// busy runner never fires one twice.
+const cronPath = (configDir) => join(agentsDir(configDir), 'cron.json');
+export function readCronState(configDir) {
+    try {
+        return JSON.parse(readFileSync(cronPath(configDir), 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeCronState(configDir, state) {
+    mkdirSync(agentsDir(configDir), { recursive: true });
+    writeFileSync(cronPath(configDir), JSON.stringify(state, null, 2) + '\n');
+}

package/dist/tracker.d.ts

@@ -0,0 +1,24 @@
+import type { Tracker as Kind } from './config.ts';
+import type { Card } from './linear.ts';
+export interface Tracker {
+    viewer(): Promise<{
+        id: string;
+        name: string;
+    }>;
+    myCardsWithLabel(label: string, team: string): Promise<Card[]>;
+    card(identifier: string): Promise<Card>;
+    comments(identifier: string): Promise<{
+        body: string;
+        createdAt: string;
+    }[]>;
+    comment(card: Card, body: string): Promise<void>;
+    setLabels(card: Card, next: string[]): Promise<void>;
+    moveTo(card: Card, stateName: string): Promise<boolean>;
+}
+export declare const TRACKERS: Record<Kind, {
+    name: string;
+    keyHint: string;
+}>;
+export type Trackers = (kind: Kind) => Tracker;
+export declare function trackersFor(configDir: string): Trackers;
+export declare const noTracker: Tracker;