@voidlabs.gg/voidshift-agents 0.4.3 → 0.4.5

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
@@ -77,8 +86,33 @@ vsf agents workflow add|edit|show|rename|move|rm
 vsf agents projects | project add|edit|show|rename|rm
 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
+```
+
+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:
+
+```json
+{
+  "triggers": [{ "source": "cron", "schedule": "0 7 * * 1-5", "task": "Morning brief" }],
+  "steps": [{ "id": "brief", "prompt": "brief.md", "output": "none", "model": "haiku", "timeoutMinutes": 10 }],
+  "maxRounds": 1,
+  "project": "tether-relay",
+  "writeBack": { "labels": true, "state": null, "comment": true }
+}
 ```
 
+A step's `output` is `plan`, `verdict`, `commits`, `publish` or `none`; a failed
+`verdict` sends the work back to the nearest `plan` or `commits` step. `engine`,
+`model` and `timeoutMinutes` fall back to the config, and `write` to true only
+for `commits`. A `publish` step takes no prompt; the others take one `prompt`
+file or `skill`, which must ask for a `RESULT:` line (`plan`, `commits`) or a
+`VERDICT:` line (`verdict`). `writeBack` applies to card runs: `state` moves a
+verified card there (`null` never moves it), `labels: false` only takes the
+trigger label off, and `comment: false` skips the closing comment. Edit the file,
+then `vsf agents validate`.
+
 ### memory
 
 A folder of markdown notes, one topic per note, with an `INDEX.md` holding one
@@ -99,6 +133,20 @@ vsf memory on | off        # turn recall on or off
 Setup creates a vault at `~/memory` or uses one you already have. Codex asks you
 to trust the recall hook once: run `/hooks` in Codex.
 
+### Your profile
+
+Every agent run carries your profile, on any machine, without touching your
+Claude or Codex folder. `vsf agents profile init` creates
+`~/.config/voidshift/agents/profile/`:
+
+- `RULES.md` is added to every step's prompt (style, commit rules, tone).
+- `claude-settings.json` is passed to Claude runs with `--settings`, so hooks
+  come along. `{{profile}}` stands for the folder, so hook scripts can live in it.
+
+Setup also asks what the runner does to agent commits before it pushes them:
+remove AI co-author lines, and add `Signed-off-by` for repos that ask for a
+DCO. Only the new commits of that step are rewritten, never pushed ones.
+
 ## What to know
 
 - **Your own logins.** Agents run the official `claude` and `codex` CLIs you

package/dist/config.d.ts

@@ -1,32 +1,69 @@
 import type { Engine } from './engine.ts';
 export type StepId = 'vs-plan' | 'vs-plan-review' | 'vs-publish' | 'vs-dev' | 'vs-qa';
-export type Output = 'plan' | 'verdict' | 'commits' | 'publish';
+export type Output = 'plan' | 'verdict' | 'commits' | 'publish' | 'none';
+export declare const OUTPUTS: Output[];
 export declare const STEPS: Record<StepId, {
     label: string;
     output: Output;
     hint: string;
+    write: boolean;
+    role: 'dev' | 'review';
 }>;
-export declare const isProducer: (s: StepId) => boolean;
+export interface StepDef {
+    id: string;
+    label?: string;
+    skill?: string;
+    prompt?: string;
+    output: Output;
+    engine?: Engine;
+    model?: string;
+    timeoutMinutes?: number;
+    write?: boolean;
+}
+export type Step = StepId | StepDef;
+export declare const STEP_ID: RegExp;
+export declare const isBuiltin: (id: string) => id is StepId;
+export declare const outputOf: (s: Step) => Output;
+export declare const stepId: (s: Step) => string;
+export declare const stepLabel: (s: Step) => string;
+export declare const stepIdLabel: (id: string) => string;
+export declare const isProducer: (s: Step) => boolean;
 export declare const AGENTS: Record<string, {
     label: string;
     hint: 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;
 }
+export interface WriteBack {
+    labels?: boolean;
+    state?: string | null;
+    comment?: boolean;
+}
 export interface Workflow {
     triggers: Trigger[];
-    steps: StepId[];
+    steps: Step[];
     maxRounds: number;
     project: string;
+    writeBack?: WriteBack;
 }
 export interface AgentsConfig {
     engine: Engine;
@@ -43,6 +80,11 @@ export interface AgentsConfig {
         dir: string;
     }[];
     enabled: string[];
+    commits?: {
+        signOff?: boolean;
+        dropAiTrailers?: boolean;
+    };
+    folders?: Record<string, string>;
 }
 export declare const TEMPLATES: Record<string, {
     steps: StepId[];
@@ -52,9 +94,26 @@ export declare const DEFAULTS: AgentsConfig;
 export declare const agentsDir: (configDir: string) => string;
 export declare const hasWork: (workflow: Pick<Workflow, "steps">) => boolean;
 export declare const hasProducer: (workflow: Pick<Workflow, "steps">) => boolean;
-export declare const describeSteps: (steps: StepId[]) => string;
+export declare const describeSteps: (steps: Step[]) => string;
 export declare const describeTriggers: (triggers: Trigger[]) => string;
 export declare const describeWorkflow: (c: Workflow) => string;
 export declare function migrate(saved: Record<string, any>): Partial<AgentsConfig>;
+export declare const defsDir: (configDir: string) => string;
+export declare const AGENT_FILE = "agent.json";
+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 interface ResolvedStep {
+    id: string;
+    label: string;
+    output: Output;
+    engine: Engine;
+    model?: string;
+    timeoutMs: number;
+    write: boolean;
+    prompt: () => string;
+    builtin?: StepId;
+}
+export declare function stepFile(step: StepDef, dir?: string): string | null;
+export declare function resolveStep(step: Step, config: Pick<AgentsConfig, 'engine' | 'models' | 'timeoutMinutes'>, dir?: string): ResolvedStep;

package/dist/config.js

@@ -1,14 +1,25 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { basename, join } from 'node:path';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const OUTPUTS = ['plan', 'verdict', 'commits', 'publish', 'none'];
+// The built-in steps, the vs-* template. `write` is whether the agent may
+// edit files; `role` picks the model from config.models.
 export const STEPS = {
-    'vs-plan': { label: 'Plan', output: 'plan', hint: 'writes a plan and posts it to the card' },
-    'vs-plan-review': { label: 'Plan review', output: 'verdict', hint: 'checks the plan; on FIX the workflow goes back to Plan' },
-    'vs-publish': { label: 'Publish', output: 'publish', hint: 'creates and pushes the branch for the card' },
-    'vs-dev': { label: 'Dev', output: 'commits', hint: 'implements the plan, commits, opens a draft PR' },
-    'vs-qa': { label: 'QA', output: 'verdict', hint: 'CI, then code review, then a usability check; on FIX back to Dev' },
+    'vs-plan': { label: 'Plan', output: 'plan', hint: 'writes a plan and posts it to the card', write: false, role: 'dev' },
+    'vs-plan-review': { label: 'Plan review', output: 'verdict', hint: 'checks the plan; on FIX the workflow goes back to Plan', write: false, role: 'review' },
+    'vs-publish': { label: 'Publish', output: 'publish', hint: 'creates and pushes the branch for the card', write: false, role: 'dev' },
+    'vs-dev': { label: 'Dev', output: 'commits', hint: 'implements the plan, commits, opens a draft PR', write: true, role: 'dev' },
+    'vs-qa': { label: 'QA', output: 'verdict', hint: 'CI, then code review, then a usability check; on FIX back to Dev', write: true, role: 'review' },
 };
+// What a custom step id may look like.
+export const STEP_ID = /^[a-z0-9][a-z0-9-]*$/;
+export const isBuiltin = (id) => Object.hasOwn(STEPS, id);
+export const outputOf = (s) => (typeof s === 'string' ? STEPS[s].output : s.output);
+export const stepId = (s) => (typeof s === 'string' ? s : s.id);
+export const stepLabel = (s) => (typeof s === 'string' ? STEPS[s]?.label ?? s : s.label ?? s.id);
+export const stepIdLabel = (id) => (isBuiltin(id) ? STEPS[id].label : id);
 // Steps a failed verdict can send work back to.
-export const isProducer = (s) => STEPS[s].output === 'plan' || STEPS[s].output === 'commits';
+export const isProducer = (s) => outputOf(s) === 'plan' || outputOf(s) === 'commits';
 // The agents in the pack, as setup describes them.
 export const AGENTS = {
     'vs-plan': { label: 'Plan', hint: 'plans a card against the code' },
@@ -19,6 +30,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 },
@@ -37,10 +61,10 @@ export const DEFAULTS = {
 };
 export const agentsDir = (configDir) => join(configDir, 'agents');
 const configPath = (configDir) => join(agentsDir(configDir), 'config.json');
-export const hasWork = (workflow) => workflow.steps.some((s) => STEPS[s].output === 'commits');
+export const hasWork = (workflow) => workflow.steps.some((s) => outputOf(s) === '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 describeSteps = (steps) => steps.map(stepLabel).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 };
@@ -85,14 +109,88 @@ export function migrate(saved) {
     const enabled = [...new Set((saved.enabled ?? []).map((a) => (a in RENAMED ? RENAMED[a] : a)).filter(Boolean))];
     return { ...rest, ...(models ? { models } : {}), projects, workflows, enabled };
 }
+// Agent folders: defs/<name>/agent.json, with its prompt files next to it.
+export const defsDir = (configDir) => join(agentsDir(configDir), 'defs');
+export const AGENT_FILE = 'agent.json';
+export function agentFolders(configDir) {
+    try {
+        return readdirSync(defsDir(configDir), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join(defsDir(configDir), e.name));
+    }
+    catch {
+        return [];
+    }
+}
+// The workflow in an agent folder. Throws when agent.json is missing or not JSON.
+export function readAgentFolder(dir) {
+    const value = JSON.parse(readFileSync(join(dir, AGENT_FILE), 'utf8'));
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${AGENT_FILE} must be an object`);
+    const { triggers, steps, maxRounds, project, writeBack } = value;
+    return { triggers, steps, maxRounds, project, ...(writeBack !== undefined ? { writeBack } : {}) };
+}
 export function readAgentsConfig(configDir) {
     const path = configPath(configDir);
-    if (!existsSync(path))
-        return structuredClone(DEFAULTS);
-    const saved = migrate(JSON.parse(readFileSync(path, 'utf8')));
-    return { ...structuredClone(DEFAULTS), ...saved, models: { ...DEFAULTS.models, ...saved.models } };
+    let config = structuredClone(DEFAULTS);
+    if (existsSync(path)) {
+        const saved = migrate(JSON.parse(readFileSync(path, 'utf8')));
+        config = { ...config, ...saved, models: { ...DEFAULTS.models, ...saved.models } };
+    }
+    // A name config.json already uses wins, and a broken folder is skipped:
+    // `vsf agents validate` reports both.
+    for (const dir of agentFolders(configDir)) {
+        const name = basename(dir);
+        if (config.workflows[name])
+            continue;
+        try {
+            config.workflows[name] = readAgentFolder(dir);
+            config.folders = { ...config.folders, [name]: dir };
+        }
+        catch {
+            // skipped
+        }
+    }
+    return config;
 }
 export function writeAgentsConfig(configDir, config) {
     mkdirSync(agentsDir(configDir), { recursive: true });
-    writeFileSync(configPath(configDir), JSON.stringify(config, null, 2) + '\n');
+    const { folders, ...rest } = config;
+    const workflows = Object.fromEntries(Object.entries(config.workflows).filter(([name]) => !folders?.[name]));
+    writeFileSync(configPath(configDir), JSON.stringify({ ...rest, workflows }, null, 2) + '\n');
+}
+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,
+// or a skill folder next to agent.json. Null for a step with neither.
+export function stepFile(step, dir = '.') {
+    if (step.prompt)
+        return resolve(dir, step.prompt);
+    if (!step.skill)
+        return null;
+    if (STEP_ID.test(step.skill) && existsSync(packSkill(step.skill)))
+        return packSkill(step.skill);
+    return resolve(dir, step.skill, 'SKILL.md');
+}
+export function resolveStep(step, config, dir) {
+    if (typeof step === 'string') {
+        const s = STEPS[step];
+        return {
+            id: step, label: s.label, output: s.output, engine: config.engine, model: config.models[s.role],
+            timeoutMs: config.timeoutMinutes * 60_000, write: s.write, prompt: () => readFileSync(packSkill(step), 'utf8'), builtin: step,
+        };
+    }
+    return {
+        id: step.id,
+        label: step.label ?? step.id,
+        output: step.output,
+        engine: step.engine ?? config.engine,
+        model: step.model ?? config.models[step.output === 'verdict' ? 'review' : 'dev'],
+        timeoutMs: (step.timeoutMinutes ?? config.timeoutMinutes) * 60_000,
+        write: step.write ?? step.output === 'commits',
+        prompt: () => {
+            const file = stepFile(step, dir);
+            if (!file)
+                throw new Error(`Step ${step.id} has no prompt or skill.`);
+            return readFileSync(file, 'utf8');
+        },
+    };
 }

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,12 +2,11 @@ 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 { parseStep, resolveName, stepNames } from "./names.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";
 const HOUR = 3_600_000;
@@ -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) => {
@@ -347,13 +373,13 @@ const run = guard(async (args, ctx) => {
     }
     let from;
     if (p.values.from) {
-        from = parseStep(p.values.from);
+        from = parseFrom(p.values.from);
         if (!from) {
             ctx.log(`Unknown step ${p.values.from}. Steps: ${stepNames()}.`);
             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;