@hyperdrive.bot/paseo-cli 0.3.34 → 0.3.36

package/dist/cli.js

@@ -6,6 +6,7 @@ import { createLoopCommand } from "./commands/loop/index.js";
 import { createPermitCommand } from "./commands/permit/index.js";
 import { createProviderCommand } from "./commands/provider/index.js";
 import { createScheduleCommand } from "./commands/schedule/index.js";
+import { createFleetCommand } from "./commands/fleet/index.js";
 import { createSpeechCommand } from "./commands/speech/index.js";
 import { createTerminalCommand } from "./commands/terminal/index.js";
 import { createWorktreeCommand } from "./commands/worktree/index.js";
@@ -102,6 +103,8 @@ export function createCli() {
     program.addCommand(createLoopCommand());
     // Schedule commands
     program.addCommand(createScheduleCommand());
+    // Fleet (Loops) commands
+    program.addCommand(createFleetCommand());
     // Permission commands
     program.addCommand(createPermitCommand());
     // Provider commands

package/dist/commands/fleet/ask-options.d.ts

@@ -0,0 +1,39 @@
+import type { AskFleetDecisionInput } from "./types.js";
+export interface AskRow {
+    decision: string;
+    status: string;
+    chosen: string;
+    resolvedBy: string;
+}
+export interface ParsedAsk {
+    ask: AskFleetDecisionInput;
+    wait: boolean;
+    pollMs: number;
+}
+/**
+ * Parse a duration like `45m`, `2h`, `90s` into milliseconds. Loops declare windows in
+ * human units; the protocol stores milliseconds.
+ */
+export declare function parseDuration(input: string): number;
+/**
+ * Parse one `--option` flag: `id:Label:effectKind:reversibility[:compensating action]`.
+ *
+ * The reversibility is REQUIRED rather than defaulted, because it is what bounds the
+ * posture: defaulting it would let an author quietly ship an irreversible act under an
+ * advisory posture, which is the one combination that must never reach a human.
+ */
+export declare function parseOption(raw: string): AskFleetDecisionInput["options"][number];
+export declare function parseAskOptions(name: string, options: {
+    kind?: string;
+    question?: string;
+    posture?: string;
+    option?: string[];
+    onExpiry?: string;
+    expiresIn?: string;
+    itemKey?: string;
+    runId?: string;
+    evidence?: string;
+    wait?: boolean;
+    pollMs?: string;
+}): ParsedAsk;
+//# sourceMappingURL=ask-options.d.ts.map

package/dist/commands/fleet/ask-options.js

@@ -0,0 +1,88 @@
+const KINDS = new Set(["gate-approval", "action-approval", "outcome-review"]);
+const POSTURES = new Set(["blocking", "deferring", "advisory"]);
+const EFFECT_KINDS = new Set(["act", "rehearse", "defer", "suppress"]);
+const REVERSIBILITIES = new Set(["reversible", "compensable", "irreversible"]);
+/**
+ * Parse a duration like `45m`, `2h`, `90s` into milliseconds. Loops declare windows in
+ * human units; the protocol stores milliseconds.
+ */
+export function parseDuration(input) {
+    const match = /^(\d+)(ms|s|m|h|d)$/.exec(input.trim());
+    if (!match) {
+        throw new Error(`Invalid duration "${input}". Use forms like 90s, 45m, 2h, 1d.`);
+    }
+    const factors = {
+        ms: 1,
+        s: 1000,
+        m: 60000,
+        h: 3600000,
+        d: 86400000,
+    };
+    return Number(match[1]) * factors[match[2]];
+}
+/**
+ * Parse one `--option` flag: `id:Label:effectKind:reversibility[:compensating action]`.
+ *
+ * The reversibility is REQUIRED rather than defaulted, because it is what bounds the
+ * posture: defaulting it would let an author quietly ship an irreversible act under an
+ * advisory posture, which is the one combination that must never reach a human.
+ */
+export function parseOption(raw) {
+    const parts = raw.split(":");
+    if (parts.length < 4) {
+        throw new Error(`Invalid --option "${raw}". Expected id:Label:effect:reversibility[:compensating action]`);
+    }
+    const [id, label, effectKind, reversibility, ...rest] = parts;
+    if (!EFFECT_KINDS.has(effectKind)) {
+        throw new Error(`Invalid effect "${effectKind}" in --option "${raw}"`);
+    }
+    if (!REVERSIBILITIES.has(reversibility)) {
+        throw new Error(`Invalid reversibility "${reversibility}" in --option "${raw}"`);
+    }
+    const compensatingAction = rest.join(":").trim();
+    return {
+        id: id.trim(),
+        label: label.trim(),
+        effect: compensatingAction
+            ? {
+                kind: effectKind,
+                reversibility: reversibility,
+                compensatingAction,
+            }
+            : { kind: effectKind, reversibility: reversibility },
+    };
+}
+export function parseAskOptions(name, options) {
+    if (!options.question?.trim()) {
+        throw new Error("--question is required");
+    }
+    const kind = options.kind ?? "action-approval";
+    if (!KINDS.has(kind)) {
+        throw new Error(`Invalid --kind "${kind}". One of: ${[...KINDS].join(", ")}`);
+    }
+    const posture = options.posture ?? "blocking";
+    if (!POSTURES.has(posture)) {
+        throw new Error(`Invalid --posture "${posture}". One of: ${[...POSTURES].join(", ")}`);
+    }
+    const parsedOptions = (options.option ?? []).map(parseOption);
+    if (parsedOptions.length === 0) {
+        throw new Error("At least one --option is required");
+    }
+    return {
+        ask: {
+            name,
+            kind: kind,
+            question: options.question.trim(),
+            posture: posture,
+            options: parsedOptions,
+            itemKey: options.itemKey,
+            runId: options.runId,
+            evidence: options.evidence,
+            onExpiry: options.onExpiry,
+            expiresInMs: options.expiresIn ? parseDuration(options.expiresIn) : undefined,
+        },
+        wait: options.wait ?? false,
+        pollMs: options.pollMs ? Number(options.pollMs) : 5000,
+    };
+}
+//# sourceMappingURL=ask-options.js.map

package/dist/commands/fleet/ask.d.ts

@@ -0,0 +1,29 @@
+import type { Command } from "commander";
+import type { ListResult, OutputSchema } from "../../output/index.js";
+import { type FleetCommandOptions } from "./shared.js";
+import { type AskRow } from "./ask-options.js";
+export declare const askSchema: OutputSchema<AskRow>;
+export interface AskCommandOptions extends FleetCommandOptions {
+    kind?: string;
+    question?: string;
+    posture?: string;
+    option?: string[];
+    onExpiry?: string;
+    expiresIn?: string;
+    itemKey?: string;
+    runId?: string;
+    evidence?: string;
+    wait?: boolean;
+    pollMs?: string;
+}
+/**
+ * Raise a decision from a loop, and optionally block until a person (or the clock)
+ * settles it.
+ *
+ * This is what makes the human-in-the-loop story reachable from a bash runner: the
+ * runner asks, waits, and branches on the chosen option id printed to stdout. Without
+ * `--wait` it returns immediately, which is the right shape for an advisory decision
+ * that has already acted.
+ */
+export declare function runAskCommand(name: string, options: AskCommandOptions, _command: Command): Promise<ListResult<AskRow>>;
+//# sourceMappingURL=ask.d.ts.map

package/dist/commands/fleet/ask.js

@@ -0,0 +1,82 @@
+import { connectFleetClient, toFleetCommandError } from "./shared.js";
+import { parseAskOptions } from "./ask-options.js";
+export const askSchema = {
+    idField: "decision",
+    columns: [
+        { header: "DECISION", field: "decision", width: 38 },
+        { header: "STATUS", field: "status", width: 10 },
+        { header: "CHOSEN", field: "chosen", width: 18 },
+        { header: "BY", field: "resolvedBy", width: 10 },
+    ],
+};
+/**
+ * Raise a decision from a loop, and optionally block until a person (or the clock)
+ * settles it.
+ *
+ * This is what makes the human-in-the-loop story reachable from a bash runner: the
+ * runner asks, waits, and branches on the chosen option id printed to stdout. Without
+ * `--wait` it returns immediately, which is the right shape for an advisory decision
+ * that has already acted.
+ */
+export async function runAskCommand(name, options, _command) {
+    // Parse before connecting, and wrap the failure the same way the rest of the fleet
+    // commands do: a loop author who mistypes an option should get one readable line,
+    // not a stack trace.
+    let parsed;
+    try {
+        parsed = parseAskOptions(name, options);
+    }
+    catch (error) {
+        throw toFleetCommandError("FLEET_ASK_INVALID", "parse decision options", error);
+    }
+    const { client } = await connectFleetClient(options.host);
+    try {
+        const created = await client.fleetAsk(parsed.ask);
+        if (created.error) {
+            throw new Error(created.error);
+        }
+        const decision = created.decision;
+        if (!decision) {
+            throw new Error("Daemon did not return a decision");
+        }
+        if (!parsed.wait) {
+            return {
+                type: "list",
+                data: [{ decision: decision.id, status: "pending", chosen: "", resolvedBy: "" }],
+                schema: askSchema,
+            };
+        }
+        // Poll until it is settled. The daemon applies `onExpiry` on read, so a decision
+        // with a clock always terminates; a blocking decision with no clock waits, which is
+        // exactly what it declared.
+        for (;;) {
+            const payload = await client.fleetDecisions({ name, includeResolved: true });
+            if (payload.error) {
+                throw new Error(payload.error);
+            }
+            const current = payload.decisions.find((entry) => entry.id === decision.id);
+            if (current?.resolvedOptionId) {
+                return {
+                    type: "list",
+                    data: [
+                        {
+                            decision: current.id,
+                            status: "resolved",
+                            chosen: current.resolvedOptionId,
+                            resolvedBy: current.resolvedBy?.kind ?? "",
+                        },
+                    ],
+                    schema: askSchema,
+                };
+            }
+            await new Promise((resolve) => setTimeout(resolve, parsed.pollMs));
+        }
+    }
+    catch (error) {
+        throw toFleetCommandError("FLEET_ASK_FAILED", "raise loop decision", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=ask.js.map

package/dist/commands/fleet/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createFleetCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/fleet/index.js

@@ -0,0 +1,55 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { runLsCommand } from "./ls.js";
+import { runInspectCommand } from "./inspect.js";
+import { runRunCommand } from "./run.js";
+import { runPauseCommand } from "./pause.js";
+import { runResumeCommand } from "./resume.js";
+import { runNewCommand } from "./new.js";
+import { runAskCommand } from "./ask.js";
+export function createFleetCommand() {
+    const fleet = new Command("fleet").description("View the super-repo automation loop fleet (Loops)");
+    addJsonAndDaemonHostOptions(fleet.command("ls").description("List all loops with status and findings")).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(fleet
+        .command("inspect")
+        .description("Inspect a single loop by name")
+        .argument("<name>", "Loop name (for example: stage-gc)")).action(withOutput(runInspectCommand));
+    addJsonAndDaemonHostOptions(fleet
+        .command("run")
+        .description("Trigger a one-off dry-run of a loop now")
+        .argument("<name>", "Loop name")).action(withOutput(runRunCommand));
+    addJsonAndDaemonHostOptions(fleet
+        .command("pause")
+        .description("Pause a loop by commenting its cron line (backs up the crontab first)")
+        .argument("<name>", "Loop name")).action(withOutput(runPauseCommand));
+    addJsonAndDaemonHostOptions(fleet
+        .command("resume")
+        .description("Resume a paused loop by uncommenting its cron line")
+        .argument("<name>", "Loop name")).action(withOutput(runResumeCommand));
+    addJsonAndDaemonHostOptions(fleet
+        .command("new")
+        .description("Scaffold a new loop (prints the cron line to install)")
+        .argument("<name>", "Loop name (kebab-case)")
+        .option("--cron <expr>", "Cron cadence, e.g. '7 4 * * *'")
+        .option("--action <prompt>", "The LLM action prompt for fresh items")
+        .option("--description <text>", "Short description of the loop")
+        .option("--mode <live|dry-run>", "Initial mode (default: dry-run)")).action(withOutput(runNewCommand));
+    addJsonAndDaemonHostOptions(fleet
+        .command("ask")
+        .description("Raise a decision from a loop, optionally blocking until it is answered")
+        .argument("<name>", "Loop name")
+        .requiredOption("--question <text>", "The question a person has to answer")
+        .option("--option <spec...>", "id:Label:effect:reversibility[:compensating action] (repeatable)")
+        .option("--kind <kind>", "gate-approval | action-approval | outcome-review")
+        .option("--posture <posture>", "blocking | deferring | advisory (default: blocking)")
+        .option("--on-expiry <optionId>", "Option applied when the clock runs out")
+        .option("--expires-in <duration>", "Lifetime, e.g. 45m, 2h")
+        .option("--item-key <key>", "Ledger item this decision is about")
+        .option("--run-id <id>", "Run/tick this decision belongs to")
+        .option("--evidence <text>", "What the gate saw")
+        .option("--wait", "Block until the decision is resolved, then print the chosen option")
+        .option("--poll-ms <ms>", "Poll interval while waiting (default: 5000)")).action(withOutput(runAskCommand));
+    return fleet;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/fleet/inspect.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+import type { ListResult } from "../../output/index.js";
+import { type FleetInspectRow } from "./schema.js";
+import { type FleetCommandOptions } from "./shared.js";
+export declare function runInspectCommand(name: string, options: FleetCommandOptions, _command: Command): Promise<ListResult<FleetInspectRow>>;
+//# sourceMappingURL=inspect.d.ts.map

package/dist/commands/fleet/inspect.js

@@ -0,0 +1,26 @@
+import { createFleetInspectRows, createFleetInspectSchema, } from "./schema.js";
+import { connectFleetClient, toFleetCommandError } from "./shared.js";
+export async function runInspectCommand(name, options, _command) {
+    const { client } = await connectFleetClient(options.host);
+    try {
+        const payload = await client.fleetInspect({ name });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        if (!payload.loop) {
+            throw new Error(`Loop not found: ${name}`);
+        }
+        return {
+            type: "list",
+            data: createFleetInspectRows(payload.loop),
+            schema: createFleetInspectSchema(payload.loop),
+        };
+    }
+    catch (error) {
+        throw toFleetCommandError("FLEET_INSPECT_FAILED", "inspect loop", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=inspect.js.map

package/dist/commands/fleet/ls.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from "commander";
+import type { ListResult } from "../../output/index.js";
+import { type FleetCommandOptions, type FleetRow } from "./shared.js";
+export declare function runLsCommand(options: FleetCommandOptions, _command: Command): Promise<ListResult<FleetRow>>;
+//# sourceMappingURL=ls.d.ts.map

package/dist/commands/fleet/ls.js

@@ -0,0 +1,23 @@
+import { fleetSchema } from "./schema.js";
+import { connectFleetClient, toFleetCommandError, toFleetRow, } from "./shared.js";
+export async function runLsCommand(options, _command) {
+    const { client } = await connectFleetClient(options.host);
+    try {
+        const payload = await client.fleetList();
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return {
+            type: "list",
+            data: payload.loops.map(toFleetRow),
+            schema: fleetSchema,
+        };
+    }
+    catch (error) {
+        throw toFleetCommandError("FLEET_LIST_FAILED", "list loops", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=ls.js.map

package/dist/commands/fleet/new.d.ts

@@ -0,0 +1,13 @@
+import type { Command } from "commander";
+import type { ListResult } from "../../output/index.js";
+import { type FleetInspectRow } from "./schema.js";
+import { type FleetCommandOptions } from "./shared.js";
+interface FleetNewOptions extends FleetCommandOptions {
+    cron?: string;
+    action?: string;
+    description?: string;
+    mode?: string;
+}
+export declare function runNewCommand(name: string, options: FleetNewOptions, _command: Command): Promise<ListResult<FleetInspectRow>>;
+export {};
+//# sourceMappingURL=new.d.ts.map

package/dist/commands/fleet/new.js

@@ -0,0 +1,44 @@
+import { createFleetInspectRows, createFleetInspectSchema, } from "./schema.js";
+import { connectFleetClient, toFleetCommandError } from "./shared.js";
+export async function runNewCommand(name, options, _command) {
+    if (!options.cron) {
+        throw { code: "MISSING_CRON", message: "--cron is required" };
+    }
+    if (!options.action) {
+        throw {
+            code: "MISSING_ACTION",
+            message: "--action is required",
+        };
+    }
+    const mode = options.mode === "live" ? "live" : "dry-run";
+    const { client } = await connectFleetClient(options.host);
+    try {
+        const payload = await client.fleetCreate({
+            name,
+            description: options.description ?? name,
+            cron: options.cron,
+            action: options.action,
+            mode,
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        if (!payload.loop) {
+            throw new Error("Loop was not created");
+        }
+        const rows = createFleetInspectRows(payload.loop);
+        rows.push({ key: "CronLine", value: payload.cronLine ?? "(none)" });
+        return {
+            type: "list",
+            data: rows,
+            schema: createFleetInspectSchema(payload.loop),
+        };
+    }
+    catch (error) {
+        throw toFleetCommandError("FLEET_CREATE_FAILED", "create loop", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=new.js.map

package/dist/commands/fleet/pause.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from "commander";
+import type { ListResult } from "../../output/index.js";
+import { type FleetCommandOptions, type FleetRow } from "./shared.js";
+export declare function runPauseCommand(name: string, options: FleetCommandOptions, _command: Command): Promise<ListResult<FleetRow>>;
+//# sourceMappingURL=pause.d.ts.map

package/dist/commands/fleet/pause.js

@@ -0,0 +1,22 @@
+import { fleetSchema } from "./schema.js";
+import { connectFleetClient, toFleetCommandError, toFleetRow, } from "./shared.js";
+export async function runPauseCommand(name, options, _command) {
+    const { client } = await connectFleetClient(options.host);
+    try {
+        const payload = await client.fleetPause({ name });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        if (!payload.loop) {
+            throw new Error(`Loop not found: ${name}`);
+        }
+        return { type: "list", data: [toFleetRow(payload.loop)], schema: fleetSchema };
+    }
+    catch (error) {
+        throw toFleetCommandError("FLEET_PAUSE_FAILED", "pause loop", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=pause.js.map

package/dist/commands/fleet/resume.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from "commander";
+import type { ListResult } from "../../output/index.js";
+import { type FleetCommandOptions, type FleetRow } from "./shared.js";
+export declare function runResumeCommand(name: string, options: FleetCommandOptions, _command: Command): Promise<ListResult<FleetRow>>;
+//# sourceMappingURL=resume.d.ts.map

package/dist/commands/fleet/resume.js

@@ -0,0 +1,22 @@
+import { fleetSchema } from "./schema.js";
+import { connectFleetClient, toFleetCommandError, toFleetRow, } from "./shared.js";
+export async function runResumeCommand(name, options, _command) {
+    const { client } = await connectFleetClient(options.host);
+    try {
+        const payload = await client.fleetResume({ name });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        if (!payload.loop) {
+            throw new Error(`Loop not found: ${name}`);
+        }
+        return { type: "list", data: [toFleetRow(payload.loop)], schema: fleetSchema };
+    }
+    catch (error) {
+        throw toFleetCommandError("FLEET_RESUME_FAILED", "resume loop", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=resume.js.map

package/dist/commands/fleet/run.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+import type { ListResult } from "../../output/index.js";
+import { type FleetInspectRow } from "./schema.js";
+import { type FleetCommandOptions } from "./shared.js";
+export declare function runRunCommand(name: string, options: FleetCommandOptions, _command: Command): Promise<ListResult<FleetInspectRow>>;
+//# sourceMappingURL=run.d.ts.map

package/dist/commands/fleet/run.js

@@ -0,0 +1,26 @@
+import { createFleetInspectRows, createFleetInspectSchema, } from "./schema.js";
+import { connectFleetClient, toFleetCommandError } from "./shared.js";
+export async function runRunCommand(name, options, _command) {
+    const { client } = await connectFleetClient(options.host);
+    try {
+        const payload = await client.fleetRunNow({ name });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        if (!payload.loop) {
+            throw new Error(`Loop not found: ${name}`);
+        }
+        return {
+            type: "list",
+            data: createFleetInspectRows(payload.loop),
+            schema: createFleetInspectSchema(payload.loop),
+        };
+    }
+    catch (error) {
+        throw toFleetCommandError("FLEET_RUN_FAILED", "run loop", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=run.js.map

package/dist/commands/fleet/schema.d.ts

@@ -0,0 +1,11 @@
+import type { OutputSchema } from "../../output/index.js";
+import type { FleetRow } from "./shared.js";
+import type { StoredFleetLoop } from "./types.js";
+export declare const fleetSchema: OutputSchema<FleetRow>;
+export interface FleetInspectRow {
+    key: string;
+    value: string;
+}
+export declare function createFleetInspectSchema(record: StoredFleetLoop): OutputSchema<FleetInspectRow>;
+export declare function createFleetInspectRows(loop: StoredFleetLoop): FleetInspectRow[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/commands/fleet/schema.js

@@ -0,0 +1,42 @@
+export const fleetSchema = {
+    idField: "name",
+    columns: [
+        { header: "LOOP", field: "name", width: 26 },
+        { header: "STATUS", field: "status", width: 12 },
+        { header: "SCHEDULE", field: "schedule", width: 18 },
+        { header: "MODE", field: "mode", width: 10 },
+        { header: "FINDINGS", field: "findings", width: 9 },
+        { header: "LAST RUN", field: "lastRun", width: 24 },
+    ],
+};
+export function createFleetInspectSchema(record) {
+    return {
+        idField: "key",
+        columns: [
+            { header: "KEY", field: "key", width: 16 },
+            { header: "VALUE", field: "value", width: 80 },
+        ],
+        serialize: () => record,
+    };
+}
+export function createFleetInspectRows(loop) {
+    const findings = loop.openFindings
+        .slice(0, 8)
+        .map((f) => `${f.key}${f.outcome ? ` (${f.outcome})` : ""}`)
+        .join(", ");
+    return [
+        { key: "Name", value: loop.name },
+        { key: "Status", value: loop.status },
+        { key: "Scheduled", value: loop.scheduled ? "yes" : "no" },
+        { key: "Cadence", value: loop.cadence ?? "null" },
+        { key: "Mode", value: loop.mode },
+        { key: "LastRunAt", value: loop.lastRunAt ?? "null" },
+        { key: "Description", value: loop.description ?? "null" },
+        {
+            key: "Findings",
+            value: `${loop.findingCount}${findings ? `: ${findings}` : ""}`,
+        },
+        { key: "Dir", value: loop.dir },
+    ];
+}
+//# sourceMappingURL=schema.js.map

package/dist/commands/fleet/shared.d.ts

@@ -0,0 +1,20 @@
+import type { CommandError, CommandOptions } from "../../output/index.js";
+import type { FleetDaemonClient, FleetLoopSummary, StoredFleetLoop } from "./types.js";
+export interface FleetCommandOptions extends CommandOptions {
+    host?: string;
+}
+export declare function connectFleetClient(host: string | undefined): Promise<{
+    client: FleetDaemonClient;
+    host: string;
+}>;
+export declare function toFleetCommandError(code: string, action: string, error: unknown): CommandError;
+export interface FleetRow {
+    name: string;
+    status: string;
+    schedule: string;
+    mode: string;
+    findings: string;
+    lastRun: string;
+}
+export declare function toFleetRow(loop: FleetLoopSummary | StoredFleetLoop): FleetRow;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/fleet/shared.js

@@ -0,0 +1,36 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+export async function connectFleetClient(host) {
+    const resolvedHost = getDaemonHost({ host });
+    try {
+        const client = (await connectToDaemon({
+            host,
+        }));
+        return { client, host: resolvedHost };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${resolvedHost}: ${message}`,
+            details: "Start the daemon with: paseo daemon start",
+        };
+    }
+}
+export function toFleetCommandError(code, action, error) {
+    if (error && typeof error === "object" && "code" in error) {
+        return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return { code, message: `Failed to ${action}: ${message}` };
+}
+export function toFleetRow(loop) {
+    return {
+        name: loop.name,
+        status: loop.status,
+        schedule: loop.scheduled ? (loop.cadence ?? "scheduled") : "unscheduled",
+        mode: loop.mode,
+        findings: String(loop.findingCount),
+        lastRun: loop.lastRunAt ?? "never",
+    };
+}
+//# sourceMappingURL=shared.js.map

package/dist/commands/fleet/types.d.ts

@@ -0,0 +1,82 @@
+import type { LoopDecision, LoopDecisionKind, LoopDecisionOption, LoopDecisionPosture } from "@hyperdrive.bot/paseo-protocol/fleet/decisions";
+import type { FleetLoopSummary, StoredFleetLoop } from "@hyperdrive.bot/paseo-protocol/fleet/types";
+export type { FleetLoopSummary, StoredFleetLoop };
+export interface FleetListPayload {
+    requestId: string;
+    loops: FleetLoopSummary[];
+    error: string | null;
+}
+export interface FleetInspectPayload {
+    requestId: string;
+    loop: StoredFleetLoop | null;
+    error: string | null;
+}
+export interface FleetRunNowPayload {
+    requestId: string;
+    loop: StoredFleetLoop | null;
+    started: boolean;
+    error: string | null;
+}
+export interface FleetControlPayload {
+    requestId: string;
+    loop: FleetLoopSummary | null;
+    error: string | null;
+}
+export interface FleetCreatePayload {
+    requestId: string;
+    loop: StoredFleetLoop | null;
+    cronLine: string | null;
+    error: string | null;
+}
+export interface CreateFleetLoopInput {
+    name: string;
+    description: string;
+    cron: string;
+    action: string;
+    mode?: "live" | "dry-run";
+    rails?: string;
+    allowed?: string;
+}
+export interface FleetDaemonClient {
+    fleetList(): Promise<FleetListPayload>;
+    fleetInspect(input: {
+        name: string;
+    }): Promise<FleetInspectPayload>;
+    fleetRunNow(input: {
+        name: string;
+    }): Promise<FleetRunNowPayload>;
+    fleetPause(input: {
+        name: string;
+    }): Promise<FleetControlPayload>;
+    fleetResume(input: {
+        name: string;
+    }): Promise<FleetControlPayload>;
+    fleetCreate(input: CreateFleetLoopInput): Promise<FleetCreatePayload>;
+    fleetAsk(input: AskFleetDecisionInput): Promise<FleetAskPayload>;
+    fleetDecisions(input: {
+        name?: string;
+        includeResolved?: boolean;
+    }): Promise<FleetDecisionsPayload>;
+    close(): Promise<void>;
+}
+export interface AskFleetDecisionInput {
+    name: string;
+    kind: LoopDecisionKind;
+    question: string;
+    posture: LoopDecisionPosture;
+    options: LoopDecisionOption[];
+    runId?: string;
+    itemKey?: string;
+    evidence?: string;
+    onExpiry?: string;
+    expiresInMs?: number;
+}
+export interface FleetAskPayload {
+    decision: LoopDecision | null;
+    error: string | null;
+}
+export interface FleetDecisionsPayload {
+    decisions: LoopDecision[];
+    error: string | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/fleet/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/commands/provider/add.d.ts

@@ -0,0 +1,23 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
+export interface ProviderAddRow {
+    provider: string;
+    label: string;
+    extends: string;
+    models: string;
+    reloaded: string;
+}
+export declare const providerAddSchema: OutputSchema<ProviderAddRow>;
+export type ProviderAddResult = SingleResult<ProviderAddRow>;
+export interface ProviderAddOptions extends CommandOptions {
+    host?: string;
+    extends?: string;
+    label?: string;
+    description?: string;
+    env?: string[];
+    model?: string[];
+    disallowedTool?: string[];
+    force?: boolean;
+}
+export declare function runAddCommand(providerId: string, options: ProviderAddOptions, _command: Command): Promise<ProviderAddResult>;
+//# sourceMappingURL=add.d.ts.map

package/dist/commands/provider/add.js

@@ -0,0 +1,110 @@
+import { loadPersistedConfig, resolvePaseoHome, savePersistedConfig, } from "@hyperdrive.bot/paseo-server";
+import { ProviderOverridesSchema } from "@hyperdrive.bot/paseo-protocol/provider-config";
+import { tryConnectToDaemon } from "../../utils/client.js";
+export const providerAddSchema = {
+    idField: "provider",
+    columns: [
+        { header: "PROVIDER", field: "provider", width: 20 },
+        { header: "LABEL", field: "label", width: 24 },
+        { header: "EXTENDS", field: "extends", width: 12 },
+        { header: "MODELS", field: "models", width: 30 },
+        {
+            header: "RELOADED",
+            field: "reloaded",
+            width: 24,
+            color: (value) => (value === "yes" ? "green" : "yellow"),
+        },
+    ],
+};
+/** `--env KEY=VALUE` (repeatable). Values may contain `=`; only the first splits. */
+function parseEnvPairs(pairs) {
+    if (!pairs || pairs.length === 0)
+        return undefined;
+    const env = {};
+    for (const pair of pairs) {
+        const separator = pair.indexOf("=");
+        if (separator <= 0) {
+            throw new Error(`Invalid --env "${pair}". Expected KEY=VALUE.`);
+        }
+        env[pair.slice(0, separator)] = pair.slice(separator + 1);
+    }
+    return env;
+}
+/** `--model id` or `--model id:Label` or `--model id:Label:default` (repeatable). */
+function parseModels(models) {
+    if (!models || models.length === 0)
+        return undefined;
+    return models.map((raw) => {
+        const [id, label, flag] = raw.split(":");
+        if (!id) {
+            throw new Error(`Invalid --model "${raw}". Expected id[:Label[:default]].`);
+        }
+        return {
+            id,
+            label: label && label.length > 0 ? label : id,
+            ...(flag === "default" ? { isDefault: true } : {}),
+        };
+    });
+}
+export async function runAddCommand(providerId, options, _command) {
+    if (!options.extends) {
+        throw new Error(`--extends is required. Choose a built-in provider (claude, codex, copilot, opencode, pi) or "acp".`);
+    }
+    const label = options.label ?? providerId;
+    const paseoHome = resolvePaseoHome();
+    const persisted = loadPersistedConfig(paseoHome);
+    const existingProviders = (persisted.agents?.providers ?? {});
+    if (existingProviders[providerId] && !options.force) {
+        throw new Error(`Provider "${providerId}" already exists in config.json. Pass --force to overwrite.`);
+    }
+    const entry = {
+        extends: options.extends,
+        label,
+        ...(options.description ? { description: options.description } : {}),
+        ...(parseEnvPairs(options.env) ? { env: parseEnvPairs(options.env) } : {}),
+        ...(parseModels(options.model) ? { models: parseModels(options.model) } : {}),
+        ...(options.disallowedTool?.length ? { disallowedTools: options.disallowedTool } : {}),
+    };
+    const nextProviders = { ...existingProviders, [providerId]: entry };
+    // Validate the WHOLE map, not just the new entry: ProviderOverridesSchema's
+    // superRefine enforces the id pattern and the extends/label requirement for
+    // custom providers, and we would rather fail here than write a config.json
+    // the daemon will reject on reload.
+    const parsed = ProviderOverridesSchema.safeParse(nextProviders);
+    if (!parsed.success) {
+        throw new Error(`Invalid provider config: ${parsed.error.issues.map((i) => i.message).join("; ")}`);
+    }
+    savePersistedConfig(paseoHome, {
+        ...persisted,
+        agents: { ...persisted.agents, providers: parsed.data },
+    });
+    // Hot-reload if a daemon is up; if not, the file write still stands and the
+    // provider is picked up on next start. Say which happened — never imply the
+    // running daemon saw it when there was no daemon to see it.
+    let reloaded = "no daemon running";
+    const client = await tryConnectToDaemon({ host: options.host });
+    if (client) {
+        try {
+            const result = await client.reloadProviderConfig();
+            reloaded =
+                result.added.includes(providerId) || result.updated.includes(providerId)
+                    ? "yes"
+                    : "daemon did not pick it up";
+        }
+        finally {
+            await client.close().catch(() => { });
+        }
+    }
+    return {
+        type: "single",
+        data: {
+            provider: providerId,
+            label,
+            extends: options.extends,
+            models: (parseModels(options.model) ?? []).map((m) => m.id).join(", ") || "—",
+            reloaded,
+        },
+        schema: providerAddSchema,
+    };
+}
+//# sourceMappingURL=add.js.map

package/dist/commands/provider/index.js

@@ -1,6 +1,8 @@
 import { Command } from "commander";
+import { runAddCommand } from "./add.js";
 import { runLsCommand } from "./ls.js";
 import { runModelsCommand } from "./models.js";
+import { runReloadCommand } from "./reload.js";
 import { withOutput } from "../../output/index.js";
 import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
 export function createProviderCommand() {
@@ -11,6 +13,25 @@ export function createProviderCommand() {
         .description("List models for a provider")
         .argument("<provider>", "Provider name (claude, codex, opencode)")
         .option("--thinking", "Include thinking option IDs for each model")).action(withOutput(runModelsCommand));
+    addJsonAndDaemonHostOptions(provider
+        .command("reload")
+        .description("Re-read providers from config.json into the running daemon (no restart)")
+        .option("--all", "Also list providers whose config did not change")).action(withOutput(runReloadCommand));
+    addJsonAndDaemonHostOptions(provider
+        .command("add")
+        .description("Add a custom provider to config.json and load it without a restart")
+        .argument("<id>", "Provider id (lowercase, e.g. zai)")
+        .requiredOption("--extends <base>", "Built-in to inherit from: claude, codex, copilot, opencode, pi, or acp")
+        .option("--label <label>", "Display name (defaults to the id)")
+        .option("--description <text>", "Description shown in the provider list")
+        .option("--env <KEY=VALUE>", "Environment variable (repeatable)", collect, [])
+        .option("--model <id[:Label[:default]]>", "Model definition (repeatable)", collect, [])
+        .option("--disallowed-tool <tool>", "Tool to disallow (repeatable)", collect, [])
+        .option("--force", "Overwrite an existing provider entry")).action(withOutput(runAddCommand));
     return provider;
 }
+/** commander repeatable-option accumulator. */
+function collect(value, previous) {
+    return [...previous, value];
+}
 //# sourceMappingURL=index.js.map

package/dist/commands/provider/reload.d.ts

@@ -0,0 +1,21 @@
+import type { Command } from "commander";
+import type { CommandOptions, ListResult, OutputSchema } from "../../output/index.js";
+/**
+ * One row per provider whose config.json entry changed. `unchanged` providers
+ * are omitted from the table by default — a reload that read back an identical
+ * file should look like a no-op, not a wall of rows.
+ */
+export interface ProviderReloadRow {
+    provider: string;
+    change: "added" | "updated" | "removed" | "unchanged";
+    label: string;
+    enabled: string;
+}
+export declare const providerReloadSchema: OutputSchema<ProviderReloadRow>;
+export type ProviderReloadResult = ListResult<ProviderReloadRow>;
+export interface ProviderReloadOptions extends CommandOptions {
+    host?: string;
+    all?: boolean;
+}
+export declare function runReloadCommand(options: ProviderReloadOptions, _command: Command): Promise<ProviderReloadResult>;
+//# sourceMappingURL=reload.d.ts.map

package/dist/commands/provider/reload.js

@@ -0,0 +1,64 @@
+import { connectToDaemon } from "../../utils/client.js";
+export const providerReloadSchema = {
+    idField: "provider",
+    columns: [
+        { header: "PROVIDER", field: "provider", width: 20 },
+        {
+            header: "CHANGE",
+            field: "change",
+            width: 10,
+            color: (value) => {
+                if (value === "added")
+                    return "green";
+                if (value === "removed")
+                    return "red";
+                if (value === "updated")
+                    return "yellow";
+                return undefined;
+            },
+        },
+        { header: "LABEL", field: "label", width: 24 },
+        { header: "ENABLED", field: "enabled", width: 10 },
+    ],
+};
+export async function runReloadCommand(options, _command) {
+    // Deliberately connectToDaemon, not tryConnectToDaemon: a reload with no
+    // daemon running is a no-op the user must hear about, not a silent success.
+    const client = await connectToDaemon({ host: options.host });
+    try {
+        const result = await client.reloadProviderConfig();
+        const labels = new Map(result.providers.map((entry) => [entry.provider, entry]));
+        const rows = [];
+        const push = (provider, change) => {
+            const entry = labels.get(provider);
+            // A removed provider is gone from the registry, so it has no label or
+            // enabled state left to report.
+            const removed = change === "removed";
+            let enabled = "—";
+            if (!removed) {
+                enabled = entry?.enabled === false ? "Disabled" : "Enabled";
+            }
+            rows.push({
+                provider,
+                change,
+                label: entry?.label ?? (removed ? "—" : provider),
+                enabled,
+            });
+        };
+        for (const provider of result.added)
+            push(provider, "added");
+        for (const provider of result.updated)
+            push(provider, "updated");
+        for (const provider of result.removed)
+            push(provider, "removed");
+        if (options.all) {
+            for (const provider of result.unchanged)
+                push(provider, "unchanged");
+        }
+        return { type: "list", data: rows, schema: providerReloadSchema };
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=reload.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperdrive.bot/paseo-cli",
-  "version": "0.3.34",
+  "version": "0.3.36",
   "description": "Paseo CLI - control your AI coding agents from the command line",
   "bin": {
     "paseo": "bin/paseo"
@@ -27,9 +27,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@hyperdrive.bot/paseo-client": "0.3.34",
-    "@hyperdrive.bot/paseo-protocol": "0.3.34",
-    "@hyperdrive.bot/paseo-server": "0.3.34",
+    "@hyperdrive.bot/paseo-client": "0.3.36",
+    "@hyperdrive.bot/paseo-protocol": "0.3.36",
+    "@hyperdrive.bot/paseo-server": "0.3.36",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",