@voidlabs.gg/voidshift-agents 0.4.3 → 0.4.4

package/README.md

@@ -50,15 +50,24 @@ Five agents, installed into Claude Code (and Codex if you use it):
 | QA | CI, then code review, then a usability check in a headless browser |
 
 Use them yourself (`/vs-plan ENG-123` in Claude Code), or let a **workflow**
-run them. A workflow starts when one of your Linear cards gets a label, runs
-agents in order in a project (a repo on your Mac), and sends work back to the
-step that made it when a check fails:
+run them. A workflow starts when one of your Linear or VoidTrack cards gets a
+label, or on a schedule, runs agents in order in a project (a repo on your
+machine), and sends work back to the step that made it when a check fails:
 
 ```
 when ENG + vs-plan:  Dev → QA  in tether-relay
 ```
 
-The runner checks Linear every minute, works in its own copy of the repo so
+Triggers, as `--trigger` takes them:
+
+```
+ENG:vs-plan                           # a Linear card in ENG assigned to you gets vs-plan
+voidtrack:ORG:vs-start                # the same for VoidTrack (vsf agents key --voidtrack)
+"cron:0 5 * * 1:Update dependencies"  # every Monday 05:00, no card, on its own branch
+```
+
+A schedule fires once when due (a missed one is made up within a day) and
+`vsf agents run --workflow NAME` fires it now. The runner checks every minute, works in its own copy of the repo so
 your checkout is never touched, and keeps two labels on the card as it goes: the
 stage (`vs-planning`, `vs-plan-review`, `vs-dev`, `vs-qa`, then `vs-qa-verified`
 or `vs-parked`) and the round (`vs-v1`, `vs-v2`). On Linear it posts the plan and

package/dist/config.d.ts

@@ -13,11 +13,21 @@ export declare const AGENTS: Record<string, {
 }>;
 export declare const visibleAgents: () => string[];
 export declare const stepEnabled: (step: StepId, enabled: string[]) => boolean;
-export interface Trigger {
-    source: 'linear';
+export type Tracker = 'linear' | 'voidtrack';
+export interface CardTrigger {
+    source: Tracker;
     team: string;
     label: string;
 }
+export interface CronTrigger {
+    source: 'cron';
+    schedule: string;
+    task: string;
+}
+export type Trigger = CardTrigger | CronTrigger;
+export declare const isCardTrigger: (t: Trigger) => t is CardTrigger;
+export declare function triggerSpec(t: Trigger): string;
+export declare function describeTrigger(t: Trigger): string;
 export interface Project {
     path: string;
     base?: string;

package/dist/config.js

@@ -19,6 +19,19 @@ export const AGENTS = {
 };
 export const visibleAgents = () => Object.keys(AGENTS);
 export const stepEnabled = (step, enabled) => enabled.includes(step);
+export const isCardTrigger = (t) => t.source !== 'cron';
+// The form `--trigger` takes: "ENG:vs-plan" (Linear), "voidtrack:ORG:vs-start",
+// or "cron:0 5 * * 1:Update the dependencies".
+export function triggerSpec(t) {
+    if (t.source === 'cron')
+        return `cron:${t.schedule}:${t.task}`;
+    return t.source === 'voidtrack' ? `voidtrack:${t.team}:${t.label}` : `${t.team}:${t.label}`;
+}
+export function describeTrigger(t) {
+    if (t.source === 'cron')
+        return `cron ${t.schedule}`;
+    return `${t.source === 'voidtrack' ? 'VoidTrack ' : ''}${t.team} + ${t.label}`;
+}
 // Step lists to start a workflow from.
 export const TEMPLATES = {
     build: { steps: ['vs-dev', 'vs-qa'], maxRounds: 3 },
@@ -40,7 +53,7 @@ const configPath = (configDir) => join(agentsDir(configDir), 'config.json');
 export const hasWork = (workflow) => workflow.steps.some((s) => STEPS[s].output === 'commits');
 export const hasProducer = (workflow) => workflow.steps.some(isProducer);
 export const describeSteps = (steps) => steps.map((s) => STEPS[s].label).join(' → ');
-export const describeTriggers = (triggers) => triggers.map((t) => `${t.team} + ${t.label}`).join(', ');
+export const describeTriggers = (triggers) => triggers.map(describeTrigger).join(', ');
 export const describeWorkflow = (c) => `when ${describeTriggers(c.triggers)}: ${describeSteps(c.steps)} in ${c.project}`;
 // Step ids that were folded into QA.
 const RENAMED = { 'vs-qa-review': 'vs-qa', ci: null, 'vs-qa-ui': null };

package/dist/control.d.ts

@@ -1,6 +1,8 @@
+import { type AgentsConfig, type Tracker as Kind } from './config.ts';
 import { type Current, type RunEntry } from './state.ts';
 import type { Check, ToolCommand, ToolContext } from './types.ts';
 export { parsePlistArgs } from './launchd.ts';
+export declare const trackersInUse: (config: Pick<AgentsConfig, "workflows">) => Kind[];
 export declare function parseAge(input: string): number | null;
 export declare function formatDuration(ms: number): string;
 export declare function stampDate(stamp: string): Date;
@@ -18,7 +20,7 @@ export interface CancelDeps {
     ours: (pid: number) => boolean;
     kill: (pid: number, signal: 'SIGTERM' | 'SIGKILL') => void;
     sleep: (ms: number) => Promise<void>;
-    cancelCard: (card: string, label: string) => Promise<boolean>;
+    cancelCard: (card: string, label: string, source: Kind) => Promise<boolean>;
 }
 export declare function cancelCurrent(ctx: ToolContext, c: Current, deps: CancelDeps): Promise<void>;
 export declare const controlCommands: Record<string, ToolCommand>;

package/dist/control.js

@@ -2,11 +2,10 @@ 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, readAgentsConfig } from "./config.js";
-import { readLinearKey } from "./secrets.js";
+import { agentsDir, isCardTrigger, readAgentsConfig } from "./config.js";
 import { isPaused, listRuns, ours, clearCurrent, liveCurrent, readCurrent, setPaused, writeRun } from "./state.js";
 import { runnerService } from "./service.js";
-import { createLinear } from "./linear.js";
+import { TRACKERS, trackersFor } from "./tracker.js";
 import { parseStep, resolveName, stepNames } from "./names.js";
 import { isStatusLabel } from "./workflow.js";
 import { cancelCard, tick } from "./runner.js";
@@ -15,11 +14,27 @@ const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', '
 const CARD_ID = /^[A-Za-z][A-Za-z0-9]*-\d+$/;
 const ISO_LINE = /^(\d{4}-\d\d-\d\dT[\d:.]+Z)\s*(.*)$/;
 export { parsePlistArgs } from "./launchd.js";
-function linear(configDir) {
-    const key = readLinearKey(configDir);
-    if (!key)
-        throw new Error('No Linear API key. Run vsf agents key');
-    return createLinear(key);
+// Trackers the workflows' card triggers use.
+export const trackersInUse = (config) => [
+    ...new Set(Object.values(config.workflows).flatMap((w) => w.triggers.filter(isCardTrigger).map((t) => t.source))),
+];
+// A card by id, from the tracker of a workflow that starts on its team.
+async function findCard(config, trackers, id) {
+    const team = id.split('-')[0].toUpperCase();
+    const sources = [...new Set(Object.values(config.workflows).flatMap((w) => w.triggers.filter(isCardTrigger).filter((t) => t.team === team).map((t) => t.source)))];
+    if (!sources.length)
+        throw new Error(`No workflow starts on team ${team}.`);
+    let last = null;
+    for (const source of sources) {
+        try {
+            const tracker = trackers(source);
+            return { card: await tracker.card(id), tracker, source };
+        }
+        catch (err) {
+            last = err;
+        }
+    }
+    throw last;
 }
 const logPath = (configDir) => join(agentsDir(configDir), 'runner.log');
 const program = (ctx) => [...ctx.selfCommand, 'agents', 'tick'];
@@ -179,7 +194,7 @@ export async function cancelCurrent(ctx, c, deps) {
                 // gone just now
             }
         }
-        ctx.log(c.card ? `Cancelled ${c.card}.` : 'Stopped a check of Linear.');
+        ctx.log(c.card ? `Cancelled ${c.card}.` : 'Stopped a check.');
         return;
     }
     // Dead or a reused pid: no signal, just tidy up what it left behind.
@@ -193,33 +208,44 @@ export async function cancelCurrent(ctx, c, deps) {
             // the record is only a nicety
         }
     }
-    if (c.card) {
-        const label = readAgentsConfig(ctx.configDir).workflows[c.workflow ?? '']?.triggers[0]?.label ?? "the workflow's label";
-        await deps.cancelCard(c.card, label);
+    if (c.card && c.source !== 'cron') {
+        const first = readAgentsConfig(ctx.configDir).workflows[c.workflow ?? '']?.triggers.find(isCardTrigger);
+        await deps.cancelCard(c.card, first?.label ?? "the workflow's label", c.source ?? 'linear');
         ctx.log(`Cleared a stale lock and cancelled ${c.card}.`);
     }
     else
         ctx.log('Cleared a stale lock.');
     clearCurrent(ctx.configDir);
 }
-const realDeps = (ctx, l) => ({
+const realDeps = (ctx) => ({
     ours,
     kill: (pid, signal) => process.kill(pid, signal),
     sleep,
-    cancelCard: (card, label) => cancelCard(l(), ctx.configDir, card, label),
+    cancelCard: async (card, label, source) => {
+        try {
+            return await cancelCard(trackersFor(ctx.configDir)(source), ctx.configDir, card, label, source);
+        }
+        catch {
+            return false;
+        }
+    },
 });
 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;
     }
-    try {
-        await linear(ctx.configDir).viewer();
-    }
-    catch (err) {
-        const msg = err.message;
-        ctx.log(/^No Linear API key/.test(msg) ? msg : `Linear did not accept the key: ${msg}. Run vsf agents key.`);
-        return 1;
+    const trackers = trackersFor(ctx.configDir);
+    for (const kind of trackersInUse(readAgentsConfig(ctx.configDir))) {
+        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;
+        }
     }
     setPaused(ctx.configDir, false);
     if (!runnerService().start(ctx.home, program(ctx), logPath(ctx.configDir))) {
@@ -233,7 +259,7 @@ async function stopCmd(ctx) {
     // Stopping the runner may have stopped the pass; finish or tidy up whatever the lock still names.
     const c = readCurrent(ctx.configDir);
     if (c)
-        await cancelCurrent(ctx, c, realDeps(ctx, () => linear(ctx.configDir)));
+        await cancelCurrent(ctx, c, realDeps(ctx));
     ctx.log('Runner stopped.');
     return 0;
 }
@@ -266,7 +292,7 @@ const status = guard(async (args, ctx) => {
         return 0;
     }
     const working = current && !current.card
-        ? ' Checking Linear now.'
+        ? ' 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(', ')}).`
             : '';
@@ -291,7 +317,7 @@ const start = guard(async (args, ctx) => {
         return p;
     const code = await startCmd(ctx);
     if (!code)
-        ctx.log('Runner started. It checks Linear every minute for cards that start your workflows.');
+        ctx.log('Runner started. Every minute it checks for cards and schedules that start your workflows.');
     return code;
 });
 const stop = guard(async (args, ctx) => {
@@ -353,7 +379,7 @@ const run = guard(async (args, ctx) => {
             return 2;
         }
     }
-    const code = await tick({ configDir: ctx.configDir, config, linear: linear(ctx.configDir), log: ctx.log, selfCommand: ctx.selfCommand }, card, { workflow, from });
+    const code = await tick({ configDir: ctx.configDir, config, trackers: trackersFor(ctx.configDir), log: ctx.log, selfCommand: ctx.selfCommand }, card, { workflow, from });
     if (!card && code === 0) {
         if (isPaused(ctx.configDir))
             ctx.log('The runner is paused, so nothing was picked up. vsf agents resume, or name a card.');
@@ -378,7 +404,7 @@ const cancel = guard(async (args, ctx) => {
         ctx.log(`${c.card ?? 'Another card'} is running, not ${card}.`);
         return 1;
     }
-    await cancelCurrent(ctx, c, realDeps(ctx, () => linear(ctx.configDir)));
+    await cancelCurrent(ctx, c, realDeps(ctx));
     return 0;
 });
 const retry = guard(async (args, ctx) => {
@@ -394,9 +420,17 @@ const retry = guard(async (args, ctx) => {
     }
     const config = readAgentsConfig(ctx.configDir);
     const names = Object.keys(config.workflows);
-    const l = linear(ctx.configDir);
-    const card = await l.card(id);
-    const startsOn = (n) => config.workflows[n].triggers.some((t) => t.team === card.teamKey);
+    let found;
+    try {
+        found = await findCard(config, trackersFor(ctx.configDir), id);
+    }
+    catch (err) {
+        ctx.log(err.message);
+        return 1;
+    }
+    const { card, source } = found;
+    const l = found.tracker;
+    const startsOn = (n) => config.workflows[n].triggers.some((t) => isCardTrigger(t) && t.source === source && t.team === card.teamKey);
     let chosen;
     if (p.values.workflow) {
         const r = resolveName(names, p.values.workflow, 'workflow');
@@ -423,7 +457,7 @@ const retry = guard(async (args, ctx) => {
         }
         chosen = candidates[0];
     }
-    const label = config.workflows[chosen].triggers.find((t) => t.team === card.teamKey).label;
+    const label = config.workflows[chosen].triggers.filter(isCardTrigger).find((t) => t.source === source && t.team === card.teamKey).label;
     const next = card.labels.filter((n) => !isStatusLabel(n));
     if (!next.includes(label))
         next.push(label);
@@ -474,7 +508,7 @@ const show = guard(async (args, ctx) => {
     }
     let labels = null;
     try {
-        labels = (await linear(ctx.configDir).card(id)).labels;
+        labels = (await findCard(readAgentsConfig(ctx.configDir), trackersFor(ctx.configDir), id)).card.labels;
     }
     catch {
         // live labels are optional
@@ -646,11 +680,7 @@ const tickCmd = async (_args, ctx) => {
     const stamped = (l) => ctx.log(`${new Date().toISOString()} ${l}`);
     try {
         const config = readAgentsConfig(ctx.configDir);
-        if (!readLinearKey(ctx.configDir)) {
-            stamped('No Linear API key. Run vsf agents key.');
-            return 1;
-        }
-        return await tick({ configDir: ctx.configDir, config, linear: linear(ctx.configDir), log: stamped, selfCommand: ctx.selfCommand });
+        return await tick({ configDir: ctx.configDir, config, trackers: trackersFor(ctx.configDir), log: stamped, selfCommand: ctx.selfCommand });
     }
     catch (err) {
         stamped(`Could not run the check: ${err.message}`);
@@ -681,7 +711,7 @@ export async function controlChecks(ctx) {
     const checks = [];
     const state = runnerState(ctx);
     checks.push(state === 'running'
-        ? { name: 'agent runner', status: 'ok', detail: 'polling Linear every minute' }
+        ? { name: 'agent runner', status: 'ok', detail: 'checking every minute' }
         : state === 'paused'
             ? { name: 'agent runner', status: 'warn', detail: 'paused', fix: 'vsf agents resume' }
             : { name: 'agent runner', status: 'warn', detail: 'not running', fix: 'vsf agents start' });

package/dist/cron.d.ts

@@ -0,0 +1,9 @@
+export interface Schedule {
+    sets: Set<number>[];
+    anyDom: boolean;
+    anyDow: boolean;
+}
+export declare function parseCron(schedule: string): Schedule | null;
+export declare function matches(s: Schedule, d: Date): boolean;
+export declare const CATCH_UP_MS: number;
+export declare function lastDue(s: Schedule, since: Date, now: Date): Date | null;

package/dist/cron.js

@@ -0,0 +1,66 @@
+// Five field cron schedules: minute hour day-of-month month day-of-week, each
+// a list of *, numbers, ranges and steps (*/15, 1-5, 0,30). Sunday is 0 or 7.
+// When both day fields are restricted, either may match, as in classic cron.
+const FIELDS = [
+    [0, 59],
+    [0, 23],
+    [1, 31],
+    [1, 12],
+    [0, 7],
+];
+function field(text, [min, max]) {
+    const out = new Set();
+    for (const part of text.split(',')) {
+        const m = /^(\*|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/.exec(part);
+        if (!m)
+            return null;
+        const step = m[4] ? Number(m[4]) : 1;
+        const lo = m[1] === '*' ? min : Number(m[2]);
+        const hi = m[1] === '*' ? max : m[3] ? Number(m[3]) : m[4] ? max : lo;
+        if (step < 1 || lo < min || hi > max || lo > hi)
+            return null;
+        for (let v = lo; v <= hi; v += step)
+            out.add(v);
+    }
+    return out;
+}
+export function parseCron(schedule) {
+    const parts = schedule.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return null;
+    const sets = [];
+    for (let i = 0; i < 5; i++) {
+        const s = field(parts[i], FIELDS[i]);
+        if (!s)
+            return null;
+        sets.push(s);
+    }
+    if (sets[4].has(7))
+        sets[4].add(0);
+    return { sets, anyDom: parts[2] === '*', anyDow: parts[4] === '*' };
+}
+export function matches(s, d) {
+    const [min, hour, dom, month, dow] = s.sets;
+    if (!min.has(d.getMinutes()) || !hour.has(d.getHours()) || !month.has(d.getMonth() + 1))
+        return false;
+    const domOk = dom.has(d.getDate());
+    const dowOk = dow.has(d.getDay());
+    if (s.anyDom || s.anyDow)
+        return domOk && dowOk;
+    return domOk || dowOk;
+}
+const MINUTE = 60_000;
+// How far back a missed schedule is still made up for, e.g. after the runner
+// was busy or the machine was off. Older misses are skipped, not queued.
+export const CATCH_UP_MS = 24 * 60 * MINUTE;
+// The latest minute after `since` and up to `now` that the schedule matches,
+// or null. Only the latest counts: several missed runs fire once.
+export function lastDue(s, since, now) {
+    const floor = Math.max(since.getTime(), now.getTime() - CATCH_UP_MS);
+    const t = new Date(now);
+    t.setSeconds(0, 0);
+    for (; t.getTime() > floor; t.setTime(t.getTime() - MINUTE))
+        if (matches(s, t))
+            return new Date(t);
+    return null;
+}

package/dist/index.js

@@ -4,12 +4,16 @@ import { homedir } from 'node:os';
 import { basename, dirname, join, resolve, sep } from 'node:path';
 import { parseArgs } from 'node:util';
 import { fileURLToPath } from 'node:url';
-import { AGENTS, STEPS, TEMPLATES, isProducer, agentsDir, describeSteps, describeTriggers, describeWorkflow, stepEnabled, visibleAgents, readAgentsConfig, writeAgentsConfig, DEFAULTS } from "./config.js";
+import { AGENTS, STEPS, TEMPLATES, isProducer, agentsDir, describeSteps, describeTrigger, describeTriggers, describeWorkflow, stepEnabled, visibleAgents, readAgentsConfig, writeAgentsConfig, DEFAULTS } from "./config.js";
 import { controlChecks, controlCommands, controlUsage } from "./control.js";
-import { keyStore, looksLikeLinearKey, readLinearKey, storeLinearKey } from "./secrets.js";
+import { keyStore, looksLikeLinearKey, readLinearKey, readSecret, storeLinearKey, storeSecret } from "./secrets.js";
+import { TRACKERS } from "./tracker.js";
+import { createVoidTrack } from "./voidtrack.js";
+import { parseCron } from "./cron.js";
+import { trackersInUse } from "./control.js";
 import { runnerService } from "./service.js";
 import { createLinear } from "./linear.js";
-import { duplicateTriggerWarnings, moveKey, parseTrigger, renameKey, sameTrigger, validateConfig, validateWorkflow, workflowsUsing } from "./manage.js";
+import { TRIGGER_FORMS, duplicateTriggerWarnings, moveKey, parseTrigger, renameKey, sameTrigger, validateConfig, validateWorkflow, workflowsUsing } from "./manage.js";
 import { parseStep, resolveName, stepNames } from "./names.js";
 import { findRepos } from "./repos.js";
 import { defaultBranch, sh } from "./git.js";
@@ -81,26 +85,28 @@ async function chooseHomes(ui, configDir, saved) {
     return homes;
 }
 // Checks the key against Linear, and only then stores it.
-async function verifyAndStore(configDir, key, info, warn) {
+async function verifyAndStore(configDir, key, info, warn, kind = 'linear') {
+    const name = TRACKERS[kind].name;
     try {
-        const me = await createLinear(key).viewer();
-        if (!storeLinearKey(configDir, key)) {
-            warn(`Linear accepted the key but it could not be stored in ${keyStore()}.`);
+        const me = await (kind === 'voidtrack' ? createVoidTrack(key) : createLinear(key)).viewer();
+        if (!(kind === 'voidtrack' ? storeSecret(configDir, 'voidtrack', key) : storeLinearKey(configDir, key))) {
+            warn(`${name} accepted the key but it could not be stored in ${keyStore()}.`);
             return null;
         }
-        info(`Linear connected as ${me.name}. Key stored in ${keyStore()}.`);
+        info(`${name} connected as ${me.name}. Key stored in ${keyStore()}.`);
         return me.name;
     }
     catch (err) {
-        warn(`Linear did not accept that key: ${err.message}. Nothing was stored.`);
+        warn(`${name} did not accept that key: ${err.message}. Nothing was stored.`);
         return null;
     }
 }
 // Asks for the key, checks it against Linear, and only then stores it.
-async function setupKey(ui, configDir) {
-    ui.info('Agents need a Linear personal API key (Linear > Settings > Security & access > API keys).');
-    const key = await ui.secret('Paste your Linear API key', (v) => (looksLikeLinearKey(v.trim()) ? undefined : 'Linear keys start with lin_api_'));
-    return verifyAndStore(configDir, key.trim(), ui.info, ui.warn);
+async function setupKey(ui, configDir, kind = 'linear') {
+    const { name, keyHint } = TRACKERS[kind];
+    ui.info(`Agents need a ${name} API key (${keyHint}).`);
+    const key = await ui.secret(`Paste your ${name} API key`, (v) => kind === 'linear' ? (looksLikeLinearKey(v.trim()) ? undefined : 'Linear keys start with lin_api_') : v.trim() ? undefined : 'Required');
+    return verifyAndStore(configDir, key.trim(), ui.info, ui.warn, kind);
 }
 async function currentLinearUser(configDir) {
     try {
@@ -277,11 +283,22 @@ async function promptWorkflow(ui, config, teams, current = {}, edit = false) {
     if (!triggers) {
         triggers = [];
         do {
-            const team = teams.length
-                ? await ui.select(triggers.length ? 'Also start for cards in which Linear team?' : 'Starts when a card in which Linear team...', teams.map((t) => ({ value: t.key, label: `${t.key}  ${t.name}`, hint: t.mine ? 'your team' : undefined })), myTeams.length === 1 ? myTeams[0].key : undefined)
-                : (await ui.text('Starts when a card in which Linear team key...', { validate: (v) => (v.trim() ? undefined : 'Required') })).trim().toUpperCase();
+            const source = await ui.select(triggers.length ? 'Also start it when...' : 'Starts when...', [
+                { value: 'linear', label: 'A Linear card gets a label' },
+                { value: 'voidtrack', label: 'A VoidTrack card gets a label' },
+                { value: 'cron', label: 'On a schedule', hint: 'runs on a standing task, no card' },
+            ], 'linear');
+            if (source === 'cron') {
+                const schedule = (await ui.text('Cron schedule (minute hour day month weekday)', { initial: '0 5 * * 1', validate: (v) => (parseCron(v) ? undefined : 'Five fields, like 0 5 * * 1') })).trim();
+                const task = (await ui.text('What should each run work on?', { placeholder: 'Update the dependencies and fix what breaks', validate: (v) => (v.trim() ? undefined : 'Required') })).trim();
+                triggers.push({ source: 'cron', schedule, task });
+                continue;
+            }
+            const team = source === 'linear' && teams.length
+                ? await ui.select('A card in which Linear team...', teams.map((t) => ({ value: t.key, label: `${t.key}  ${t.name}`, hint: t.mine ? 'your team' : undefined })), myTeams.length === 1 ? myTeams[0].key : undefined)
+                : (await ui.text(`A card in which ${TRACKERS[source].name} team key...`, { validate: (v) => (v.trim() ? undefined : 'Required') })).trim().toUpperCase();
             const label = (await ui.text('...gets which label?', { initial: 'vs-plan', validate: (v) => (v.trim() ? undefined : 'Required') })).trim();
-            triggers.push({ source: 'linear', team, label });
+            triggers.push({ source, team, label });
         } while (await ui.confirm('Add another way to start this workflow?', false));
     }
     let steps = w.steps?.length && (await keep('steps', describeSteps(w.steps))) ? w.steps : undefined;
@@ -341,7 +358,7 @@ async function setupWorkflows(ui, config, teams, log) {
 // One entry per command, in the order help lists them.
 const USAGE = [
     ['workflows [--json]', 'List workflows in the order they match'],
-    ['workflow add [NAME] [--trigger TEAM:LABEL]... [--steps dev,qa | --template build] [--project P] [--rounds N]', 'Create a workflow; prompts for what is missing'],
+    ['workflow add [NAME] [--trigger TEAM:LABEL]... [--steps dev,qa | --template build] [--project P] [--rounds N]', 'Create a workflow; prompts for what is missing. A trigger is TEAM:LABEL (Linear), voidtrack:TEAM:LABEL or "cron:SCHEDULE:TASK"'],
     ['workflow show NAME [--json]', 'Show one workflow'],
     ['workflow edit NAME [--trigger T:L]... [--add-trigger T:L] [--remove-trigger T:L] [--steps S | --template T] [--project P] [--rounds N]', 'Change a workflow; no flags asks'],
     ['workflow rename OLD NEW', 'Rename a workflow, keeping its place'],
@@ -356,7 +373,7 @@ const USAGE = [
     ['homes [--json]', 'Show where the agents are linked'],
     ['link DIR [--claude | --codex]', 'Link the agents into a config folder'],
     ['unlink DIR', 'Remove the agents from a config folder'],
-    ['key', 'Store or replace the Linear API key (reads stdin without a terminal)'],
+    ['key [--voidtrack]', 'Store or replace the Linear or VoidTrack API key (reads stdin without a terminal)'],
     ['help [COMMAND]', 'Show this list, or one command'],
 ];
 const usageOf = (name) => USAGE.filter(([c]) => c === name || c.startsWith(`${name} `))
@@ -441,7 +458,7 @@ function readWorkflowFlags(v, config) {
         for (const t of v.trigger) {
             const parsed = parseTrigger(t);
             if (!parsed)
-                return { error: `Bad trigger ${t}. Use TEAM:LABEL, like ENG:vs-plan.`, code: 2 };
+                return { error: `Bad trigger ${t}. Use ${TRIGGER_FORMS}.`, code: 2 };
             flags.triggers.push(parsed);
         }
     }
@@ -590,7 +607,7 @@ const workflowSubs = {
         else {
             ctx.log(`Workflow ${name}: ${describeWorkflow(w)}`);
             for (const t of w.triggers)
-                ctx.log(`Trigger: ${t.team} + ${t.label}`);
+                ctx.log(`Trigger: ${describeTrigger(t)}${t.source === 'cron' ? `, task: ${t.task}` : ''}`);
             ctx.log(`Steps: ${describeSteps(w.steps)}`);
             ctx.log(`Project: ${w.project}`);
             ctx.log(`Rounds: ${w.maxRounds}`);
@@ -637,7 +654,7 @@ const workflowSubs = {
         for (const t of (v['add-trigger'] ?? [])) {
             const parsed = parseTrigger(t);
             if (!parsed) {
-                ctx.log(`Bad trigger ${t}. Use TEAM:LABEL, like ENG:vs-plan.`);
+                ctx.log(`Bad trigger ${t}. Use ${TRIGGER_FORMS}.`);
                 return 2;
             }
             if (!next.triggers.some((x) => sameTrigger(x, parsed)))
@@ -1053,7 +1070,11 @@ const agents = {
         await setupProjects(ui, config, ctx.log);
         await setupWorkflows(ui, config, await linear(ctx.configDir).teams(), ctx.log);
         writeAgentsConfig(ctx.configDir, config);
-        if (Object.keys(config.workflows).length && (await ui.confirm('Start the background runner now? It checks Linear every minute for cards that start your workflows.'))) {
+        if (trackersInUse(config).includes('voidtrack') && !readSecret(ctx.configDir, 'voidtrack')) {
+            if (!(await setupKey(ui, ctx.configDir, 'voidtrack')))
+                ctx.log('VoidTrack is not connected yet. Run vsf agents key --voidtrack.');
+        }
+        if (Object.keys(config.workflows).length && (await ui.confirm('Start the background runner now? Every minute it checks for cards and schedules that start your workflows.'))) {
             const ok = runnerService().start(ctx.home, [...ctx.selfCommand, 'agents', 'tick'], join(agentsDir(ctx.configDir), 'runner.log'));
             ctx.log(ok ? 'Runner started.' : 'Could not start the runner. Try vsf agents start.');
         }
@@ -1077,12 +1098,19 @@ const agents = {
                 ? { name: `agents in ${homeLabel(h)}`, status: 'ok', detail: `${wanted.length} linked` }
                 : { name: `agents in ${homeLabel(h)}`, status: 'warn', detail: `missing ${missing.join(', ')}`, fix: `vsf agents link ${tilde(h.dir)}` });
         }
-        try {
-            const me = await linear(ctx.configDir).viewer();
-            checks.push({ name: 'Linear', status: 'ok', detail: `connected as ${me.name}` });
-        }
-        catch (err) {
-            checks.push({ name: 'Linear', status: 'fail', detail: err.message, fix: 'vsf agents key' });
+        const inUse = trackersInUse(saved);
+        for (const kind of inUse.length ? inUse : ['linear']) {
+            const { name } = TRACKERS[kind];
+            try {
+                const key = readSecret(ctx.configDir, kind);
+                if (!key)
+                    throw new Error(`No ${name} API key`);
+                const me = await (kind === 'voidtrack' ? createVoidTrack(key) : createLinear(key)).viewer();
+                checks.push({ name, status: 'ok', detail: `connected as ${me.name}` });
+            }
+            catch (err) {
+                checks.push({ name, status: 'fail', detail: err.message, fix: `vsf agents key${kind === 'linear' ? '' : ` --${kind}`}` });
+            }
         }
         const workflows = Object.entries(saved.workflows);
         const broken = workflows.filter(([, c]) => !saved.projects[c.project] || !isRepo(saved.projects[c.project].path)).map(([n]) => n);
@@ -1134,21 +1162,26 @@ const agents = {
         link: homeCommands.link,
         unlink: homeCommands.unlink,
         async key(args, ctx) {
-            const p = begin('key', args, {}, ctx);
+            const p = begin('key', args, { voidtrack: { type: 'boolean' } }, ctx);
             if (typeof p === 'number')
                 return p;
             if (p.positionals.length) {
                 ctx.log('Keys are not accepted on the command line. Pipe the key in instead.');
                 return 2;
             }
+            const kind = p.values.voidtrack ? 'voidtrack' : 'linear';
             if (interactive())
-                return (await setupKey(ctx.ui, ctx.configDir)) ? 0 : 1;
+                return (await setupKey(ctx.ui, ctx.configDir, kind)) ? 0 : 1;
             const key = readFileSync(0, 'utf8').trim();
-            if (!looksLikeLinearKey(key)) {
+            if (kind === 'linear' && !looksLikeLinearKey(key)) {
                 ctx.log('Linear keys start with lin_api_');
                 return 2;
             }
-            return (await verifyAndStore(ctx.configDir, key, ctx.log, ctx.log)) ? 0 : 1;
+            if (!key) {
+                ctx.log('No key on stdin.');
+                return 2;
+            }
+            return (await verifyAndStore(ctx.configDir, key, ctx.log, ctx.log, kind)) ? 0 : 1;
         },
         async help(args, ctx) {
             const want = args.join(' ').trim();

package/dist/linear.d.ts

@@ -20,7 +20,7 @@ export declare function createLinear(apiKey: string): {
         name: string;
         mine: boolean;
     }[]>;
-    myCardsWithLabel(label: string): Promise<Card[]>;
+    myCardsWithLabel(label: string, team: string): Promise<Card[]>;
     card(identifier: string): Promise<Card>;
     comments(identifier: string): Promise<{
         body: string;

package/dist/linear.js

@@ -79,14 +79,14 @@ export function createLinear(apiKey) {
             const all = d?.teams?.nodes ?? [];
             return all.map((t) => ({ ...t, mine: mine.has(t.key) })).sort((a, b) => Number(b.mine) - Number(a.mine));
         },
-        // My cards carrying the trigger label.
-        async myCardsWithLabel(label) {
+        // My cards in the team carrying the trigger label.
+        async myCardsWithLabel(label, team) {
             const d = await gql('myCards', `query MyCards($label: String!) {
           issues(first: 20, orderBy: createdAt, filter: { assignee: { isMe: { eq: true } }, labels: { name: { eq: $label } } }) {
             nodes { ${CARD_FIELDS} }
           }
         }`, { label });
-            return (d?.issues?.nodes ?? []).map(mapCard);
+            return (d?.issues?.nodes ?? []).map(mapCard).filter((c) => c.teamKey === team);
         },
         async card(identifier) {
             const d = await gql('card', `query Card($id: String!) { issue(id: $id) { ${CARD_FIELDS} } }`, { id: identifier });

package/dist/manage.d.ts

@@ -1,5 +1,6 @@
 import { type AgentsConfig, type Trigger, type Workflow } from './config.ts';
 export declare function validateWorkflow(config: Pick<AgentsConfig, 'enabled' | 'projects'>, workflow: Workflow): string[];
+export declare const TRIGGER_FORMS = "TEAM:LABEL (Linear), voidtrack:TEAM:LABEL, or cron:SCHEDULE:TASK";
 export declare function parseTrigger(input: string): Trigger | null;
 export declare const sameTrigger: (a: Trigger, b: Trigger) => boolean;
 export declare function duplicateTriggerWarnings(workflows: Record<string, Workflow>, name: string, workflow: Workflow): string[];