@phnx-labs/agents-cli 1.20.89 → 1.20.91

package/dist/commands/harness.js

@@ -11,15 +11,82 @@
  * native harness registry. The `agents profiles` tree stays unchanged.
  */
 import chalk from 'chalk';
-import { addProfile } from './profiles.js';
-import { listProfiles, readProfile, deleteProfile, profileHostLabel, profileProviderLabel, profileModelLabel, profileAuthLabel, getProfilePath, } from '../lib/profiles.js';
+import { addProfile, ensureProviderToken } from './profiles.js';
+import { listProfiles, readProfile, writeProfile, deleteProfile, profileExists, profileHostLabel, profileProviderLabel, profileModelLabel, profileAuthLabel, profileLabel, forkProfile, profileFromHostModel, authEnvKeyForHost, getProfilePath, validateProfileName, } from '../lib/profiles.js';
 import { listPresets } from '../lib/profiles-presets.js';
-import { AGENTS, ALL_AGENT_IDS } from '../lib/agents.js';
+import { AGENTS, ALL_AGENT_IDS, resolveAgentName } from '../lib/agents.js';
 /** Short capability summary for a native harness — its supported run modes. */
 function nativeModes(id) {
     const modes = AGENTS[id]?.capabilities?.modes ?? [];
     return modes.length ? modes.join('/') : '-';
 }
+/**
+ * Print one custom harness. Shared by `agents harness view <name>` and by
+ * `agents view <name>` — a custom harness resolves as an agent type there, so
+ * both entry points must describe it identically.
+ */
+export function renderHarnessDetail(name) {
+    const p = readProfile(name);
+    console.log(chalk.bold(profileLabel(p)) + chalk.gray('  (custom harness)'));
+    if (p.description)
+        console.log(chalk.gray(p.description));
+    console.log('');
+    console.log(`Host:     ${profileHostLabel(p)}`);
+    console.log(`Model:    ${profileModelLabel(p)}`);
+    if (p.fallback_model)
+        console.log(`Fallback: ${p.fallback_model}`);
+    console.log(`Provider: ${profileProviderLabel(p)}`);
+    console.log(`Auth:     ${profileAuthLabel(p)}`);
+    if (p.forkedFrom)
+        console.log(`Forked:   from ${p.forkedFrom}`);
+    console.log(chalk.gray(getProfilePath(p.name)));
+    console.log('');
+    console.log(chalk.gray(`Run: agents run ${p.name} "hello"`));
+}
+/**
+ * Build the new harness for `agents harness fork <source> <name>`.
+ *
+ * Two sources, one verb: an existing custom harness is copied and overridden;
+ * a native agent id is turned into a harness pinned to `--model` on that host.
+ * Forking a native harness therefore requires `--model` — there is nothing to
+ * copy a model from.
+ */
+export function buildFork(source, name, opts) {
+    if (profileExists(source)) {
+        return forkProfile(readProfile(source), name, {
+            model: opts.model,
+            baseUrl: opts.baseUrl,
+            provider: opts.authProvider,
+            version: opts.version,
+            label: opts.label,
+            description: opts.description,
+        });
+    }
+    const host = resolveAgentName(source);
+    if (!host) {
+        throw new Error(`No harness or agent named '${source}'.\n` +
+            `Fork from a custom harness (agents harness list) or a native one: ${ALL_AGENT_IDS.join(', ')}.`);
+    }
+    if (!opts.model) {
+        throw new Error(`--model <id> is required when forking the native '${host}' harness (there is no model to inherit).`);
+    }
+    return profileFromHostModel(name, host, opts.model, {
+        version: opts.version,
+        baseUrl: opts.baseUrl,
+        provider: opts.authProvider,
+        authEnvVar: opts.authProvider ? authEnvKeyForHostOrThrow(host) : undefined,
+        label: opts.label,
+        description: opts.description ?? `Forked from ${host}: ${opts.model}`,
+    });
+}
+/** Auth env var for a host, as a hard error when the host declares none. */
+function authEnvKeyForHostOrThrow(host) {
+    const key = authEnvKeyForHost(host);
+    if (!key) {
+        throw new Error(`--auth-provider is set but host '${host}' has no known auth env var; it manages its own login.`);
+    }
+    return key;
+}
 export function registerHarnessCommands(program) {
     const cmd = program
         .command('harness')
@@ -30,11 +97,18 @@ A custom harness pins a host CLI (opencode, claude, codex, grok, antigravity, ..
 model and gives it a name. 'agents run <name>' then behaves like a native agent
 type, and 'agents repo push user' syncs it to every device.
 
+A custom harness is its own agent type in 'agents view' — its own block beside Claude
+and Codex, not a row indented under the host CLI that executes it.
+
 Examples:
   # Meta Muse Spark 1.1 through OpenCode, called 'spark'
   agents harness add spark --host opencode --model meta/muse-spark-1.1
   agents run spark "refactor api/handlers/checkout.py"
 
+  # Fork a native harness, or copy one of your own and swap the model
+  agents harness fork opencode deepseek --model deepseek/deepseek-v4-flash-0731 --auth-provider openrouter
+  agents harness fork deepseek deepseek-chat --model deepseek/deepseek-chat-v3
+
   # Per-run model override still wins
   agents run spark --model opencode/big-pickle "quick pass"
 
@@ -66,6 +140,48 @@ Examples:
             process.exit(1);
         }
     });
+    cmd
+        .command('fork <source> <name>')
+        .description('Fork a native harness (claude, opencode, ...) or an existing custom one into a new named harness.')
+        .option('--model <id>', 'Model to pin on the fork (required when forking a native harness)')
+        .option('--base-url <url>', 'Custom endpoint base URL (claude/codex hosts)')
+        .option('--auth-provider <provider>', 'Attach a keychain-backed API key under this provider')
+        .option('--version <version>', 'Pin the host CLI version (e.g., 1.16.0)')
+        .option('--label <text>', 'Human-facing name shown by `agents view` (defaults to <name>)')
+        .option('--description <text>', 'One-line description')
+        .option('--key-stdin', 'Read the API key from stdin instead of prompting (for scripts/CI)')
+        .option('--force', 'Overwrite an existing harness with the same name')
+        .addHelpText('after', `
+Examples:
+  # Fork OpenCode into a harness pinned to a DeepSeek model on OpenRouter
+  agents harness fork opencode deepseek --model deepseek/deepseek-v4-flash-0731 --auth-provider openrouter
+
+  # Fork Claude Code onto a private gateway
+  agents harness fork claude corp --model gpt-x --base-url https://gw.corp/v1 --auth-provider corp
+
+  # Copy an existing harness and swap only the model
+  agents harness fork deepseek deepseek-chat --model deepseek/deepseek-chat-v3
+`)
+        .action(async (source, name, opts) => {
+        try {
+            validateProfileName(name);
+            if (profileExists(name) && !opts.force) {
+                throw new Error(`Harness '${name}' already exists. Use --force to overwrite.`);
+            }
+            // Build first so a bad source/flag combination fails before prompting
+            // for a key the user would then have stored for nothing.
+            const forked = buildFork(source, name, opts);
+            if (opts.authProvider)
+                await ensureProviderToken(opts.authProvider, undefined, opts.keyStdin);
+            writeProfile(forked);
+            console.log(chalk.green(`Harness '${name}' forked from ${source}.`));
+            console.log(chalk.gray(`Try: agents run ${name} "hello"`));
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
     cmd
         .command('list')
         .alias('ls')
@@ -114,16 +230,7 @@ Examples:
         .description('Show one custom harness (host, model, provider, auth, path).')
         .action((name) => {
         try {
-            const p = readProfile(name);
-            console.log(chalk.bold(p.name));
-            if (p.description)
-                console.log(chalk.gray(p.description));
-            console.log('');
-            console.log(`Host:     ${profileHostLabel(p)}`);
-            console.log(`Model:    ${profileModelLabel(p)}`);
-            console.log(`Provider: ${profileProviderLabel(p)}`);
-            console.log(`Auth:     ${profileAuthLabel(p)}`);
-            console.log(chalk.gray(getProfilePath(p.name)));
+            renderHarnessDetail(name);
         }
         catch (err) {
             console.error(chalk.red(err.message));

package/dist/commands/hooks.js

@@ -603,30 +603,46 @@ Examples:
         .option('--warn-ms <n>', 'p99 threshold above which a hook is flagged as slow', '2000')
         .option('--json', 'Emit raw JSON rows instead of the table')
         .addHelpText('after', `
-Shows aggregated stats for every hook that emitted a hook.fire event into
-~/.agents/.cache/logs/events-YYYY-MM-DD.jsonl. Only hooks with \`cache:\` in
-their manifest are instrumented today — the generated shim writes the events.
+Shows aggregated stats for every hook that fired through a generated shim.
+Primary source: disposable SQLite warehouse ~/.agents/.cache/perf/perf.db
+(same data as \`agents perf hooks\`). Falls back to the legacy daily JSONL under
+~/.agents/.cache/logs/ when the warehouse is empty.
 
 Examples:
   agents hooks profile                # last 7 days, table form
   agents hooks profile --days 30      # roll up the full month
   agents hooks profile --json | jq    # pipe somewhere
+  agents perf hooks                   # same rollup under the perf surface
 
 A hook whose p99 exceeds --warn-ms gets flagged in the cache column. Add
 'cache: 5m' or 'cache: 5m-bg' to its hooks.yaml entry to fix it.
 `)
         .action(async (options) => {
         const { aggregateHookProfile, loadHookFireEvents, formatMs, formatCacheColumn, DEFAULT_SLOW_HOOK_WARN_MS } = await import('../lib/hooks/profile.js');
+        const { aggregateSamples } = await import('../lib/perf/db.js');
         const days = Math.max(1, parseInt(options.days, 10) || 7);
         const warnMs = Math.max(0, parseInt(options.warnMs, 10) || DEFAULT_SLOW_HOOK_WARN_MS);
-        const rows = aggregateHookProfile(loadHookFireEvents(days));
+        // Prefer the indexed warehouse; fall back to legacy JSONL for pre-warehouse shims.
+        const fromDb = aggregateSamples({ days, kinds: ['hook.fire'] }).map((r) => ({
+            hook: r.label,
+            n: r.n,
+            p50Ms: r.p50Ms,
+            p99Ms: r.p99Ms,
+            meanMs: r.meanMs,
+            maxMs: r.maxMs,
+            cacheHitPct: r.cacheHitPct ?? 0,
+            cacheStalePct: r.cacheStalePct ?? 0,
+            cacheMissPct: r.cacheMissPct ?? 0,
+            errorCount: r.errorCount ?? 0,
+        }));
+        const rows = fromDb.length > 0 ? fromDb : aggregateHookProfile(loadHookFireEvents(days));
         if (options.json) {
             console.log(JSON.stringify(rows, null, 2));
             return;
         }
         if (rows.length === 0) {
-            console.log(chalk.gray(`No hook.fire events in the last ${days} day${days === 1 ? '' : 's'}.`));
-            console.log(chalk.gray('Add \'cache: 5m\' to a hook in hooks.yaml to start collecting stats.'));
+            console.log(chalk.gray(`No hook.fire samples in the last ${days} day${days === 1 ? '' : 's'}.`));
+            console.log(chalk.gray('Add \'cache: 5m\' to a hook (or matches:) so a shim instruments it, then resync.'));
             return;
         }
         const widths = { hook: 36, n: 5, p50: 7, p99: 7, mean: 7, max: 7, cache: 30 };

package/dist/commands/perf.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `agents perf` — latency rollups over the disposable perf SQLite warehouse.
+ *
+ * Subcommands:
+ *   agents perf              multi-section summary (commands + hooks + runs)
+ *   agents perf hooks        per-hook p50/p99 + cache hit rates
+ *   agents perf commands     slowest CLI command paths (from command.end)
+ *   agents perf run          agent.run / perf.timing labels
+ *
+ * Soft-joins sessions.db via shared string keys (session_id, agent, machine) —
+ * no foreign keys. Warehouse lives at ~/.agents/.cache/perf/perf.db (safe to wipe).
+ */
+import type { Command } from 'commander';
+export declare function registerPerfCommand(program: Command): void;

package/dist/commands/perf.js

@@ -0,0 +1,221 @@
+/**
+ * `agents perf` — latency rollups over the disposable perf SQLite warehouse.
+ *
+ * Subcommands:
+ *   agents perf              multi-section summary (commands + hooks + runs)
+ *   agents perf hooks        per-hook p50/p99 + cache hit rates
+ *   agents perf commands     slowest CLI command paths (from command.end)
+ *   agents perf run          agent.run / perf.timing labels
+ *
+ * Soft-joins sessions.db via shared string keys (session_id, agent, machine) —
+ * no foreign keys. Warehouse lives at ~/.agents/.cache/perf/perf.db (safe to wipe).
+ */
+import chalk from 'chalk';
+import { aggregateSamples, perfDbPath, } from '../lib/perf/db.js';
+import { formatMs, formatCacheColumn, DEFAULT_SLOW_HOOK_WARN_MS, loadHookFireEvents, aggregateHookProfile, } from '../lib/hooks/profile.js';
+function parseDays(raw) {
+    const n = parseInt(raw ?? '7', 10);
+    return Number.isFinite(n) && n > 0 ? n : 7;
+}
+function parseWarnMs(raw, fallback) {
+    const n = parseInt(raw ?? String(fallback), 10);
+    return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
+function parseLimit(raw, fallback) {
+    const n = parseInt(raw ?? String(fallback), 10);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+/** Map warehouse rows shaped like hook.fire into the existing HookProfileRow UI. */
+function asHookRows(rows) {
+    return rows.map((r) => ({
+        hook: r.label,
+        n: r.n,
+        p50Ms: r.p50Ms,
+        p99Ms: r.p99Ms,
+        meanMs: r.meanMs,
+        maxMs: r.maxMs,
+        cacheHitPct: r.cacheHitPct ?? 0,
+        cacheStalePct: r.cacheStalePct ?? 0,
+        cacheMissPct: r.cacheMissPct ?? 0,
+        errorCount: r.errorCount ?? 0,
+    }));
+}
+function printTable(headers, widths, lines, slowFlags) {
+    const pad = (s, w) => (s.length >= w ? s.slice(0, w) : s + ' '.repeat(w - s.length));
+    const header = headers.map((h, i) => pad(h, widths[i])).join(' ');
+    console.log(chalk.bold(header));
+    console.log(chalk.gray('─'.repeat(header.length)));
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].map((c, j) => pad(c, widths[j])).join(' ');
+        console.log(slowFlags[i] ? chalk.yellow(line) : line);
+    }
+}
+function renderHookTable(rows, warnMs) {
+    if (rows.length === 0) {
+        console.log(chalk.gray('No hook timing samples yet.'));
+        console.log(chalk.gray(`Warehouse: ${perfDbPath()}`));
+        console.log(chalk.gray('Hooks write via cache/matches shims into the spool; run a session or resync hooks.'));
+        return;
+    }
+    const widths = { hook: 36, n: 5, p50: 7, p99: 7, mean: 7, max: 7, cache: 28 };
+    const pad = (s, w) => (s.length >= w ? s.slice(0, w) : s + ' '.repeat(w - s.length));
+    const header = [
+        pad('HOOK', widths.hook),
+        pad('N', widths.n),
+        pad('P50', widths.p50),
+        pad('P99', widths.p99),
+        pad('MEAN', widths.mean),
+        pad('MAX', widths.max),
+        pad('CACHE', widths.cache),
+    ].join(' ');
+    console.log(chalk.bold(header));
+    console.log(chalk.gray('─'.repeat(header.length)));
+    for (const r of rows) {
+        const slow = r.p99Ms > warnMs;
+        const cacheCol = formatCacheColumn(r);
+        const warning = slow && r.cacheHitPct + r.cacheStalePct === 0 ? '  ← add cache: 5m' : '';
+        const line = [
+            pad(r.hook, widths.hook),
+            pad(String(r.n), widths.n),
+            pad(formatMs(r.p50Ms), widths.p50),
+            pad(formatMs(r.p99Ms), widths.p99),
+            pad(formatMs(r.meanMs), widths.mean),
+            pad(formatMs(r.maxMs), widths.max),
+            pad(cacheCol, widths.cache),
+        ].join(' ') + warning;
+        console.log(slow ? chalk.yellow(line) : line);
+    }
+}
+function renderLabelTable(title, rows, warnMs, limit) {
+    const sliced = rows.slice(0, limit);
+    if (sliced.length === 0) {
+        console.log(chalk.gray(`No ${title} samples yet.`));
+        return;
+    }
+    const widths = [40, 5, 7, 7, 7, 7];
+    printTable(['LABEL', 'N', 'P50', 'P99', 'MEAN', 'MAX'], widths, sliced.map((r) => [
+        r.label,
+        String(r.n),
+        formatMs(r.p50Ms),
+        formatMs(r.p99Ms),
+        formatMs(r.meanMs),
+        formatMs(r.maxMs),
+    ]), sliced.map((r) => r.p99Ms > warnMs));
+}
+/**
+ * Prefer SQLite samples; fall back to the legacy daily JSONL so existing
+ * instrumentation still surfaces until shims are resynced.
+ */
+function loadHookProfile(days) {
+    const fromDb = asHookRows(aggregateSamples({ days, kinds: ['hook.fire'] }));
+    if (fromDb.length > 0)
+        return fromDb;
+    return aggregateHookProfile(loadHookFireEvents(days));
+}
+function hooksAction(opts) {
+    const days = parseDays(opts.days);
+    const warnMs = parseWarnMs(opts.warnMs, DEFAULT_SLOW_HOOK_WARN_MS);
+    const rows = loadHookProfile(days);
+    if (opts.json) {
+        console.log(JSON.stringify(rows, null, 2));
+        return;
+    }
+    renderHookTable(rows, warnMs);
+}
+function commandsAction(opts) {
+    const days = parseDays(opts.days);
+    const warnMs = parseWarnMs(opts.warnMs, 500);
+    const limit = parseLimit(opts.limit, 40);
+    const rows = aggregateSamples({ days, kinds: ['command.end'] });
+    if (opts.json) {
+        console.log(JSON.stringify(rows.slice(0, limit), null, 2));
+        return;
+    }
+    renderLabelTable('command', rows, warnMs, limit);
+}
+function runAction(opts) {
+    const days = parseDays(opts.days);
+    const warnMs = parseWarnMs(opts.warnMs, 60_000);
+    const limit = parseLimit(opts.limit, 40);
+    const rows = aggregateSamples({ days, kinds: ['perf.timing'] });
+    if (opts.json) {
+        console.log(JSON.stringify(rows.slice(0, limit), null, 2));
+        return;
+    }
+    renderLabelTable('run/timing', rows, warnMs, limit);
+}
+function summaryAction(opts) {
+    const days = parseDays(opts.days);
+    if (opts.json) {
+        console.log(JSON.stringify({
+            days,
+            warehouse: perfDbPath(),
+            hooks: loadHookProfile(days),
+            commands: aggregateSamples({ days, kinds: ['command.end'] }).slice(0, 20),
+            run: aggregateSamples({ days, kinds: ['perf.timing'] }).slice(0, 20),
+        }, null, 2));
+        return;
+    }
+    console.log(chalk.bold(`agents perf — last ${days} day${days === 1 ? '' : 's'}`));
+    console.log(chalk.gray(`warehouse: ${perfDbPath()}  (disposable; soft-join sessions via session_id/agent/machine)`));
+    console.log('');
+    console.log(chalk.bold('Commands (slowest by p99)'));
+    renderLabelTable('command', aggregateSamples({ days, kinds: ['command.end'] }), parseWarnMs(opts.warnMs, 500), 12);
+    console.log('');
+    console.log(chalk.bold('Hooks'));
+    renderHookTable(loadHookProfile(days), parseWarnMs(opts.warnMs, DEFAULT_SLOW_HOOK_WARN_MS));
+    console.log('');
+    console.log(chalk.bold('Runs (perf.timing)'));
+    renderLabelTable('run/timing', aggregateSamples({ days, kinds: ['perf.timing'] }), parseWarnMs(opts.warnMs, 60_000), 12);
+}
+function attachSharedOptions(cmd) {
+    return cmd
+        .option('--days <n>', 'Days of samples to include', '7')
+        .option('--warn-ms <n>', 'p99 above this is highlighted')
+        .option('--limit <n>', 'Max rows in the table', '40')
+        .option('--json', 'Emit JSON instead of a table');
+}
+/**
+ * Commander binds a flag declared on both parent and child to the *parent*.
+ * Merge so `agents perf commands --json` still sees json:true on the leaf.
+ */
+function leafOpts(cmd) {
+    const parent = cmd.parent && typeof cmd.parent.opts === 'function'
+        ? cmd.parent.opts()
+        : {};
+    return { ...parent, ...cmd.opts() };
+}
+export function registerPerfCommand(program) {
+    const perf = program
+        .command('perf')
+        .description('Latency rollups from the disposable perf warehouse (hooks, commands, runs)')
+        .addHelpText('after', `
+The warehouse is SQLite at ~/.agents/.cache/perf/perf.db — safe to delete.
+Identity columns reuse sessions/events string shapes (session_id, agent, machine)
+for soft cross-reference; there are no foreign keys.
+
+Examples:
+  agents perf                     # summary: commands + hooks + runs
+  agents perf hooks               # per-hook p50/p99 + cache hit rate
+  agents perf commands --days 30  # slowest CLI entrypoints
+  agents perf run --json          # agent.run timings as JSON
+  agents perf hooks --warn-ms 500
+`);
+    // Options live on the parent so `agents perf --json` and
+    // `agents perf commands --json` both work (see leafOpts).
+    attachSharedOptions(perf).action(function summary() {
+        summaryAction(this.opts());
+    });
+    perf.command('hooks').description('Per-hook timing + cache stats')
+        .action(function hooks() {
+        hooksAction(leafOpts(this));
+    });
+    perf.command('commands').description('Slowest CLI command paths (command.end samples)')
+        .action(function commands() {
+        commandsAction(leafOpts(this));
+    });
+    perf.command('run').description('agent.run / perf.timing label rollups')
+        .action(function run() {
+        runAction(leafOpts(this));
+    });
+}

package/dist/commands/profiles.d.ts

@@ -15,6 +15,9 @@ import { type Preset } from '../lib/profiles-presets.js';
  * without mocking @inquirer/prompts.
  */
 export declare function buildProfileFromCollection(name: string, preset: Preset, collected: Record<string, string>, version?: string): Profile;
+/** Read all available data from stdin synchronously, trimmed. */
+/** Ensure a provider API key exists in keychain, prompting or reading stdin if missing. */
+export declare function ensureProviderToken(provider: string, signupUrl?: string, fromStdin?: boolean): Promise<void>;
 /** Options accepted by {@link addProfile} — shared by `agents profiles add` and `agents harness add`. */
 export interface AddProfileOptions {
     preset?: string;

package/dist/commands/profiles.js

@@ -47,7 +47,7 @@ async function promptForSecret(message) {
 }
 /** Read all available data from stdin synchronously, trimmed. */
 /** Ensure a provider API key exists in keychain, prompting or reading stdin if missing. */
-async function ensureProviderToken(provider, signupUrl, fromStdin) {
+export async function ensureProviderToken(provider, signupUrl, fromStdin) {
     const item = keychainItemName(provider);
     if (hasKeychainToken(item)) {
         return;

package/dist/commands/routines.d.ts

@@ -14,10 +14,29 @@ import type { DeviceRegistry } from '../lib/devices/registry.js';
  * callers drop it straight into a status line.
  */
 export declare function formatRunDuration(startedAt: string, completedAt: string | null): string;
+/**
+ * The last run THIS device can speak for.
+ *
+ * A run record is written by whichever daemon fired the routine, into that
+ * machine's own runs dir — records carry no device attribution, so a record
+ * found here only ever describes this device's history. When a routine is
+ * pinned away from this machine (`devices:` excludes it) any local record is a
+ * leftover from before the pin, and reporting it as the routine's status paints
+ * another device's healthy routine red. Report nothing instead; the local
+ * history stays readable via `agents routines runs <name>`, and the owning
+ * device's status via `agents routines list --device <name>`.
+ */
+export declare function localLatestRun(job: JobConfig): RunMeta | null;
 export interface RoutineListGroup {
     key: string;
     title: string;
     jobs: JobConfig[];
+    /**
+     * Whether this device's run records describe the group. False for a
+     * `Device: <peer>` group — the rows are the same routine seen from a machine
+     * that does not fire it there, so Last Status is not ours to report.
+     */
+    local: boolean;
 }
 export declare function groupRoutineJobsByDevice(jobs: JobConfig[], registry: DeviceRegistry, self?: string): RoutineListGroup[];
 export declare function buildRunsJson(runs: RunMeta[]): Record<string, unknown>[];