@hyperdrive.bot/paseo-protocol 0.3.35 → 0.3.36

package/dist/fleet/rpc-schemas.js

@@ -0,0 +1,187 @@
+import { z } from "zod";
+import { LoopDecisionKindSchema, LoopDecisionOptionSchema, LoopDecisionPostureSchema, LoopDecisionSchema, } from "./decisions.js";
+import { LoopParamValueSchema } from "./params.js";
+import { FleetExecutionSchema, FleetLoopModeSchema, FleetLoopSummarySchema, StoredFleetLoopSchema, } from "./types.js";
+// --- requests ---------------------------------------------------------------
+export const FleetListRequestSchema = z.object({
+    type: z.literal("fleet/list"),
+    requestId: z.string(),
+});
+export const FleetInspectRequestSchema = z.object({
+    type: z.literal("fleet/inspect"),
+    requestId: z.string(),
+    name: z.string(),
+});
+export const FleetRunNowRequestSchema = z.object({
+    type: z.literal("fleet/run-now"),
+    requestId: z.string(),
+    name: z.string(),
+});
+export const FleetPauseRequestSchema = z.object({
+    type: z.literal("fleet/pause"),
+    requestId: z.string(),
+    name: z.string(),
+});
+export const FleetResumeRequestSchema = z.object({
+    type: z.literal("fleet/resume"),
+    requestId: z.string(),
+    name: z.string(),
+});
+// --- responses --------------------------------------------------------------
+export const FleetListResponseSchema = z.object({
+    type: z.literal("fleet/list/response"),
+    payload: z.object({
+        requestId: z.string(),
+        loops: z.array(FleetLoopSummarySchema),
+        error: z.string().nullable(),
+    }),
+});
+export const FleetInspectResponseSchema = z.object({
+    type: z.literal("fleet/inspect/response"),
+    payload: z.object({
+        requestId: z.string(),
+        loop: StoredFleetLoopSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const FleetRunNowResponseSchema = z.object({
+    type: z.literal("fleet/run-now/response"),
+    payload: z.object({
+        requestId: z.string(),
+        loop: StoredFleetLoopSchema.nullable(),
+        started: z.boolean(),
+        error: z.string().nullable(),
+    }),
+});
+export const FleetPauseResponseSchema = z.object({
+    type: z.literal("fleet/pause/response"),
+    payload: z.object({
+        requestId: z.string(),
+        loop: FleetLoopSummarySchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const FleetResumeResponseSchema = z.object({
+    type: z.literal("fleet/resume/response"),
+    payload: z.object({
+        requestId: z.string(),
+        loop: FleetLoopSummarySchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const FleetCreateRequestSchema = z.object({
+    type: z.literal("fleet/create"),
+    requestId: z.string(),
+    name: z.string(),
+    description: z.string(),
+    cron: z.string(),
+    action: z.string(),
+    mode: z.enum(["live", "dry-run"]).optional(),
+    rails: z.string().optional(),
+    allowed: z.string().optional(),
+});
+export const FleetCreateResponseSchema = z.object({
+    type: z.literal("fleet/create/response"),
+    payload: z.object({
+        requestId: z.string(),
+        loop: StoredFleetLoopSchema.nullable(),
+        cronLine: z.string().nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const FleetSetModeRequestSchema = z.object({
+    type: z.literal("fleet/set-mode"),
+    requestId: z.string(),
+    name: z.string(),
+    mode: z.enum(["live", "dry-run"]),
+});
+export const FleetSetModeResponseSchema = z.object({
+    type: z.literal("fleet/set-mode/response"),
+    payload: z.object({
+        requestId: z.string(),
+        loop: FleetLoopSummarySchema.nullable(),
+        /** Mode the loop was in before this call, so the UI can report the transition. */
+        previousMode: FleetLoopModeSchema.nullable(),
+        /** False when the loop was already in the requested mode: nothing was written. */
+        changed: z.boolean(),
+        error: z.string().nullable(),
+    }),
+});
+export const FleetAskRequestSchema = z.object({
+    type: z.literal("fleet/ask"),
+    requestId: z.string(),
+    name: z.string(),
+    kind: LoopDecisionKindSchema,
+    question: z.string(),
+    posture: LoopDecisionPostureSchema,
+    options: z.array(LoopDecisionOptionSchema).min(1),
+    runId: z.string().optional(),
+    itemKey: z.string().optional(),
+    evidence: z.string().optional(),
+    onExpiry: z.string().optional(),
+    expiresInMs: z.number().int().positive().optional(),
+});
+export const FleetAskResponseSchema = z.object({
+    type: z.literal("fleet/ask/response"),
+    payload: z.object({
+        requestId: z.string(),
+        decision: LoopDecisionSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const FleetDecisionsRequestSchema = z.object({
+    type: z.literal("fleet/decisions"),
+    requestId: z.string(),
+    name: z.string().optional(),
+    includeResolved: z.boolean().optional(),
+});
+export const FleetDecisionsResponseSchema = z.object({
+    type: z.literal("fleet/decisions/response"),
+    payload: z.object({
+        requestId: z.string(),
+        decisions: z.array(LoopDecisionSchema),
+        error: z.string().nullable(),
+    }),
+});
+export const FleetResolveDecisionRequestSchema = z.object({
+    type: z.literal("fleet/resolve-decision"),
+    requestId: z.string(),
+    decisionId: z.string(),
+    optionId: z.string(),
+});
+export const FleetResolveDecisionResponseSchema = z.object({
+    type: z.literal("fleet/resolve-decision/response"),
+    payload: z.object({
+        requestId: z.string(),
+        decision: LoopDecisionSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const FleetSetParamsRequestSchema = z.object({
+    type: z.literal("fleet/set-params"),
+    requestId: z.string(),
+    name: z.string(),
+    values: z.record(z.string(), LoopParamValueSchema),
+});
+export const FleetSetParamsResponseSchema = z.object({
+    type: z.literal("fleet/set-params/response"),
+    payload: z.object({
+        requestId: z.string(),
+        loop: StoredFleetLoopSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const FleetExecutionsRequestSchema = z.object({
+    type: z.literal("fleet/executions"),
+    requestId: z.string(),
+    name: z.string(),
+});
+export const FleetExecutionsResponseSchema = z.object({
+    type: z.literal("fleet/executions/response"),
+    payload: z.object({
+        requestId: z.string(),
+        executions: z.array(FleetExecutionSchema),
+        error: z.string().nullable(),
+    }),
+});
+//# sourceMappingURL=rpc-schemas.js.map

package/dist/fleet/types.d.ts

@@ -0,0 +1,170 @@
+import { z } from "zod";
+/**
+ * Fleet = the super-repo autonomous "loop" fleet, surfaced as a first-class paseo
+ * entity. Presented in the UI as "Loops"; namespaced `fleet` internally because the
+ * `loop` token is already taken by the Ralph worker/verifier entity.
+ *
+ * These loops are NOT owned by the daemon — they run as bash+cron under the
+ * super-repo. The daemon reads their state (see server/fleet/fleet-reader.ts) and
+ * optionally drives run-now / pause / resume. The record is therefore derived on
+ * read, not persisted like a schedule.
+ */
+export declare const FleetLoopModeSchema: z.ZodEnum<{
+    unknown: "unknown";
+    live: "live";
+    "dry-run": "dry-run";
+}>;
+export type FleetLoopMode = z.infer<typeof FleetLoopModeSchema>;
+export declare const FleetLoopStatusSchema: z.ZodEnum<{
+    error: "error";
+    idle: "idle";
+    unknown: "unknown";
+    paused: "paused";
+    healthy: "healthy";
+    blocked: "blocked";
+    unscheduled: "unscheduled";
+}>;
+export type FleetLoopStatus = z.infer<typeof FleetLoopStatusSchema>;
+export declare const FleetFindingSchema: z.ZodObject<{
+    key: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodOptional<z.ZodString>;
+    actionable: z.ZodBoolean;
+    outcome: z.ZodOptional<z.ZodString>;
+    handledAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FleetFinding = z.infer<typeof FleetFindingSchema>;
+export declare const FleetRunDaySchema: z.ZodObject<{
+    date: z.ZodString;
+    gateCount: z.ZodNumber;
+    freshCount: z.ZodNumber;
+    doneCount: z.ZodNumber;
+}, z.core.$strip>;
+export type FleetRunDay = z.infer<typeof FleetRunDaySchema>;
+export declare const StoredFleetLoopSchema: z.ZodObject<{
+    name: z.ZodString;
+    displayName: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    dir: z.ZodString;
+    statePrefix: z.ZodString;
+    scheduled: z.ZodBoolean;
+    paused: z.ZodBoolean;
+    cadence: z.ZodOptional<z.ZodString>;
+    mode: z.ZodEnum<{
+        unknown: "unknown";
+        live: "live";
+        "dry-run": "dry-run";
+    }>;
+    status: z.ZodEnum<{
+        error: "error";
+        idle: "idle";
+        unknown: "unknown";
+        paused: "paused";
+        healthy: "healthy";
+        blocked: "blocked";
+        unscheduled: "unscheduled";
+    }>;
+    lastRunAt: z.ZodOptional<z.ZodString>;
+    findingCount: z.ZodNumber;
+    openFindings: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodOptional<z.ZodString>;
+        actionable: z.ZodBoolean;
+        outcome: z.ZodOptional<z.ZodString>;
+        handledAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    errorTail: z.ZodOptional<z.ZodString>;
+    recentRuns: z.ZodArray<z.ZodObject<{
+        date: z.ZodString;
+        gateCount: z.ZodNumber;
+        freshCount: z.ZodNumber;
+        doneCount: z.ZodNumber;
+    }, z.core.$strip>>;
+    paramsSchema: z.ZodOptional<z.ZodObject<{
+        fields: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                enum: "enum";
+                "string-list": "string-list";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            default: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
+}, z.core.$strip>;
+export type StoredFleetLoop = z.infer<typeof StoredFleetLoopSchema>;
+/** List projection: drop the heavy detail arrays, keep the count. */
+export declare const FleetLoopSummarySchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        unknown: "unknown";
+        live: "live";
+        "dry-run": "dry-run";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        error: "error";
+        idle: "idle";
+        unknown: "unknown";
+        paused: "paused";
+        healthy: "healthy";
+        blocked: "blocked";
+        unscheduled: "unscheduled";
+    }>;
+    paused: z.ZodBoolean;
+    cadence: z.ZodOptional<z.ZodString>;
+    lastRunAt: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodString;
+    dir: z.ZodString;
+    statePrefix: z.ZodString;
+    scheduled: z.ZodBoolean;
+    findingCount: z.ZodNumber;
+    paramsSchema: z.ZodOptional<z.ZodObject<{
+        fields: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                enum: "enum";
+                "string-list": "string-list";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            default: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
+}, z.core.$strip>;
+export type FleetLoopSummary = z.infer<typeof FleetLoopSummarySchema>;
+/**
+ * One execution of a loop, i.e. a paseo agent the loop spawned (labeled loop=<name>).
+ * Projected from an agent snapshot so the Loops detail can list runs + link to sessions.
+ */
+export declare const FleetExecutionSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    title: z.ZodNullable<z.ZodString>;
+    status: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    requiresAttention: z.ZodOptional<z.ZodBoolean>;
+    attentionReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    costUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    run: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FleetExecution = z.infer<typeof FleetExecutionSchema>;
+//# sourceMappingURL=types.d.ts.map

package/dist/fleet/types.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { LoopParamsSchemaSchema, LoopParamValueSchema } from "./params.js";
+/**
+ * Fleet = the super-repo autonomous "loop" fleet, surfaced as a first-class paseo
+ * entity. Presented in the UI as "Loops"; namespaced `fleet` internally because the
+ * `loop` token is already taken by the Ralph worker/verifier entity.
+ *
+ * These loops are NOT owned by the daemon — they run as bash+cron under the
+ * super-repo. The daemon reads their state (see server/fleet/fleet-reader.ts) and
+ * optionally drives run-now / pause / resume. The record is therefore derived on
+ * read, not persisted like a schedule.
+ */
+export const FleetLoopModeSchema = z.enum(["live", "dry-run", "unknown"]);
+export const FleetLoopStatusSchema = z.enum([
+    "healthy",
+    "idle",
+    "blocked",
+    "error",
+    "paused",
+    "unscheduled",
+    "unknown",
+]);
+export const FleetFindingSchema = z.object({
+    key: z.string(),
+    title: z.string().optional(),
+    evidence: z.string().optional(),
+    actionable: z.boolean(),
+    /** Terminal outcome from the loop's seen-ledger, if handled. */
+    outcome: z.string().optional(),
+    handledAt: z.string().optional(),
+});
+export const FleetRunDaySchema = z.object({
+    date: z.string(),
+    gateCount: z.number().int().nonnegative(),
+    freshCount: z.number().int().nonnegative(),
+    doneCount: z.number().int().nonnegative(),
+});
+export const StoredFleetLoopSchema = z.object({
+    name: z.string(),
+    displayName: z.string(),
+    description: z.string().optional(),
+    dir: z.string(),
+    statePrefix: z.string(),
+    scheduled: z.boolean(),
+    paused: z.boolean(),
+    cadence: z.string().optional(),
+    mode: FleetLoopModeSchema,
+    status: FleetLoopStatusSchema,
+    lastRunAt: z.string().optional(),
+    findingCount: z.number().int().nonnegative(),
+    openFindings: z.array(FleetFindingSchema),
+    errorTail: z.string().optional(),
+    recentRuns: z.array(FleetRunDaySchema),
+    /** The loop's declared knobs, when it ships a params.schema.json. */
+    paramsSchema: LoopParamsSchemaSchema.optional(),
+    /** Current values from params.json. */
+    params: z.record(z.string(), LoopParamValueSchema).optional(),
+});
+/** List projection: drop the heavy detail arrays, keep the count. */
+export const FleetLoopSummarySchema = StoredFleetLoopSchema.omit({
+    openFindings: true,
+    recentRuns: true,
+    errorTail: true,
+});
+/**
+ * One execution of a loop, i.e. a paseo agent the loop spawned (labeled loop=<name>).
+ * Projected from an agent snapshot so the Loops detail can list runs + link to sessions.
+ */
+export const FleetExecutionSchema = z.object({
+    agentId: z.string(),
+    title: z.string().nullable(),
+    status: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    requiresAttention: z.boolean().optional(),
+    attentionReason: z.string().nullable().optional(),
+    costUsd: z.number().nullable().optional(),
+    run: z.string().optional(),
+});
+//# sourceMappingURL=types.js.map