@prave/shared 1.2.2 → 1.4.0

package/dist/schemas/run.schema.d.ts

@@ -0,0 +1,501 @@
+import { z } from 'zod';
+/**
+ * Run schemas — server-side scheduled Skill executions.
+ *
+ * The on-disk shape is split across three tables:
+ *
+ *   - `skill_bundles`   uploaded project folder (SKILL.md + scripts + .env)
+ *   - `runs`            schedule + agent + status for one deployment
+ *   - `run_executions`  append-only fire-history with logs and tokens
+ *
+ * (See supabase/migrations/049_runs_and_bundles.sql for the full
+ * column-level docstrings.)
+ */
+export declare const runAgentSchema: z.ZodEnum<["claude", "codex", "cursor", "gemini", "cline", "amp"]>;
+export type RunAgent = z.infer<typeof runAgentSchema>;
+export declare const runScheduleKindSchema: z.ZodEnum<["hourly", "daily", "weekly", "monthly", "custom"]>;
+export type RunScheduleKind = z.infer<typeof runScheduleKindSchema>;
+export declare const runStatusSchema: z.ZodEnum<["active", "paused", "failed", "disabled"]>;
+export type RunStatus = z.infer<typeof runStatusSchema>;
+export declare const runExecutionStatusSchema: z.ZodEnum<["running", "success", "failed", "timeout", "cancelled"]>;
+export type RunExecutionStatus = z.infer<typeof runExecutionStatusSchema>;
+export declare const runScheduleInputSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"hourly">;
+}, "strip", z.ZodTypeAny, {
+    kind: "hourly";
+}, {
+    kind: "hourly";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"daily">;
+    time: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "daily";
+    time: string;
+}, {
+    kind: "daily";
+    time: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"weekly">;
+    time: z.ZodString;
+    weekday: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    kind: "weekly";
+    time: string;
+    weekday: number;
+}, {
+    kind: "weekly";
+    time: string;
+    weekday: number;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"monthly">;
+    time: z.ZodString;
+    day_of_month: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    kind: "monthly";
+    time: string;
+    day_of_month: number;
+}, {
+    kind: "monthly";
+    time: string;
+    day_of_month: number;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"custom">;
+    cron_expr: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "custom";
+    cron_expr: string;
+}, {
+    kind: "custom";
+    cron_expr: string;
+}>]>;
+export type RunScheduleInput = z.infer<typeof runScheduleInputSchema>;
+export declare const skillBundleSchema: z.ZodObject<{
+    id: z.ZodString;
+    owner_id: z.ZodString;
+    skill_id: z.ZodNullable<z.ZodString>;
+    source: z.ZodEnum<["upload", "github"]>;
+    tarball_path: z.ZodString;
+    manifest: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        size: z.ZodNumber;
+        sha256: z.ZodString;
+        kind: z.ZodEnum<["text", "binary", "script"]>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        kind: "text" | "binary" | "script";
+        size: number;
+        sha256: string;
+    }, {
+        path: string;
+        kind: "text" | "binary" | "script";
+        size: number;
+        sha256: string;
+    }>, "many">;
+    total_size_bytes: z.ZodNumber;
+    has_scripts: z.ZodBoolean;
+    has_env_template: z.ZodBoolean;
+    secret_scan_status: z.ZodEnum<["pending", "clean", "rejected"]>;
+    secret_scan_findings: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        rule: z.ZodString;
+        line: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        rule: string;
+        line?: number | undefined;
+    }, {
+        path: string;
+        rule: string;
+        line?: number | undefined;
+    }>, "many">>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    skill_id: string | null;
+    created_at: string;
+    updated_at: string;
+    owner_id: string;
+    source: "upload" | "github";
+    tarball_path: string;
+    manifest: {
+        path: string;
+        kind: "text" | "binary" | "script";
+        size: number;
+        sha256: string;
+    }[];
+    total_size_bytes: number;
+    has_scripts: boolean;
+    has_env_template: boolean;
+    secret_scan_status: "pending" | "clean" | "rejected";
+    secret_scan_findings: {
+        path: string;
+        rule: string;
+        line?: number | undefined;
+    }[] | null;
+}, {
+    id: string;
+    skill_id: string | null;
+    created_at: string;
+    updated_at: string;
+    owner_id: string;
+    source: "upload" | "github";
+    tarball_path: string;
+    manifest: {
+        path: string;
+        kind: "text" | "binary" | "script";
+        size: number;
+        sha256: string;
+    }[];
+    total_size_bytes: number;
+    has_scripts: boolean;
+    has_env_template: boolean;
+    secret_scan_status: "pending" | "clean" | "rejected";
+    secret_scan_findings: {
+        path: string;
+        rule: string;
+        line?: number | undefined;
+    }[] | null;
+}>;
+export type SkillBundle = z.infer<typeof skillBundleSchema>;
+export declare const runSchema: z.ZodObject<{
+    id: z.ZodString;
+    owner_id: z.ZodString;
+    bundle_id: z.ZodString;
+    slug: z.ZodString;
+    name: z.ZodString;
+    agent: z.ZodEnum<["claude", "codex", "cursor", "gemini", "cline", "amp"]>;
+    schedule_kind: z.ZodEnum<["hourly", "daily", "weekly", "monthly", "custom"]>;
+    cron_expr: z.ZodString;
+    timezone: z.ZodString;
+    status: z.ZodEnum<["active", "paused", "failed", "disabled"]>;
+    timeout_seconds: z.ZodNumber;
+    max_log_bytes: z.ZodNumber;
+    next_run_at: z.ZodNullable<z.ZodString>;
+    last_run_at: z.ZodNullable<z.ZodString>;
+    last_exec_status: z.ZodNullable<z.ZodEnum<["success", "failed", "timeout", "cancelled"]>>;
+    total_runs: z.ZodNumber;
+    total_failures: z.ZodNumber;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "failed" | "active" | "paused" | "disabled";
+    id: string;
+    created_at: string;
+    updated_at: string;
+    slug: string;
+    name: string;
+    owner_id: string;
+    cron_expr: string;
+    bundle_id: string;
+    agent: "claude" | "codex" | "cursor" | "gemini" | "cline" | "amp";
+    schedule_kind: "custom" | "monthly" | "hourly" | "daily" | "weekly";
+    timezone: string;
+    timeout_seconds: number;
+    max_log_bytes: number;
+    next_run_at: string | null;
+    last_run_at: string | null;
+    last_exec_status: "success" | "failed" | "timeout" | "cancelled" | null;
+    total_runs: number;
+    total_failures: number;
+}, {
+    status: "failed" | "active" | "paused" | "disabled";
+    id: string;
+    created_at: string;
+    updated_at: string;
+    slug: string;
+    name: string;
+    owner_id: string;
+    cron_expr: string;
+    bundle_id: string;
+    agent: "claude" | "codex" | "cursor" | "gemini" | "cline" | "amp";
+    schedule_kind: "custom" | "monthly" | "hourly" | "daily" | "weekly";
+    timezone: string;
+    timeout_seconds: number;
+    max_log_bytes: number;
+    next_run_at: string | null;
+    last_run_at: string | null;
+    last_exec_status: "success" | "failed" | "timeout" | "cancelled" | null;
+    total_runs: number;
+    total_failures: number;
+}>;
+export type Run = z.infer<typeof runSchema>;
+export declare const createRunInputSchema: z.ZodObject<{
+    bundle_id: z.ZodString;
+    name: z.ZodString;
+    agent: z.ZodEnum<["claude", "codex", "cursor", "gemini", "cline", "amp"]>;
+    schedule: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"hourly">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "hourly";
+    }, {
+        kind: "hourly";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"daily">;
+        time: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "daily";
+        time: string;
+    }, {
+        kind: "daily";
+        time: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"weekly">;
+        time: z.ZodString;
+        weekday: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        kind: "weekly";
+        time: string;
+        weekday: number;
+    }, {
+        kind: "weekly";
+        time: string;
+        weekday: number;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"monthly">;
+        time: z.ZodString;
+        day_of_month: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        kind: "monthly";
+        time: string;
+        day_of_month: number;
+    }, {
+        kind: "monthly";
+        time: string;
+        day_of_month: number;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"custom">;
+        cron_expr: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "custom";
+        cron_expr: string;
+    }, {
+        kind: "custom";
+        cron_expr: string;
+    }>]>;
+    timezone: z.ZodDefault<z.ZodString>;
+    timeout_seconds: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    bundle_id: string;
+    agent: "claude" | "codex" | "cursor" | "gemini" | "cline" | "amp";
+    timezone: string;
+    schedule: {
+        kind: "hourly";
+    } | {
+        kind: "daily";
+        time: string;
+    } | {
+        kind: "weekly";
+        time: string;
+        weekday: number;
+    } | {
+        kind: "monthly";
+        time: string;
+        day_of_month: number;
+    } | {
+        kind: "custom";
+        cron_expr: string;
+    };
+    timeout_seconds?: number | undefined;
+}, {
+    name: string;
+    bundle_id: string;
+    agent: "claude" | "codex" | "cursor" | "gemini" | "cline" | "amp";
+    schedule: {
+        kind: "hourly";
+    } | {
+        kind: "daily";
+        time: string;
+    } | {
+        kind: "weekly";
+        time: string;
+        weekday: number;
+    } | {
+        kind: "monthly";
+        time: string;
+        day_of_month: number;
+    } | {
+        kind: "custom";
+        cron_expr: string;
+    };
+    timezone?: string | undefined;
+    timeout_seconds?: number | undefined;
+}>;
+export type CreateRunInput = z.infer<typeof createRunInputSchema>;
+export declare const updateRunInputSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    agent: z.ZodOptional<z.ZodEnum<["claude", "codex", "cursor", "gemini", "cline", "amp"]>>;
+    schedule: z.ZodOptional<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"hourly">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "hourly";
+    }, {
+        kind: "hourly";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"daily">;
+        time: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "daily";
+        time: string;
+    }, {
+        kind: "daily";
+        time: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"weekly">;
+        time: z.ZodString;
+        weekday: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        kind: "weekly";
+        time: string;
+        weekday: number;
+    }, {
+        kind: "weekly";
+        time: string;
+        weekday: number;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"monthly">;
+        time: z.ZodString;
+        day_of_month: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        kind: "monthly";
+        time: string;
+        day_of_month: number;
+    }, {
+        kind: "monthly";
+        time: string;
+        day_of_month: number;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"custom">;
+        cron_expr: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "custom";
+        cron_expr: string;
+    }, {
+        kind: "custom";
+        cron_expr: string;
+    }>]>>;
+    timezone: z.ZodOptional<z.ZodString>;
+    timeout_seconds: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodOptional<z.ZodEnum<["active", "paused"]>>;
+}, "strip", z.ZodTypeAny, {
+    status?: "active" | "paused" | undefined;
+    name?: string | undefined;
+    agent?: "claude" | "codex" | "cursor" | "gemini" | "cline" | "amp" | undefined;
+    timezone?: string | undefined;
+    timeout_seconds?: number | undefined;
+    schedule?: {
+        kind: "hourly";
+    } | {
+        kind: "daily";
+        time: string;
+    } | {
+        kind: "weekly";
+        time: string;
+        weekday: number;
+    } | {
+        kind: "monthly";
+        time: string;
+        day_of_month: number;
+    } | {
+        kind: "custom";
+        cron_expr: string;
+    } | undefined;
+}, {
+    status?: "active" | "paused" | undefined;
+    name?: string | undefined;
+    agent?: "claude" | "codex" | "cursor" | "gemini" | "cline" | "amp" | undefined;
+    timezone?: string | undefined;
+    timeout_seconds?: number | undefined;
+    schedule?: {
+        kind: "hourly";
+    } | {
+        kind: "daily";
+        time: string;
+    } | {
+        kind: "weekly";
+        time: string;
+        weekday: number;
+    } | {
+        kind: "monthly";
+        time: string;
+        day_of_month: number;
+    } | {
+        kind: "custom";
+        cron_expr: string;
+    } | undefined;
+}>;
+export type UpdateRunInput = z.infer<typeof updateRunInputSchema>;
+export declare const runExecutionSchema: z.ZodObject<{
+    id: z.ZodString;
+    run_id: z.ZodString;
+    worker_id: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<["running", "success", "failed", "timeout", "cancelled"]>;
+    started_at: z.ZodString;
+    finished_at: z.ZodNullable<z.ZodString>;
+    duration_ms: z.ZodNullable<z.ZodNumber>;
+    exit_code: z.ZodNullable<z.ZodNumber>;
+    log_text: z.ZodNullable<z.ZodString>;
+    log_truncated: z.ZodBoolean;
+    input_tokens: z.ZodNullable<z.ZodNumber>;
+    output_tokens: z.ZodNullable<z.ZodNumber>;
+    cost_estimate_cents: z.ZodNullable<z.ZodNumber>;
+    error_message: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "success" | "failed" | "running" | "timeout" | "cancelled";
+    id: string;
+    created_at: string;
+    input_tokens: number | null;
+    output_tokens: number | null;
+    error_message: string | null;
+    run_id: string;
+    worker_id: string | null;
+    started_at: string;
+    finished_at: string | null;
+    duration_ms: number | null;
+    exit_code: number | null;
+    log_text: string | null;
+    log_truncated: boolean;
+    cost_estimate_cents: number | null;
+}, {
+    status: "success" | "failed" | "running" | "timeout" | "cancelled";
+    id: string;
+    created_at: string;
+    input_tokens: number | null;
+    output_tokens: number | null;
+    error_message: string | null;
+    run_id: string;
+    worker_id: string | null;
+    started_at: string;
+    finished_at: string | null;
+    duration_ms: number | null;
+    exit_code: number | null;
+    log_text: string | null;
+    log_truncated: boolean;
+    cost_estimate_cents: number | null;
+}>;
+export type RunExecution = z.infer<typeof runExecutionSchema>;
+export declare const deploySessionSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    upload_url: z.ZodString;
+    wizard_url: z.ZodString;
+    expires_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    expires_at: string;
+    session_id: string;
+    upload_url: string;
+    wizard_url: string;
+}, {
+    expires_at: string;
+    session_id: string;
+    upload_url: string;
+    wizard_url: string;
+}>;
+export type DeploySession = z.infer<typeof deploySessionSchema>;
+export interface RunExecuteJob {
+    run_id: string;
+    execution_id: string;
+    scheduled_at: string;
+}
+//# sourceMappingURL=run.schema.d.ts.map

package/dist/schemas/run.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/run.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;;;GAWG;AAKH,eAAO,MAAM,cAAc,oEAOzB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAKrD,eAAO,MAAM,qBAAqB,+DAMhC,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,eAAO,MAAM,eAAe,uDAK1B,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD,eAAO,MAAM,wBAAwB,qEAMnC,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAezE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsBjC,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAGrE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6B5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAG3D,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBpB,CAAA;AACF,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE3C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAGjE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgB7B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAO7D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;EAK9B,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAG/D,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;CACrB"}

package/dist/schemas/run.schema.js

@@ -0,0 +1,179 @@
+import { z } from 'zod';
+/**
+ * Run schemas — server-side scheduled Skill executions.
+ *
+ * The on-disk shape is split across three tables:
+ *
+ *   - `skill_bundles`   uploaded project folder (SKILL.md + scripts + .env)
+ *   - `runs`            schedule + agent + status for one deployment
+ *   - `run_executions`  append-only fire-history with logs and tokens
+ *
+ * (See supabase/migrations/049_runs_and_bundles.sql for the full
+ * column-level docstrings.)
+ */
+// ── Agent identifier ─────────────────────────────────────────────────
+// Same string set as the existing multi-agent feature. The runner
+// picks the matching CLI invocation per name.
+export const runAgentSchema = z.enum([
+    'claude',
+    'codex',
+    'cursor',
+    'gemini',
+    'cline',
+    'amp',
+]);
+// ── Schedule presets ─────────────────────────────────────────────────
+// The wizard picker only shows the presets; `custom` is a power-user
+// affordance exposed via the same form's "Advanced" twirl-down.
+export const runScheduleKindSchema = z.enum([
+    'hourly',
+    'daily',
+    'weekly',
+    'monthly',
+    'custom',
+]);
+export const runStatusSchema = z.enum([
+    'active',
+    'paused',
+    'failed',
+    'disabled',
+]);
+export const runExecutionStatusSchema = z.enum([
+    'running',
+    'success',
+    'failed',
+    'timeout',
+    'cancelled',
+]);
+// ── Schedule input ───────────────────────────────────────────────────
+//
+// The wizard sends one of:
+//
+//   { kind: 'hourly' }                                  → "0 * * * *"
+//   { kind: 'daily',   time: '08:00' }                  → "0 8 * * *"
+//   { kind: 'weekly',  time: '08:00', weekday: 1 }      → "0 8 * * 1"
+//   { kind: 'monthly', time: '08:00', day_of_month: 1 } → "0 8 1 * *"
+//   { kind: 'custom',  cron_expr: '*/15 * * * *' }
+//
+// The API service expands these into the canonical 5-field cron used
+// downstream. Timezone is captured separately so "daily at 08:00" lands
+// at the user's local 08:00 regardless of server location.
+export const runScheduleInputSchema = z.discriminatedUnion('kind', [
+    z.object({
+        kind: z.literal('hourly'),
+    }),
+    z.object({
+        kind: z.literal('daily'),
+        time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, 'HH:MM'),
+    }),
+    z.object({
+        kind: z.literal('weekly'),
+        time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, 'HH:MM'),
+        weekday: z.number().int().min(0).max(6),
+    }),
+    z.object({
+        kind: z.literal('monthly'),
+        time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, 'HH:MM'),
+        day_of_month: z.number().int().min(1).max(28),
+    }),
+    z.object({
+        kind: z.literal('custom'),
+        cron_expr: z.string().min(9).max(120),
+    }),
+]);
+// ── Bundle ───────────────────────────────────────────────────────────
+export const skillBundleSchema = z.object({
+    id: z.string().uuid(),
+    owner_id: z.string().uuid(),
+    skill_id: z.string().uuid().nullable(),
+    source: z.enum(['upload', 'github']),
+    tarball_path: z.string(),
+    manifest: z.array(z.object({
+        path: z.string(),
+        size: z.number().int().nonnegative(),
+        sha256: z.string(),
+        kind: z.enum(['text', 'binary', 'script']),
+    })),
+    total_size_bytes: z.number().int().nonnegative(),
+    has_scripts: z.boolean(),
+    has_env_template: z.boolean(),
+    secret_scan_status: z.enum(['pending', 'clean', 'rejected']),
+    secret_scan_findings: z
+        .array(z.object({
+        path: z.string(),
+        rule: z.string(),
+        line: z.number().int().nonnegative().optional(),
+    }))
+        .nullable(),
+    created_at: z.string().datetime(),
+    updated_at: z.string().datetime(),
+});
+// ── Run ──────────────────────────────────────────────────────────────
+export const runSchema = z.object({
+    id: z.string().uuid(),
+    owner_id: z.string().uuid(),
+    bundle_id: z.string().uuid(),
+    slug: z.string(),
+    name: z.string(),
+    agent: runAgentSchema,
+    schedule_kind: runScheduleKindSchema,
+    cron_expr: z.string(),
+    timezone: z.string(),
+    status: runStatusSchema,
+    timeout_seconds: z.number().int().positive(),
+    max_log_bytes: z.number().int().positive(),
+    next_run_at: z.string().datetime().nullable(),
+    last_run_at: z.string().datetime().nullable(),
+    last_exec_status: z
+        .enum(['success', 'failed', 'timeout', 'cancelled'])
+        .nullable(),
+    total_runs: z.number().int().nonnegative(),
+    total_failures: z.number().int().nonnegative(),
+    created_at: z.string().datetime(),
+    updated_at: z.string().datetime(),
+});
+export const createRunInputSchema = z.object({
+    bundle_id: z.string().uuid(),
+    name: z.string().min(1).max(120),
+    agent: runAgentSchema,
+    schedule: runScheduleInputSchema,
+    timezone: z.string().min(2).max(60).default('UTC'),
+    timeout_seconds: z.number().int().min(5).max(300).optional(),
+});
+export const updateRunInputSchema = z.object({
+    name: z.string().min(1).max(120).optional(),
+    agent: runAgentSchema.optional(),
+    schedule: runScheduleInputSchema.optional(),
+    timezone: z.string().optional(),
+    timeout_seconds: z.number().int().min(5).max(300).optional(),
+    status: z.enum(['active', 'paused']).optional(),
+});
+// ── Execution ────────────────────────────────────────────────────────
+export const runExecutionSchema = z.object({
+    id: z.string().uuid(),
+    run_id: z.string().uuid(),
+    worker_id: z.string().nullable(),
+    status: runExecutionStatusSchema,
+    started_at: z.string().datetime(),
+    finished_at: z.string().datetime().nullable(),
+    duration_ms: z.number().int().nullable(),
+    exit_code: z.number().int().nullable(),
+    log_text: z.string().nullable(),
+    log_truncated: z.boolean(),
+    input_tokens: z.number().int().nullable(),
+    output_tokens: z.number().int().nullable(),
+    cost_estimate_cents: z.number().int().nullable(),
+    error_message: z.string().nullable(),
+    created_at: z.string().datetime(),
+});
+// ── Deploy-CLI session ──────────────────────────────────────────────
+// The CLI's `prave deploy` flow uses a short-lived session token to
+// hand off the upload from the terminal to the browser wizard. The
+// API mints the session, the CLI uploads the tarball, the browser
+// claims the session and finalizes the Run.
+export const deploySessionSchema = z.object({
+    session_id: z.string(),
+    upload_url: z.string().url(),
+    wizard_url: z.string().url(),
+    expires_at: z.string().datetime(),
+});