@matthesketh/fleet 1.1.0 → 1.6.0

package/dist/core/routines/schema.d.ts

@@ -0,0 +1,418 @@
+import { z } from 'zod';
+export declare const RoutineTaskSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"claude-cli">;
+    prompt: z.ZodString;
+    outputFormat: z.ZodDefault<z.ZodLiteral<"json">>;
+    tokenCap: z.ZodDefault<z.ZodNumber>;
+    wallClockMs: z.ZodDefault<z.ZodNumber>;
+    maxUsd: z.ZodDefault<z.ZodNumber>;
+    model: z.ZodOptional<z.ZodString>;
+    appendSystem: z.ZodOptional<z.ZodString>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    kind: "claude-cli";
+    prompt: string;
+    outputFormat: "json";
+    tokenCap: number;
+    wallClockMs: number;
+    maxUsd: number;
+    model?: string | undefined;
+    appendSystem?: string | undefined;
+    allowedTools?: string[] | undefined;
+}, {
+    kind: "claude-cli";
+    prompt: string;
+    outputFormat?: "json" | undefined;
+    tokenCap?: number | undefined;
+    wallClockMs?: number | undefined;
+    maxUsd?: number | undefined;
+    model?: string | undefined;
+    appendSystem?: string | undefined;
+    allowedTools?: string[] | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"shell">;
+    argv: z.ZodArray<z.ZodString, "many">;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    wallClockMs: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    kind: "shell";
+    wallClockMs: number;
+    argv: string[];
+    env?: Record<string, string> | undefined;
+}, {
+    kind: "shell";
+    argv: string[];
+    env?: Record<string, string> | undefined;
+    wallClockMs?: number | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"mcp-call">;
+    tool: z.ZodString;
+    args: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    wallClockMs: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    kind: "mcp-call";
+    wallClockMs: number;
+    tool: string;
+    args: Record<string, unknown>;
+}, {
+    kind: "mcp-call";
+    tool: string;
+    wallClockMs?: number | undefined;
+    args?: Record<string, unknown> | undefined;
+}>]>;
+export type RoutineTask = z.infer<typeof RoutineTaskSchema>;
+export declare const NotifyConfigSchema: z.ZodObject<{
+    kind: z.ZodEnum<["stdout", "webhook", "slack", "email"]>;
+    on: z.ZodDefault<z.ZodEnum<["always", "failure", "success"]>>;
+    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    config: Record<string, unknown>;
+    kind: "email" | "stdout" | "webhook" | "slack";
+    on: "always" | "failure" | "success";
+}, {
+    kind: "email" | "stdout" | "webhook" | "slack";
+    config?: Record<string, unknown> | undefined;
+    on?: "always" | "failure" | "success" | undefined;
+}>;
+export declare const RoutineScheduleSchema: z.ZodUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"manual">;
+}, "strip", z.ZodTypeAny, {
+    kind: "manual";
+}, {
+    kind: "manual";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"calendar">;
+    onCalendar: z.ZodString;
+    randomizedDelaySec: z.ZodDefault<z.ZodNumber>;
+    persistent: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    kind: "calendar";
+    onCalendar: string;
+    randomizedDelaySec: number;
+    persistent: boolean;
+}, {
+    kind: "calendar";
+    onCalendar: string;
+    randomizedDelaySec?: number | undefined;
+    persistent?: boolean | undefined;
+}>]>;
+export type RoutineSchedule = z.infer<typeof RoutineScheduleSchema>;
+export declare const RoutineSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodDefault<z.ZodString>;
+    schedule: z.ZodUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"manual">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "manual";
+    }, {
+        kind: "manual";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"calendar">;
+        onCalendar: z.ZodString;
+        randomizedDelaySec: z.ZodDefault<z.ZodNumber>;
+        persistent: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "calendar";
+        onCalendar: string;
+        randomizedDelaySec: number;
+        persistent: boolean;
+    }, {
+        kind: "calendar";
+        onCalendar: string;
+        randomizedDelaySec?: number | undefined;
+        persistent?: boolean | undefined;
+    }>]>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    targets: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    perTarget: z.ZodDefault<z.ZodBoolean>;
+    task: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"claude-cli">;
+        prompt: z.ZodString;
+        outputFormat: z.ZodDefault<z.ZodLiteral<"json">>;
+        tokenCap: z.ZodDefault<z.ZodNumber>;
+        wallClockMs: z.ZodDefault<z.ZodNumber>;
+        maxUsd: z.ZodDefault<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodString>;
+        appendSystem: z.ZodOptional<z.ZodString>;
+        allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "claude-cli";
+        prompt: string;
+        outputFormat: "json";
+        tokenCap: number;
+        wallClockMs: number;
+        maxUsd: number;
+        model?: string | undefined;
+        appendSystem?: string | undefined;
+        allowedTools?: string[] | undefined;
+    }, {
+        kind: "claude-cli";
+        prompt: string;
+        outputFormat?: "json" | undefined;
+        tokenCap?: number | undefined;
+        wallClockMs?: number | undefined;
+        maxUsd?: number | undefined;
+        model?: string | undefined;
+        appendSystem?: string | undefined;
+        allowedTools?: string[] | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"shell">;
+        argv: z.ZodArray<z.ZodString, "many">;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        wallClockMs: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "shell";
+        wallClockMs: number;
+        argv: string[];
+        env?: Record<string, string> | undefined;
+    }, {
+        kind: "shell";
+        argv: string[];
+        env?: Record<string, string> | undefined;
+        wallClockMs?: number | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"mcp-call">;
+        tool: z.ZodString;
+        args: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        wallClockMs: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "mcp-call";
+        wallClockMs: number;
+        tool: string;
+        args: Record<string, unknown>;
+    }, {
+        kind: "mcp-call";
+        tool: string;
+        wallClockMs?: number | undefined;
+        args?: Record<string, unknown> | undefined;
+    }>]>;
+    notify: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["stdout", "webhook", "slack", "email"]>;
+        on: z.ZodDefault<z.ZodEnum<["always", "failure", "success"]>>;
+        config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        config: Record<string, unknown>;
+        kind: "email" | "stdout" | "webhook" | "slack";
+        on: "always" | "failure" | "success";
+    }, {
+        kind: "email" | "stdout" | "webhook" | "slack";
+        config?: Record<string, unknown> | undefined;
+        on?: "always" | "failure" | "success" | undefined;
+    }>, "many">>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    name: string;
+    id: string;
+    description: string;
+    schedule: {
+        kind: "manual";
+    } | {
+        kind: "calendar";
+        onCalendar: string;
+        randomizedDelaySec: number;
+        persistent: boolean;
+    };
+    targets: string[];
+    perTarget: boolean;
+    task: {
+        kind: "claude-cli";
+        prompt: string;
+        outputFormat: "json";
+        tokenCap: number;
+        wallClockMs: number;
+        maxUsd: number;
+        model?: string | undefined;
+        appendSystem?: string | undefined;
+        allowedTools?: string[] | undefined;
+    } | {
+        kind: "shell";
+        wallClockMs: number;
+        argv: string[];
+        env?: Record<string, string> | undefined;
+    } | {
+        kind: "mcp-call";
+        wallClockMs: number;
+        tool: string;
+        args: Record<string, unknown>;
+    };
+    notify: {
+        config: Record<string, unknown>;
+        kind: "email" | "stdout" | "webhook" | "slack";
+        on: "always" | "failure" | "success";
+    }[];
+    tags: string[];
+    updatedAt?: string | undefined;
+    createdAt?: string | undefined;
+}, {
+    name: string;
+    id: string;
+    schedule: {
+        kind: "manual";
+    } | {
+        kind: "calendar";
+        onCalendar: string;
+        randomizedDelaySec?: number | undefined;
+        persistent?: boolean | undefined;
+    };
+    task: {
+        kind: "claude-cli";
+        prompt: string;
+        outputFormat?: "json" | undefined;
+        tokenCap?: number | undefined;
+        wallClockMs?: number | undefined;
+        maxUsd?: number | undefined;
+        model?: string | undefined;
+        appendSystem?: string | undefined;
+        allowedTools?: string[] | undefined;
+    } | {
+        kind: "shell";
+        argv: string[];
+        env?: Record<string, string> | undefined;
+        wallClockMs?: number | undefined;
+    } | {
+        kind: "mcp-call";
+        tool: string;
+        wallClockMs?: number | undefined;
+        args?: Record<string, unknown> | undefined;
+    };
+    enabled?: boolean | undefined;
+    updatedAt?: string | undefined;
+    description?: string | undefined;
+    targets?: string[] | undefined;
+    perTarget?: boolean | undefined;
+    notify?: {
+        kind: "email" | "stdout" | "webhook" | "slack";
+        config?: Record<string, unknown> | undefined;
+        on?: "always" | "failure" | "success" | undefined;
+    }[] | undefined;
+    tags?: string[] | undefined;
+    createdAt?: string | undefined;
+}>;
+export type Routine = z.infer<typeof RoutineSchema>;
+export declare const RunStatusSchema: z.ZodEnum<["queued", "running", "ok", "failed", "timeout", "aborted"]>;
+export type RunStatus = z.infer<typeof RunStatusSchema>;
+export declare const RunEventSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"start">;
+    routineId: z.ZodString;
+    target: z.ZodNullable<z.ZodString>;
+    at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    kind: "start";
+    routineId: string;
+    target: string | null;
+}, {
+    at: string;
+    kind: "start";
+    routineId: string;
+    target: string | null;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"stdout">;
+    chunk: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "stdout";
+    chunk: string;
+}, {
+    kind: "stdout";
+    chunk: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"stderr">;
+    chunk: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "stderr";
+    chunk: string;
+}, {
+    kind: "stderr";
+    chunk: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"tool-call">;
+    name: z.ZodString;
+    argsPreview: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    kind: "tool-call";
+    argsPreview?: string | undefined;
+}, {
+    name: string;
+    kind: "tool-call";
+    argsPreview?: string | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"cost">;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    cacheCreateTokens: z.ZodDefault<z.ZodNumber>;
+    cacheReadTokens: z.ZodDefault<z.ZodNumber>;
+    usd: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    kind: "cost";
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreateTokens: number;
+    cacheReadTokens: number;
+    usd: number;
+}, {
+    kind: "cost";
+    inputTokens: number;
+    outputTokens: number;
+    usd: number;
+    cacheCreateTokens?: number | undefined;
+    cacheReadTokens?: number | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"end">;
+    status: z.ZodEnum<["queued", "running", "ok", "failed", "timeout", "aborted"]>;
+    exitCode: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    at: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    status: "timeout" | "ok" | "failed" | "aborted" | "queued" | "running";
+    kind: "end";
+    exitCode: number;
+    durationMs: number;
+    error?: string | undefined;
+}, {
+    at: string;
+    status: "timeout" | "ok" | "failed" | "aborted" | "queued" | "running";
+    kind: "end";
+    exitCode: number;
+    durationMs: number;
+    error?: string | undefined;
+}>]>;
+export type RunEvent = z.infer<typeof RunEventSchema>;
+export declare const SignalKindSchema: z.ZodEnum<["git-clean", "git-ahead", "git-behind", "open-prs", "pr-age-max", "deps-outdated", "deps-vulns", "build-ok", "tests-ok", "env-schema-ok", "container-up", "ci-status", "cache-age"]>;
+export type SignalKind = z.infer<typeof SignalKindSchema>;
+export declare const SignalStateSchema: z.ZodEnum<["ok", "warn", "error", "unknown"]>;
+export type SignalState = z.infer<typeof SignalStateSchema>;
+export declare const SignalSchema: z.ZodObject<{
+    repo: z.ZodString;
+    kind: z.ZodEnum<["git-clean", "git-ahead", "git-behind", "open-prs", "pr-age-max", "deps-outdated", "deps-vulns", "build-ok", "tests-ok", "env-schema-ok", "container-up", "ci-status", "cache-age"]>;
+    state: z.ZodEnum<["ok", "warn", "error", "unknown"]>;
+    value: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+    detail: z.ZodDefault<z.ZodString>;
+    collectedAt: z.ZodString;
+    ttlMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    detail: string;
+    kind: "git-clean" | "git-ahead" | "git-behind" | "open-prs" | "pr-age-max" | "deps-outdated" | "deps-vulns" | "build-ok" | "tests-ok" | "env-schema-ok" | "container-up" | "ci-status" | "cache-age";
+    value: string | number | boolean | null;
+    repo: string;
+    state: "warn" | "error" | "unknown" | "ok";
+    collectedAt: string;
+    ttlMs: number;
+}, {
+    kind: "git-clean" | "git-ahead" | "git-behind" | "open-prs" | "pr-age-max" | "deps-outdated" | "deps-vulns" | "build-ok" | "tests-ok" | "env-schema-ok" | "container-up" | "ci-status" | "cache-age";
+    value: string | number | boolean | null;
+    repo: string;
+    state: "warn" | "error" | "unknown" | "ok";
+    collectedAt: string;
+    ttlMs: number;
+    detail?: string | undefined;
+}>;
+export type Signal = z.infer<typeof SignalSchema>;
+export declare function validateRoutine(input: unknown): Routine;
+export declare function isExpired(signal: Signal, now?: number): boolean;

package/dist/core/routines/schema.js

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+const ROUTINE_ID_REGEX = /^[a-z][a-z0-9-]{0,62}$/;
+const NO_SHELL_META = /^[^`$;&|><\n\r\\"]*$/;
+const DEFAULT_WALLCLOCK_MS = 15 * 60 * 1000;
+const DEFAULT_TOKEN_CAP = 100_000;
+const DEFAULT_MAX_USD = 5;
+export const RoutineTaskSchema = z.discriminatedUnion('kind', [
+    z.object({
+        kind: z.literal('claude-cli'),
+        prompt: z.string().min(1).max(8000),
+        outputFormat: z.literal('json').default('json'),
+        tokenCap: z.number().int().positive().max(1_000_000).default(DEFAULT_TOKEN_CAP),
+        wallClockMs: z.number().int().positive().max(60 * 60 * 1000).default(DEFAULT_WALLCLOCK_MS),
+        maxUsd: z.number().positive().max(100).default(DEFAULT_MAX_USD),
+        model: z.string().optional(),
+        appendSystem: z.string().max(2000).optional(),
+        allowedTools: z.array(z.string().regex(/^[A-Za-z0-9_:*\-]+$/)).optional(),
+    }),
+    z.object({
+        kind: z.literal('shell'),
+        argv: z.array(z.string().min(1).regex(NO_SHELL_META)).min(1).max(64),
+        env: z.record(z.string().regex(/^[A-Z_][A-Z0-9_]*$/), z.string()).optional(),
+        wallClockMs: z.number().int().positive().max(60 * 60 * 1000).default(DEFAULT_WALLCLOCK_MS),
+    }),
+    z.object({
+        kind: z.literal('mcp-call'),
+        tool: z.string().regex(/^[a-z][a-z0-9_.-]*$/i),
+        args: z.record(z.string(), z.unknown()).default({}),
+        wallClockMs: z.number().int().positive().max(60 * 60 * 1000).default(DEFAULT_WALLCLOCK_MS),
+    }),
+]);
+export const NotifyConfigSchema = z.object({
+    kind: z.enum(['stdout', 'webhook', 'slack', 'email']),
+    on: z.enum(['always', 'failure', 'success']).default('failure'),
+    config: z.record(z.string(), z.unknown()).default({}),
+});
+export const RoutineScheduleSchema = z.union([
+    z.object({ kind: z.literal('manual') }),
+    z.object({
+        kind: z.literal('calendar'),
+        onCalendar: z.string().min(1).max(200),
+        randomizedDelaySec: z.number().int().nonnegative().max(3600).default(0),
+        persistent: z.boolean().default(true),
+    }),
+]);
+export const RoutineSchema = z.object({
+    id: z.string().regex(ROUTINE_ID_REGEX, 'lowercase alphanumeric and dashes only'),
+    name: z.string().min(1).max(100),
+    description: z.string().max(2000).default(''),
+    schedule: RoutineScheduleSchema,
+    enabled: z.boolean().default(true),
+    targets: z.array(z.string().min(1)).default([]),
+    perTarget: z.boolean().default(false),
+    task: RoutineTaskSchema,
+    notify: z.array(NotifyConfigSchema).default([]),
+    tags: z.array(z.string().max(32)).max(16).default([]),
+    createdAt: z.string().datetime().optional(),
+    updatedAt: z.string().datetime().optional(),
+});
+export const RunStatusSchema = z.enum(['queued', 'running', 'ok', 'failed', 'timeout', 'aborted']);
+export const RunEventSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('start'), routineId: z.string(), target: z.string().nullable(), at: z.string().datetime() }),
+    z.object({ kind: z.literal('stdout'), chunk: z.string() }),
+    z.object({ kind: z.literal('stderr'), chunk: z.string() }),
+    z.object({ kind: z.literal('tool-call'), name: z.string(), argsPreview: z.string().max(500).optional() }),
+    z.object({
+        kind: z.literal('cost'),
+        inputTokens: z.number().int().nonnegative(),
+        outputTokens: z.number().int().nonnegative(),
+        cacheCreateTokens: z.number().int().nonnegative().default(0),
+        cacheReadTokens: z.number().int().nonnegative().default(0),
+        usd: z.number().nonnegative(),
+    }),
+    z.object({
+        kind: z.literal('end'),
+        status: RunStatusSchema,
+        exitCode: z.number().int(),
+        durationMs: z.number().int().nonnegative(),
+        at: z.string().datetime(),
+        error: z.string().optional(),
+    }),
+]);
+export const SignalKindSchema = z.enum([
+    'git-clean',
+    'git-ahead',
+    'git-behind',
+    'open-prs',
+    'pr-age-max',
+    'deps-outdated',
+    'deps-vulns',
+    'build-ok',
+    'tests-ok',
+    'env-schema-ok',
+    'container-up',
+    'ci-status',
+    'cache-age',
+]);
+export const SignalStateSchema = z.enum(['ok', 'warn', 'error', 'unknown']);
+export const SignalSchema = z.object({
+    repo: z.string(),
+    kind: SignalKindSchema,
+    state: SignalStateSchema,
+    value: z.union([z.string(), z.number(), z.boolean(), z.null()]),
+    detail: z.string().default(''),
+    collectedAt: z.string().datetime(),
+    ttlMs: z.number().int().nonnegative(),
+});
+export function validateRoutine(input) {
+    return RoutineSchema.parse(input);
+}
+export function isExpired(signal, now = Date.now()) {
+    return new Date(signal.collectedAt).getTime() + signal.ttlMs <= now;
+}

package/dist/core/routines/signals-collector.d.ts

@@ -0,0 +1,35 @@
+import type Database from 'better-sqlite3';
+import type { SignalProvider } from '../../adapters/types.js';
+import type { Signal, SignalKind } from './schema.js';
+export interface SignalTarget {
+    repoName: string;
+    repoPath: string;
+}
+export interface CollectorOptions {
+    providers: readonly SignalProvider[];
+    db: Database.Database;
+    concurrency?: number;
+    now?: () => number;
+}
+export interface CollectRequest {
+    target: SignalTarget;
+    kinds?: readonly SignalKind[];
+    force?: boolean;
+}
+export interface CollectSummary {
+    total: number;
+    fromCache: number;
+    collected: number;
+    errors: number;
+}
+export declare class SignalCollector {
+    private readonly providers;
+    private readonly db;
+    private readonly now;
+    private readonly concurrency;
+    constructor(opts: CollectorOptions);
+    readCached(repoName: string, kinds?: readonly SignalKind[]): Signal[];
+    private persist;
+    collect(requests: readonly CollectRequest[]): Promise<CollectSummary>;
+    snapshot(targets: readonly SignalTarget[]): Promise<Map<string, Signal[]>>;
+}

package/dist/core/routines/signals-collector.js

@@ -0,0 +1,114 @@
+function isFresh(signal, nowMs) {
+    return new Date(signal.collectedAt).getTime() + signal.ttlMs > nowMs;
+}
+function rowToSignal(row) {
+    let parsed = null;
+    if (row.value !== null) {
+        try {
+            parsed = JSON.parse(row.value);
+        }
+        catch {
+            parsed = row.value;
+        }
+    }
+    return {
+        repo: row.repo,
+        kind: row.kind,
+        state: row.state,
+        value: parsed,
+        detail: row.detail,
+        collectedAt: row.collected_at,
+        ttlMs: row.ttl_ms,
+    };
+}
+export class SignalCollector {
+    providers;
+    db;
+    now;
+    concurrency;
+    constructor(opts) {
+        this.providers = new Map(opts.providers.map(p => [p.kind, p]));
+        this.db = opts.db;
+        this.now = opts.now ?? (() => Date.now());
+        this.concurrency = opts.concurrency ?? 4;
+    }
+    readCached(repoName, kinds) {
+        const params = [repoName];
+        let sql = 'SELECT repo, kind, state, value, detail, collected_at, ttl_ms FROM signal_cache WHERE repo = ?';
+        if (kinds && kinds.length > 0) {
+            sql += ` AND kind IN (${kinds.map(() => '?').join(', ')})`;
+            params.push(...kinds);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(rowToSignal);
+    }
+    persist(signal) {
+        const stmt = this.db.prepare(`
+      INSERT INTO signal_cache (repo, kind, state, value, detail, collected_at, ttl_ms)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(repo, kind) DO UPDATE SET
+        state = excluded.state,
+        value = excluded.value,
+        detail = excluded.detail,
+        collected_at = excluded.collected_at,
+        ttl_ms = excluded.ttl_ms
+    `);
+        stmt.run(signal.repo, signal.kind, signal.state, signal.value === null ? null : JSON.stringify(signal.value), signal.detail, signal.collectedAt, signal.ttlMs);
+        this.db.prepare(`
+      INSERT INTO signal_history (repo, kind, state, value, detail, collected_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(signal.repo, signal.kind, signal.state, signal.value === null ? null : JSON.stringify(signal.value), signal.detail, signal.collectedAt);
+    }
+    async collect(requests) {
+        const summary = { total: 0, fromCache: 0, collected: 0, errors: 0 };
+        const queue = [];
+        const nowMs = this.now();
+        for (const req of requests) {
+            const kinds = req.kinds ?? Array.from(this.providers.keys());
+            const cached = req.force ? [] : this.readCached(req.target.repoName, kinds);
+            const cachedByKind = new Map(cached.map(s => [s.kind, s]));
+            for (const kind of kinds) {
+                summary.total++;
+                const c = cachedByKind.get(kind);
+                if (c && isFresh(c, nowMs)) {
+                    summary.fromCache++;
+                    continue;
+                }
+                const provider = this.providers.get(kind);
+                if (!provider)
+                    continue;
+                queue.push({ req, kind, provider });
+            }
+        }
+        let i = 0;
+        const workers = [];
+        for (let w = 0; w < Math.min(this.concurrency, queue.length); w++) {
+            workers.push((async () => {
+                while (true) {
+                    const idx = i++;
+                    if (idx >= queue.length)
+                        return;
+                    const { req, provider } = queue[idx];
+                    try {
+                        const signal = await provider.collect(req.target.repoPath, req.target.repoName);
+                        this.persist(signal);
+                        summary.collected++;
+                    }
+                    catch {
+                        summary.errors++;
+                    }
+                }
+            })());
+        }
+        await Promise.all(workers);
+        return summary;
+    }
+    async snapshot(targets) {
+        await this.collect(targets.map(target => ({ target })));
+        const result = new Map();
+        for (const target of targets) {
+            result.set(target.repoName, this.readCached(target.repoName));
+        }
+        return result;
+    }
+}