@boxxy/server 0.0.1 → 0.1.3

package/dist/handlers/attempt-handlers.d.ts

@@ -0,0 +1,130 @@
+import type { AttemptRow } from '@boxxy/model';
+import type { ProvenCall } from '../types.ts';
+export declare const attemptHandlers: {
+    current: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: ProvenCall | null;
+    }, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"attempt">;
+        attempt: import("zod").ZodType<AttemptRow, unknown, import("zod/v4/core").$ZodTypeInternals<AttemptRow, unknown>>;
+        item: import("zod").ZodType<import("@boxxy/model").ItemView, unknown, import("zod/v4/core").$ZodTypeInternals<import("@boxxy/model").ItemView, unknown>>;
+        input: import("zod").ZodJSONSchema;
+        closeOut: import("zod").ZodObject<{
+            phase: import("zod").ZodString;
+            schema: import("zod").ZodJSONSchema;
+            outcomes: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        skills: import("zod").ZodObject<{
+            pin: import("zod").ZodNullable<import("zod").ZodObject<{
+                source: import("zod").ZodString;
+                ref: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+            names: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        notes: import("zod").ZodArray<import("zod").ZodObject<{
+            seq: import("zod").ZodNumber;
+            text: import("zod").ZodString;
+            at: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"refused">;
+        reason: import("zod").ZodEnum<{
+            "no-attempt": "no-attempt";
+            "not-current": "not-current";
+        }>;
+    }, import("zod/v4/core").$strip>], "kind">, Record<never, never>>;
+    closeOut: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: ProvenCall | null;
+    }, import("zod").ZodObject<{
+        session: import("zod").ZodObject<{
+            attempt: import("zod").ZodString;
+            agentSession: import("zod").ZodOptional<import("zod").ZodString>;
+            product: import("zod").ZodOptional<import("zod").ZodEnum<{
+                claude_code: "claude_code";
+                codex: "codex";
+            }>>;
+        }, import("zod/v4/core").$strip>;
+        closeOut: import("zod").ZodUnknown;
+    }, import("zod/v4/core").$strip>, import("zod").ZodType<import("@boxxy/model").CloseOutAnswer, unknown, import("zod/v4/core").$ZodTypeInternals<import("@boxxy/model").CloseOutAnswer, unknown>>, Record<never, never>>;
+    evidence: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: ProvenCall | null;
+    }, import("zod").ZodObject<{
+        session: import("zod").ZodObject<{
+            attempt: import("zod").ZodString;
+            agentSession: import("zod").ZodOptional<import("zod").ZodString>;
+            product: import("zod").ZodOptional<import("zod").ZodEnum<{
+                claude_code: "claude_code";
+                codex: "codex";
+            }>>;
+        }, import("zod/v4/core").$strip>;
+        kind: import("zod").ZodEnum<{
+            "ci-run": "ci-run";
+            "live-check": "live-check";
+            test: "test";
+        }>;
+        ref: import("zod").ZodString;
+        observed: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"recorded">;
+        factId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"refused">;
+        reason: import("zod").ZodEnum<{
+            "no-attempt": "no-attempt";
+            "not-current": "not-current";
+        }>;
+    }, import("zod/v4/core").$strip>], "kind">, Record<never, never>>;
+    bindSession: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: ProvenCall | null;
+    }, import("zod").ZodObject<{
+        session: import("zod").ZodObject<{
+            attempt: import("zod").ZodNonOptional<import("zod").ZodString>;
+            agentSession: import("zod").ZodNonOptional<import("zod").ZodOptional<import("zod").ZodString>>;
+            product: import("zod").ZodNonOptional<import("zod").ZodOptional<import("zod").ZodEnum<{
+                claude_code: "claude_code";
+                codex: "codex";
+            }>>>;
+        }, import("zod/v4/core").$strip>;
+        seenAt: import("zod").ZodISODateTime;
+        missingSkills: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodEnum<{
+            bound: "bound";
+            held: "held";
+            "no-attempt": "no-attempt";
+            "not-current": "not-current";
+            "skill-missing": "skill-missing";
+        }>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"fault">;
+        fault: import("zod").ZodLiteral<"agent-session-owned">;
+        holder: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>], "kind">, Record<never, never>>;
+    recordPullRequest: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: ProvenCall | null;
+    }, import("zod").ZodObject<{
+        session: import("zod").ZodObject<{
+            attempt: import("zod").ZodString;
+            agentSession: import("zod").ZodOptional<import("zod").ZodString>;
+            product: import("zod").ZodOptional<import("zod").ZodEnum<{
+                claude_code: "claude_code";
+                codex: "codex";
+            }>>;
+        }, import("zod/v4/core").$strip>;
+        url: import("zod").ZodURL;
+    }, import("zod/v4/core").$strip>, import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"linked">;
+        repo: import("zod").ZodString;
+        number: import("zod").ZodNumber;
+        repeat: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"retry">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"refused">;
+        reason: import("zod").ZodEnum<{
+            "linked-elsewhere": "linked-elsewhere";
+            "no-attempt": "no-attempt";
+            "not-a-pull-request-url": "not-a-pull-request-url";
+            "not-current": "not-current";
+        }>;
+    }, import("zod/v4/core").$strip>], "kind">, Record<never, never>>;
+};

package/dist/handlers/build-owner-fact.d.ts

@@ -0,0 +1,3 @@
+import type { ItemId, NewFact, WorkFacts } from '@boxxy/model';
+import type { ServerDeps } from '../types.ts';
+export declare function buildOwnerFact<Type extends keyof WorkFacts>(deps: ServerDeps, item: ItemId, type: Type, payload: WorkFacts[Type]): NewFact<Type>;

package/dist/handlers/item-handlers.d.ts

@@ -0,0 +1,168 @@
+import type { ItemView, NoteRow, RelationRow } from '@boxxy/model';
+export declare const itemHandlers: {
+    file: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        repo: import("zod").ZodString;
+        title: import("zod").ZodString;
+        outcome: import("zod").ZodString;
+        acceptance: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+        kind: import("zod").ZodOptional<import("zod").ZodString>;
+        designMode: import("zod").ZodOptional<import("zod").ZodEnum<{
+            agent: "agent";
+            attended: "attended";
+        }>>;
+        blockedBy: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+        labels: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        item: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, {
+        NOT_FOUND: {
+            message: string;
+            data: import("zod").ZodObject<{
+                item: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+    }>;
+    edit: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        item: import("zod").ZodString;
+        title: import("zod").ZodOptional<import("zod").ZodString>;
+        outcome: import("zod").ZodOptional<import("zod").ZodString>;
+        acceptance: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodOptional<import("zod").ZodString>;
+            text: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>>;
+        designMode: import("zod").ZodOptional<import("zod").ZodEnum<{
+            agent: "agent";
+            attended: "attended";
+        }>>;
+        labels: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        item: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, {
+        NOT_FOUND: {
+            message: string;
+            data: import("zod").ZodObject<{
+                item: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+    }>;
+    close: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        item: import("zod").ZodString;
+        reason: import("zod").ZodString;
+        of: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        item: import("zod").ZodString;
+        ended: import("zod").ZodArray<import("zod").ZodObject<{
+            attempt: import("zod").ZodString;
+            how: import("zod").ZodEnum<{
+                closing: "closing";
+                settled: "settled";
+            }>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, {
+        NOT_FOUND: {
+            message: string;
+            data: import("zod").ZodObject<{
+                item: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+    }>;
+    retry: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        item: import("zod").ZodString;
+        phase: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        lever: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>, {
+        NOT_FOUND: {
+            message: string;
+            data: import("zod").ZodObject<{
+                item: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        UNKNOWN_PHASE: {
+            message: string;
+        };
+    }>;
+    wake: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        item: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"requested">;
+        attempt: import("zod").ZodString;
+        atcSession: import("zod").ZodNullable<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"not-sleeping">;
+    }, import("zod/v4/core").$strip>], "kind">, {
+        NOT_FOUND: {
+            message: string;
+            data: import("zod").ZodObject<{
+                item: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+    }>;
+    note: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        item: import("zod").ZodString;
+        text: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        item: import("zod").ZodString;
+        seq: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>, {
+        NOT_FOUND: {
+            message: string;
+            data: import("zod").ZodObject<{
+                item: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+    }>;
+    get: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        item: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        item: import("zod").ZodType<ItemView, unknown, import("zod/v4/core").$ZodTypeInternals<ItemView, unknown>>;
+        notes: import("zod").ZodArray<import("zod").ZodType<NoteRow, unknown, import("zod/v4/core").$ZodTypeInternals<NoteRow, unknown>>>;
+        attempts: import("zod").ZodArray<import("zod").ZodType<import("@boxxy/model").AttemptRow, unknown, import("zod/v4/core").$ZodTypeInternals<import("@boxxy/model").AttemptRow, unknown>>>;
+        relations: import("zod").ZodArray<import("zod").ZodType<RelationRow, unknown, import("zod/v4/core").$ZodTypeInternals<RelationRow, unknown>>>;
+        evidence: import("zod").ZodArray<import("zod").ZodType<import("@boxxy/model").EvidenceRow, unknown, import("zod/v4/core").$ZodTypeInternals<import("@boxxy/model").EvidenceRow, unknown>>>;
+        pullRequests: import("zod").ZodArray<import("zod").ZodType<import("@boxxy/model").PullRequestRow, unknown, import("zod/v4/core").$ZodTypeInternals<import("@boxxy/model").PullRequestRow, unknown>>>;
+    }, import("zod/v4/core").$strip>, {
+        NOT_FOUND: {
+            message: string;
+            data: import("zod").ZodObject<{
+                item: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+    }>;
+    list: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        state: import("zod").ZodOptional<import("zod").ZodEnum<{
+            archived: "archived";
+            blocked: "blocked";
+            done: "done";
+            idea: "idea";
+            ready: "ready";
+            running: "running";
+            waiting: "waiting";
+        }>>;
+        repo: import("zod").ZodOptional<import("zod").ZodString>;
+        phase: import("zod").ZodOptional<import("zod").ZodString>;
+        text: import("zod").ZodOptional<import("zod").ZodString>;
+        label: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+        after: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        items: import("zod").ZodArray<import("zod").ZodType<ItemView, unknown, import("zod/v4/core").$ZodTypeInternals<ItemView, unknown>>>;
+        next: import("zod").ZodNullable<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, Record<never, never>>;
+};

package/dist/handlers/outbox-handlers.d.ts

@@ -0,0 +1,7 @@
+export declare const outboxHandlers: {
+    retry: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        unparked: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>, Record<never, never>>;
+};

package/dist/handlers/plan-handlers.d.ts

@@ -0,0 +1,62 @@
+export declare const planHandlers: {
+    defer: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        item: import("zod").ZodString;
+        until: import("zod").ZodOptional<import("zod").ZodISODateTime>;
+        reason: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        lever: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>, {
+        NOT_FOUND: {
+            message: string;
+            data: import("zod").ZodObject<{
+                item: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+    }>;
+    undefer: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        item: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        lever: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>, {
+        NOT_FOUND: {
+            message: string;
+            data: import("zod").ZodObject<{
+                item: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+    }>;
+    expedite: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        items: import("zod").ZodArray<import("zod").ZodString>;
+        reason: import("zod").ZodString;
+        expires: import("zod").ZodOptional<import("zod").ZodISODateTime>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        levers: import("zod").ZodArray<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>, {
+        NOT_FOUND: {
+            message: string;
+            data: import("zod").ZodObject<{
+                item: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+    }>;
+    unexpedite: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        item: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        lever: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>, {
+        NOT_FOUND: {
+            message: string;
+            data: import("zod").ZodObject<{
+                item: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+    }>;
+};

package/dist/handlers/read-item-ids.d.ts

@@ -0,0 +1,10 @@
+import type { ItemId, StoreReader } from '@boxxy/model';
+import type { ServerDeps } from '../types.ts';
+export type ItemIdsAnswer = {
+    readonly kind: 'found';
+    readonly items: ItemId[];
+} | {
+    readonly kind: 'not-found';
+    readonly item: string;
+};
+export declare function readItemIds(tx: StoreReader, deps: ServerDeps, raw: readonly string[]): Promise<ItemIdsAnswer>;

package/dist/handlers/relation-handlers.d.ts

@@ -0,0 +1,41 @@
+export declare const relationHandlers: {
+    add: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        source: import("zod").ZodString;
+        type: import("zod").ZodString;
+        target: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"added">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"refused">;
+        reason: import("zod").ZodEnum<{
+            cycle: "cycle";
+            exists: "exists";
+            "unknown-type": "unknown-type";
+        }>;
+    }, import("zod/v4/core").$strip>], "kind">, {
+        NOT_FOUND: {
+            message: string;
+            data: import("zod").ZodObject<{
+                item: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+    }>;
+    remove: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        source: import("zod").ZodString;
+        type: import("zod").ZodString;
+        target: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        removed: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>, {
+        NOT_FOUND: {
+            message: string;
+            data: import("zod").ZodObject<{
+                item: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+    }>;
+};

package/dist/handlers/report-handlers.d.ts

@@ -0,0 +1,102 @@
+export declare const reportHandlers: {
+    cost: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        item: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        landedAt: import("zod").ZodNullable<import("zod").ZodString>;
+        attempts: import("zod").ZodNumber;
+        lines: import("zod").ZodArray<import("zod").ZodObject<{
+            phase: import("zod").ZodString;
+            rework: import("zod").ZodBoolean;
+            product: import("zod").ZodString;
+            model: import("zod").ZodNullable<import("zod").ZodString>;
+            requests: import("zod").ZodNumber;
+            inputTokens: import("zod").ZodNumber;
+            cacheReadTokens: import("zod").ZodNumber;
+            cacheCreationTokens: import("zod").ZodNumber;
+            outputTokens: import("zod").ZodNumber;
+            costUSD: import("zod").ZodNullable<import("zod").ZodNumber>;
+            costBasis: import("zod").ZodEnum<{
+                none: "none";
+                reported: "reported";
+                turn: "turn";
+            }>;
+        }, import("zod/v4/core").$strip>>;
+        totals: import("zod").ZodObject<{
+            requests: import("zod").ZodNumber;
+            costUSD: import("zod").ZodNumber;
+            reworkCostUSD: import("zod").ZodNumber;
+            requestsWithoutCost: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+        item: import("zod").ZodString;
+        behind: import("zod").ZodObject<{
+            facts: import("zod").ZodNumber;
+            oldestAt: import("zod").ZodNullable<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, {
+        NOT_FOUND: {
+            message: string;
+            data: import("zod").ZodObject<{
+                item: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        PEPYS_NOT_CONFIGURED: {
+            message: string;
+        };
+        PEPYS_UNAVAILABLE: {
+            message: string;
+            data: import("zod").ZodObject<{
+                reason: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+    }>;
+    stageTimes: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        item: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        environment: import("zod").ZodString;
+        steps: import("zod").ZodArray<import("zod").ZodObject<{
+            step: import("zod").ZodEnum<{
+                build: "build";
+                deploy: "deploy";
+                design: "design";
+                merge: "merge";
+                release: "release";
+                review: "review";
+                triage: "triage";
+            }>;
+            minutes: import("zod").ZodNullable<import("zod").ZodNumber>;
+            endedAt: import("zod").ZodNullable<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        rework: import("zod").ZodObject<{
+            count: import("zod").ZodNumber;
+            minutes: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+        reviewWaitMinutes: import("zod").ZodNullable<import("zod").ZodNumber>;
+        sleepMinutes: import("zod").ZodNumber;
+        pullRequests: import("zod").ZodArray<import("zod").ZodString>;
+        item: import("zod").ZodString;
+        behind: import("zod").ZodObject<{
+            facts: import("zod").ZodNumber;
+            oldestAt: import("zod").ZodNullable<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, {
+        NOT_FOUND: {
+            message: string;
+            data: import("zod").ZodObject<{
+                item: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        PEPYS_NOT_CONFIGURED: {
+            message: string;
+        };
+        PEPYS_UNAVAILABLE: {
+            message: string;
+            data: import("zod").ZodObject<{
+                reason: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+    }>;
+};

package/dist/handlers/rules-handlers.d.ts

@@ -0,0 +1,20 @@
+export declare const rulesHandlers: {
+    dryRun: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{
+        rules: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"loaded">;
+        version: import("zod").ZodString;
+        moved: import("zod").ZodNumber;
+        items: import("zod").ZodArray<import("zod").ZodObject<{
+            item: import("zod").ZodString;
+            now: import("zod").ZodType<import("@boxxy/model").Position, unknown, import("zod/v4/core").$ZodTypeInternals<import("@boxxy/model").Position, unknown>>;
+            then: import("zod").ZodType<import("@boxxy/model").Position, unknown, import("zod/v4/core").$ZodTypeInternals<import("@boxxy/model").Position, unknown>>;
+            moved: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"rejected">;
+        rejections: import("zod").ZodArray<import("zod").ZodType<import("@boxxy/model").LoadRejection, unknown, import("zod/v4/core").$ZodTypeInternals<import("@boxxy/model").LoadRejection, unknown>>>;
+    }, import("zod/v4/core").$strip>], "kind">, Record<never, never>>;
+};

package/dist/handlers/runner-handlers.d.ts

@@ -0,0 +1,65 @@
+import type { AttemptRow } from '@boxxy/model';
+export declare const runnerHandlers: {
+    status: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        paused: import("zod").ZodBoolean;
+        limits: import("zod").ZodArray<import("zod").ZodType<import("@boxxy/model").LimitFill, unknown, import("zod/v4/core").$ZodTypeInternals<import("@boxxy/model").LimitFill, unknown>>>;
+        attempts: import("zod").ZodArray<import("zod").ZodObject<{
+            attempt: import("zod").ZodType<AttemptRow, unknown, import("zod/v4/core").$ZodTypeInternals<AttemptRow, unknown>>;
+            title: import("zod").ZodString;
+            waitingSince: import("zod").ZodNullable<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+        strays: import("zod").ZodArray<import("zod").ZodType<AttemptRow, unknown, import("zod/v4/core").$ZodTypeInternals<AttemptRow, unknown>>>;
+        notices: import("zod").ZodObject<{
+            unsent: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+        outbox: import("zod").ZodObject<{
+            sink: import("zod").ZodEnum<{
+                none: "none";
+                pepys: "pepys";
+            }>;
+            state: import("zod").ZodEnum<{
+                "backing-off": "backing-off";
+                blocked: "blocked";
+                idle: "idle";
+                off: "off";
+                sending: "sending";
+            }>;
+            unsent: import("zod").ZodNumber;
+            parked: import("zod").ZodNumber;
+            lag: import("zod").ZodNullable<import("zod").ZodNumber>;
+            failingSince: import("zod").ZodNullable<import("zod").ZodNumber>;
+            nextTryAt: import("zod").ZodNullable<import("zod").ZodNumber>;
+            lastError: import("zod").ZodNullable<import("zod").ZodObject<{
+                kind: import("zod").ZodEnum<{
+                    "refused-batch": "refused-batch";
+                    "refused-sink": "refused-sink";
+                    retry: "retry";
+                }>;
+                status: import("zod").ZodNullable<import("zod").ZodNumber>;
+                message: import("zod").ZodString;
+                at: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            lastStoredAt: import("zod").ZodNullable<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        rules: import("zod").ZodObject<{
+            version: import("zod").ZodString;
+            commit: import("zod").ZodString;
+            lastRejected: import("zod").ZodNullable<import("zod").ZodObject<{
+                commit: import("zod").ZodString;
+                rejections: import("zod").ZodArray<import("zod").ZodType<import("@boxxy/model").LoadRejection, unknown, import("zod/v4/core").$ZodTypeInternals<import("@boxxy/model").LoadRejection, unknown>>>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, Record<never, never>>;
+    pause: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        paused: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>>;
+    resume: import("@orpc/server").ImplementedProcedure<import("../types.ts").RequestContext & object, {
+        call: import("../types.ts").ProvenCall | null;
+    }, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        paused: import("zod").ZodLiteral<false>;
+    }, import("zod/v4/core").$strip>, Record<never, never>>;
+};

package/dist/handlers/to-wire-json.d.ts

@@ -0,0 +1,5 @@
+import type { JsonValue } from '@boxxy/model';
+export type WireJSON = null | boolean | number | string | WireJSON[] | {
+    [key: string]: WireJSON;
+};
+export declare function toWireJSON(value: JsonValue): WireJSON;

package/dist/handlers/write-levers.d.ts

@@ -0,0 +1,11 @@
+import type { LeverRow } from '@boxxy/model';
+import type { ServerDeps } from '../types.ts';
+export type LeverDraft = Pick<LeverRow, 'kind' | 'until' | 'expiresAt' | 'reason' | 'phase'>;
+export type LeverAnswer = {
+    readonly kind: 'recorded';
+    readonly levers: readonly number[];
+} | {
+    readonly kind: 'not-found';
+    readonly item: string;
+};
+export declare function writeLevers(deps: ServerDeps, items: readonly string[], draft: LeverDraft): Promise<LeverAnswer>;